Compiler Optimization Correctness by Temporal Logic

Lacey, David; Jones, Neil D.; Wyk, Eric Van; Frederiksen, Carl Christian

doi:10.1023/b:lisp.0000029444.99264.c0

Cited by 28 publications

(15 citation statements)

References 37 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…We have extended Gordon's LTS semantics to incorporate additional language constructs and also to allow terms that contain free variables. Bisimulation has previously been used to prove the correctness of program transformations for imperative languages, which lend themselves more naturally to a labelled transition system semantics [11]. The focus of all the previous work on applying bisimulation techniques to functional programs was not on proving the correctness of program transformations.…”

Section: Theorem 3 (Correctness Of Folding)mentioning

confidence: 99%

Proving the Correctness of Unfold/Fold Program Transformations Using Bisimulation

Hamilton

Jones

2012

Perspectives of Systems Informatics

Self Cite

View full text Add to dashboard Cite

Abstract. This paper shows that a bisimulation approach can be used to prove the correctness of unfold/fold program transformation algorithms. As an illustration, we show how our approach can be use to prove the correctness of positive supercompilation (due to Sørensen et al). Traditional program equivalence proofs show the original and transformed programs are contextually equivalent, i.e., have the same termination behaviour in all closed contexts. Contextual equivalence can, however, be difficult to establish directly. Gordon and Howe use an alternative approach: to represent a program's behaviour by a labelled transition system whose bisimilarity relation is a congruence that coincides with contextual equivalence. Labelled transition systems are well-suited to represent global program behaviour. On the other hand, unfold/fold program transformations use generalization and folding, and neither is easy to describe contextually, due to use of non-local information. We show that weak bisimulation on labelled transition systems gives an elegant framework to prove contextual equivalence of original and transformed programs. One reason is that folds can be seen in the context of corresponding unfolds.

show abstract

Section: Theorem 3 (Correctness Of Folding)mentioning

confidence: 99%

Proving the Correctness of Unfold/Fold Program Transformations Using Bisimulation

Hamilton

Jones

2012

Perspectives of Systems Informatics

Self Cite

View full text Add to dashboard Cite

show abstract

“…Cobalt can then either interpret the optimization or produce proof obligations for it to be correct (semantics-preserving). The formalism and techniques used for this were previously used to prove optimizations correct manually by Lacey et al [91]. For correctness conditions to be generated, each analysis must specify the semantic property that it represents for each program point.…”

Section: Program Semantics and Abstract Interpretation A Number Of Smentioning

confidence: 99%

A Language for Specifying Compiler Optimizations for Generic Software

Lumsdaine

Willcock

2007

View full text Add to dashboard Cite

would not have been exposed to either generic programming or programming languages to the level that I have. He has also shown me in detail how to perform research and write high-quality papers, and I am grateful to be able to benefit from his experience in these areas.I am also grateful to my mentor at Lawrence Livermore National Laboratory, Daniel Quinlan, for aid in creating the thesis and support in both software development and writing the thesis. The ROSE framework, of which he is the main developer, was invaluable in applying the work in this thesis to commonly used programming languages. On the other hand, software libraries have also been recognized as potentially aiding in program optimization. One proposed implementation of library-based optimization is to allow the library author, or a library user, to define custom analyses and optimizations. Only limited systems have been created to take advantage of this potential, however. One problem in creating a framework for defining new optimizations and analyses is how users are to specify them: implementing them by hand inside a compiler is difficult and prone to errors. Thus, a domain-specific language for librarybased compiler optimizations would be beneficial. Many optimization specification languages have appeared in the literature, but they tend to be either limited in power or unnecessarily difficult to use. Therefore, I have designed, implemented, and evaluated the Pavilion language for specifying program analyses and optimizations, designed for library authors and users. These analyses and optimizations can be based on the implementation of a particular library, its use in a specific program, or on the properties of a broad range of types, expressed through concepts. The new system is intended to provide a high level of expressiveness, even though the intended users are unlikely to be compiler experts.viii

show abstract

“…Recently, program matching languages that combine descriptions of code fragments with information about the control-flow paths between them have been found useful in specifying rules for program manipulation tasks such as compiler optimizations [16,17], bug finding [10], refactorings [24], and evolution [20].…”

Section: Introductionmentioning

confidence: 99%

“…CTL model checking [7,12] is then used to find the nodes in the control-flow graph that satisfy the formula, thus identifying where the pattern matches in the program. To support the specification of compiler optimizations, Lacey and De Moor extended CTL first with predicates over free variables, producing the logic CTL-FV [17], and then with predicates over variables that may be existentially quantified, producing a logic that we refer to as CTL-V [15]. The former allows collecting information about the program during the matching process, via variable bindings, and imposing constraints on the allowed subterms when a given variable is matched more than once.…”

Section: Introductionmentioning

confidence: 99%

“…First, we briefly review the syntax, semantics, and algorithmic implementation of the well-known Computational Tree Logic (CTL) [7]. Next, we present a variant of CTL called CTL-FV (CTL with free variables) used by Lacey et al to show the correctness of some classical compiler optimizations [17]. Finally, we present CTL-V (CTL with variables), a CTL variant with existentially quantified variables that was used in Lacey's subsequent work [15], and formally define its semantics.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

A foundation for flow-based program matching

Brunel

Doligez

Hansen

et al. 2009

Proceedings of the 36th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages

View full text Add to dashboard Cite

Reasoning about program control-flow paths is an important functionality of a number of recent program matching languages and associated searching and transformation tools. Temporal logic provides a well-defined means of expressing properties of control-flow paths in programs, and indeed an extension of the temporal logic CTL has been applied to the problem of specifying and verifying the transformations commonly performed by optimizing compilers. Nevertheless, in developing the Coccinelle program transformation tool for performing Linux collateral evolutions in systems code, we have found that existing variants of CTL do not adequately support rules that transform subterms other than the ones matching an entire formula. Being able to transform any of the subterms of a matched term seems essential in the domain targeted by Coccinelle.In this paper, we propose an extension to CTL named CTL-VW (CTL with variables and witnesses) that is a suitable basis for the semantics and implementation of the Coccinelle's program matching language. Our extension to CTL includes existential quantification over program fragments, which allows metavariables in the program matching language to range over different values within different control-flow paths, and a notion of witnesses that record such existential bindings for use in the subsequent program transformation process. We formalize CTL-VW and describe its use in the context of Coccinelle. We then assess the performance of the approach in practice, using a transformation rule that fixes several reference count bugs in Linux code.

show abstract

Compiler Optimization Correctness by Temporal Logic

Cited by 28 publications

References 37 publications

Proving the Correctness of Unfold/Fold Program Transformations Using Bisimulation

Proving the Correctness of Unfold/Fold Program Transformations Using Bisimulation

A Language for Specifying Compiler Optimizations for Generic Software

A foundation for flow-based program matching

Contact Info

Product

Resources

About