## Proving correctness of compiler optimizations by temporal logic (2002)

### Cached

### Download Links

- [www.cs.umn.edu]
- [www.eecs.umich.edu]
- [www.cs.umn.edu]
- [www.dcs.warwick.ac.uk]
- [ftp.diku.dk]
- [web.comlab.ox.ac.uk]
- [repository.readscheme.org]
- DBLP

### Other Repositories/Bibliography

Citations: | 55 - 5 self |

### BibTeX

@INPROCEEDINGS{Lacey02provingcorrectness,

author = {David Lacey and Neil D. Jones},

title = {Proving correctness of compiler optimizations by temporal logic},

booktitle = {},

year = {2002},

pages = {283--294},

publisher = {ACM Press}

}

### Years of Citing Articles

### OpenURL

### Abstract

### Citations

1995 |
Abstract interpretation: A unified lattice model for static analysis of programs by construction or approximation of fixpoints
- Cousot, Cousot
- 1977
(Show Context)
Citation Context ... transformation correctness must, by its very nature, be a semantics-based endeavor. 1.2 Semantics-based program manipulation Much has happened in this field since the path-breaking 1977 Cousot paper =-=[5] and 1980 -=-conference [11]. The field of "abstract interpretation" [1, 5, 6, 13, 23, 25] arose as a mainly European, theory-based counterpart to the welldeveloped more pragmatic North American approach... |

1240 | Automatic verification of finite-state concurrent systems using temporal logic specifications
- Clarke, Emerson, et al.
- 1986
(Show Context)
Citation Context ... are defined at that point (i.e. assigned by := or read). 2.3 CTL with free variables The temporal logic CTL-FV used in specifying transformation conditions is in two respects a generalization of CTL =-=[3]-=-. First, as is common, the temporal path quantifiers E and A are extended to also quantify over backwards paths in the obvious way. Our notation for this: - E and - A . These paths may be finite and o... |

1155 | Proof-carrying code
- Necula
- 1997
(Show Context)
Citation Context ...the results in the paper are not directly applicable to compilers since no automatic method is given for applying the optimizations described, they are however applicable to proof carrying code (PCC) =-=[22]-=- and e#cient code certification (ECC) [15], as Kozen and Patron state. In ECC, an optimized program contains a proof verifying that the transformations applied to it were sound, in which case proofs a... |

1023 |
Advanced Compiler Design and Implementation
- Muchnick
- 1997
(Show Context)
Citation Context ...tation with the same final answer; and vice versa. 1.1 Compiler optimizing transformations A great many program transformations are done by optimizing compilers; an exhaustive catalog may be found in =-=[20]-=-. These have been a great success pragmatically, so it is important that there be no serious doubt of their correctness: that transformed programs are always semantically equivalent to those from whic... |

570 | Principles of Program Analysis
- Nielson, Nielson, et al.
- 1999
(Show Context)
Citation Context ...based endeavor. 1.2 Semantics-based program manipulation Much has happened in this field since the path-breaking 1977 Cousot paper [5] and 1980 conference [11]. The field of "abstract interpretat=-=ion" [1, 5, 6, 13, 23, 25]-=- arose as a mainly European, theory-based counterpart to the welldeveloped more pragmatic North American approach to program analysis [2, 10, 21]. The goal of semantics-based program manipulation ([12... |

285 |
Flow Analysis of Computer Programs
- Hecht
- 1977
(Show Context)
Citation Context ...[11]. The field of "abstract interpretation" [1, 5, 6, 13, 23, 25] arose as a mainly European, theory-based counterpart to the welldeveloped more pragmatic North American approach to program=-= analysis [2, 10, 21]-=-. The goal of semantics-based program manipulation ([12] and the PEPM conference series) is to place program analysis and transformation on a solid foundation in the semantics of programming languages... |

248 |
The Formal Semantics of Programming Languages
- Winskel
- 1993
(Show Context)
Citation Context ...ong three "actors": the condition that enables applying the transformation and the semantics of the subject program both before and after transformation. Denotational and operational semanti=-=cs (e.g., [33]-=-) typically present many example proofs of equivalences between program fragments. However most of these are small (excepting the monumental and indigestible [19]), and their purpose is mainly to illu... |

159 |
Abstract interpretation: A uni lattice model for static analysis of programs by construction or approximation of
- Cousot, Cousot
(Show Context)
Citation Context ...ng methods that are mathematically rather more sophisticated than those of this paper. 1.2 Semantics-based program manipulation Much has happened in thisseld since the path-breaking 1977 Cousot paper =-=[5] and -=-1980 conference [9]. Theseld of \abstract interpretation" [1, 5, 6, 11, 17, 19] arose as a mainly European, theory-based counterpart to the welldeveloped more pragmatic North American approach to... |

119 |
editors. Abstract Interpretation of Declarative Languages
- Abramsky, Henkin
- 1987
(Show Context)
Citation Context ...based endeavor. 1.2 Semantics-based program manipulation Much has happened in this field since the path-breaking 1977 Cousot paper [5] and 1980 conference [11]. The field of "abstract interpretat=-=ion" [1, 5, 6, 13, 23, 25]-=- arose as a mainly European, theory-based counterpart to the welldeveloped more pragmatic North American approach to program analysis [2, 10, 21]. The goal of semantics-based program manipulation ([12... |

112 | Optimal code motion: Theory and practice
- Riithing, Steffen
- 1994
(Show Context)
Citation Context ... showed that temporal logic is well-suited to describing data dependencies and other program properties exploited in classical compiler optimizations. In particular, work by Knoop, Ste#en and Ruthing =-=[14]-=- showed that new insights could be gained from using temporal logic, enabling new and stronger code motion algorithms, now part of several commercial compilers. More relevant to this paper: The code m... |

102 |
Data flow analysis is model checking of abstract interpretations
- Schmidt
- 1998
(Show Context)
Citation Context ... more appropriate for traditional intermediate-code optimizations. 1.4 Model checking and program analysis This situation has improved with the advent of model checking approaches to program analysis =-=[4, 27, 29, 30, 32, 28]-=-. Work by Ste#en and Schmidt [29, 30] showed that temporal logic is well-suited to describing data dependencies and other program properties exploited in classical compiler optimizations. In particula... |

91 |
Semantic foundations of program analysis
- Cousot
- 1981
(Show Context)
Citation Context ...based endeavor. 1.2 Semantics-based program manipulation Much has happened in this field since the path-breaking 1977 Cousot paper [5] and 1980 conference [11]. The field of "abstract interpretat=-=ion" [1, 5, 6, 13, 23, 25]-=- arose as a mainly European, theory-based counterpart to the welldeveloped more pragmatic North American approach to program analysis [2, 10, 21]. The goal of semantics-based program manipulation ([12... |

89 | Abstract interpretation: A semantics-based tool for program analysis
- Jones, Nielson
- 1994
(Show Context)
Citation Context |

86 | A Theory of Programming Language Semantics - Milne, Strachey - 1976 |

77 | Lightweight Closure Conversion
- Steckler, Wand
- 1997
(Show Context)
Citation Context ...ut no goto statements, whereas we do not make this restriction. Some transformation correctness proofs have been made for functional languages, especially the work by Wand and colleagues, for example =-=[31], using &q-=-uot;logical relations." These methods are mathematically rather more sophisticated than those of this paper, which seem more appropriate for traditional intermediate-code optimizations. 1.4 Model... |

72 |
Automatic veri of concurrent systems using temporal logic
- Clarke, Emerson, et al.
- 1986
(Show Context)
Citation Context ...pplied. These conditions are specied as CTL-FV formulas. 2.3 CTL with free variables The temporal logic CTL-FV used in specifying transformation conditions is in two respects a generalization of CTL [=-=3-=-]. First, as is common, the temporal path quantiers E and A are extended to also quantify over backwards paths in the obvious way. Our notation for this: E and A . These paths may besnite and our quan... |

70 |
Program Flow Analysis: Theory and Application
- Muchnick, Jones
- 1981
(Show Context)
Citation Context ...[11]. The field of "abstract interpretation" [1, 5, 6, 13, 23, 25] arose as a mainly European, theory-based counterpart to the welldeveloped more pragmatic North American approach to program=-= analysis [2, 10, 21]-=-. The goal of semantics-based program manipulation ([12] and the PEPM conference series) is to place program analysis and transformation on a solid foundation in the semantics of programming languages... |

65 | Program analysis as model checking of abstract interpretations
- Schmidt, Steffen
- 1998
(Show Context)
Citation Context ... more appropriate for traditional intermediate-code optimizations. 1.4 Model checking and program analysis This situation has improved with the advent of model checking approaches to program analysis =-=[4, 27, 29, 30, 32, 28]-=-. Work by Ste#en and Schmidt [29, 30] showed that temporal logic is well-suited to describing data dependencies and other program properties exploited in classical compiler optimizations. In particula... |

54 |
Computation tree logic CTL and path quantifiers in the monadic theory of the binary tree
- Hafer, Thomas
- 1987
(Show Context)
Citation Context ... That is, we consider a branching notion of past which may be either finite, as in CTLbp [17], or infinte, as in POTL [26, 34]. A branching past is more appropriate here than the linear past in PCTL# =-=[8]-=- which can also be used to augement branching time logics with past time operators. Second, propositions are generalized to predicates over free variables. (A traditional atomic proposition is simply ... |

53 |
On the relation of programs and computations to models of temporal logic
- Wolper
- 1995
(Show Context)
Citation Context ...nd our quantifications over paths are thus over infinite and maximal finite paths. That is, we consider a branching notion of past which may be either finite, as in CTLbp [17], or infinte, as in POTL =-=[26, 34]-=-. A branching past is more appropriate here than the linear past in PCTL# [8] which can also be used to augement branching time logics with past time operators. Second, propositions are generalized to... |

38 | Efficient code certification
- Kozen
- 1998
(Show Context)
Citation Context ...applicable to compilers since no automatic method is given for applying the optimizations described, they are however applicable to proof carrying code (PCC) [22] and e#cient code certification (ECC) =-=[15]-=-, as Kozen and Patron state. In ECC, an optimized program contains a proof verifying that the transformations applied to it were sound, in which case proofs about specific instances are exactly what i... |

37 | Imperative program transformation by rewriting
- Lacey, Moor
- 2001
(Show Context)
Citation Context ...s. More relevant to this paper: The code motion transformations could be proven correct. 1.5 Model checking and program transformation In this paper we give a formalism (essentially it is a subset of =-=[18]-=-) for succinctly expressing program transformations, making use of temporal logic; and use this formalism to prove the universal correctness (semantics preservation for all programs) of the three opti... |

35 | Certification of compiler optimizations using Kleene algebra with tests
- Kozen, Patron
- 2000
(Show Context)
Citation Context ...s scope (and would have been impractically complex in a denotational framework, witness [19]). Another approach to verifying the correctness of compiler optimizations is presented by Kozen and Patron =-=[16]-=-. Using an extension of Kleene algebra, Kleene algebra with tests (KAT), an extensive collection of instances of program transformations are proven correct, i.e. a concrete optimization is proven corr... |

34 |
A Denotational Framework for Data Flow Analysis
- Nielson
- 1982
(Show Context)
Citation Context |

32 |
A temporal logic for reasoning about partially ordered computations
- Pinter, Wolper
- 1984
(Show Context)
Citation Context ...nd our quantifications over paths are thus over infinite and maximal finite paths. That is, we consider a branching notion of past which may be either finite, as in CTLbp [17], or infinte, as in POTL =-=[26, 34]-=-. A branching past is more appropriate here than the linear past in PCTL# [8] which can also be used to augement branching time logics with past time operators. Second, propositions are generalized to... |

26 | Once and for all
- Kupferman, Pnueli
(Show Context)
Citation Context .... These paths may be finite and our quantifications over paths are thus over infinite and maximal finite paths. That is, we consider a branching notion of past which may be either finite, as in CTLbp =-=[17]-=-, or infinte, as in POTL [26, 34]. A branching past is more appropriate here than the linear past in PCTL# [8] which can also be used to augement branching time logics with past time operators. Second... |

15 | The Fixpoint Analysis Machine
- Steffen, Claßen, et al.
- 1995
(Show Context)
Citation Context ... more appropriate for traditional intermediate-code optimizations. 1.4 Model checking and program analysis This situation has improved with the advent of model checking approaches to program analysis =-=[4, 27, 29, 30, 32, 28]-=-. Work by Ste#en and Schmidt [29, 30] showed that temporal logic is well-suited to describing data dependencies and other program properties exploited in classical compiler optimizations. In particula... |

9 | Correctness of classical compiler optimizations using CTL
- Frederiksen
- 2001
(Show Context)
Citation Context ...mations correct, though, but rather to establish a framework within which a wide spectrum of classical compiler optimizations can be validated. More instances of this paper's approach may be found in =-=[7]-=-. Many optimizing transformations can be elegantly expressed using rewrite rules of form: I =# I # if #, where I, I # are intermediate language instructions and # is a property expressed in a temporal... |

7 |
Using model checking in a parallelizing compiler. Parallel Processing Letters
- Rus, Wyk
- 1998
(Show Context)
Citation Context |

5 |
Semantic Foundations of Data Flow Analysis
- Nielson
- 1981
(Show Context)
Citation Context ...n" and "strength reduction." Few formal proofs have been made of correctness of such transformations. Two works relating the semantics-based approaches to transformation correctness: Ni=-=elson's thesis [24] has an un-=-published chapter proving correctness of "constant folding" perhaps omitted from the journal paper [23], because of the complexity of its development and proof. Havelund's thesis [9] careful... |

1 |
Stepwise Development of a Denotational Stack Semantics
- Havelund
- 1984
(Show Context)
Citation Context ...thesis [24] has an unpublished chapter proving correctness of "constant folding" perhaps omitted from the journal paper [23], because of the complexity of its development and proof. Havelund=-='s thesis [9]-=- carefully explores semantic aspects of transformations from a Pascal-like mini-language into typical stack-based imperative intermediate code, but correctness proofs were out of its scope (and would ... |

1 |
Semantique: Semantic-Based Program Manipulation Techniques
- Jones
- 1989
(Show Context)
Citation Context ...25] arose as a mainly European, theory-based counterpart to the welldeveloped more pragmatic North American approach to program analysis [2, 10, 21]. The goal of semantics-based program manipulation (=-=[12]-=- and the PEPM conference series) is to place program analysis and transformation on a solid foundation in the semantics of programming languages, making it possible to prove that analyses are sound an... |

1 |
Schloss Ringberg Seminar: Model Checking and Program Analysis. Workshop
- Podelski, Steen, et al.
- 2000
(Show Context)
Citation Context |

1 |
Imperative Program Transformation by Rewriting. Compiler Construction
- Lacey, Moor
- 2001
(Show Context)
Citation Context ...l compilers. More relevant to this paper: The code motion transformations could be proven correct. 1.4 Model-checking and program transformation In this paper we give a formalism (essentially that of =-=[13]-=-) for succinctly expressing program transformations, making use of temporal logic; and use this formalism to prove the universal correctness (semantics preservation for all programs) of the three opti... |