Automatic verification of finite-state concurrent systems using temporal logic specifications
ACM Transactions on Programming Languages and Systems (TOPLAS)
Compilers: principles, techniques, and tools
Compilers: principles, techniques, and tools
Computation tree logic CTL* and path quantifiers in the monadic theory of the binary tree
14th International Colloquium on Automata, languages and programming
Abstract interpretation of declarative languages
Abstract interpretation of declarative languages
The formal semantics of programming languages: an introduction
The formal semantics of programming languages: an introduction
Optimal code motion: theory and practice
ACM Transactions on Programming Languages and Systems (TOPLAS)
Abstract interpretation: a semantics-based tool for program analysis
Handbook of logic in computer science (vol. 4)
Lightweight closure conversion
ACM Transactions on Programming Languages and Systems (TOPLAS)
Proceedings of the 24th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Data flow analysis is model checking of abstract interpretations
POPL '98 Proceedings of the 25th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Advanced compiler design and implementation
Advanced compiler design and implementation
POPL '77 Proceedings of the 4th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
Semantics-Directed Compiler Generation: Proceedings
Semantics-Directed Compiler Generation: Proceedings
Flow Analysis of Computer Programs
Flow Analysis of Computer Programs
Principles of Program Analysis
Principles of Program Analysis
Program Flow Analysis: Theory and Application
Program Flow Analysis: Theory and Application
A Theory of Programming Language Semantics
A Theory of Programming Language Semantics
CONCUR '95 Proceedings of the 6th International Conference on Concurrency Theory
On the Relation of Programs and Computations to Models of Temporal Logic
Temporal Logic in Specification
LICS '95 Proceedings of the 10th Annual IEEE Symposium on Logic in Computer Science
A temporal logic for reasoning about partially ordered computations (Extended Abstract)
PODC '84 Proceedings of the third annual ACM symposium on Principles of distributed computing
Efficient Code Certification
Universal Regular Path Queries
Higher-Order and Symbolic Computation
Automatically proving the correctness of compiler optimizations
PLDI '03 Proceedings of the ACM SIGPLAN 2003 conference on Programming language design and implementation
The essence of computation
Structure-preserving binary relations for program abstraction
The essence of computation
Iterative-free program analysis
ICFP '03 Proceedings of the eighth ACM SIGPLAN international conference on Functional programming
Simple relational correctness proofs for static analyses and program transformations
Proceedings of the 31st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Incremental execution of transformation specifications
Proceedings of the 31st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Compiler Optimization Correctness by Temporal Logic
Higher-Order and Symbolic Computation
Imperative program optimization by partial evaluation
Proceedings of the 2004 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
Slot games: a quantitative model of computation
Proceedings of the 32nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Automated soundness proofs for dataflow analyses and transformations via local rules
Proceedings of the 32nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Formal validation of pattern matching code
PPDP '05 Proceedings of the 7th ACM SIGPLAN international conference on Principles and practice of declarative programming
JunGL: a scripting language for refactoring
Proceedings of the 28th international conference on Software engineering
An approach toward profit-driven optimization
ACM Transactions on Architecture and Code Optimization (TACO)
Using Verified Data-Flow Analysis-based Optimizations in Attribute Grammars
Electronic Notes in Theoretical Computer Science (ENTCS)
Structuring Optimizing Transformations and Proving Them Sound
Electronic Notes in Theoretical Computer Science (ENTCS)
Generating Java Compiler Optimizers Using Bidirectional CTL
Electronic Notes in Theoretical Computer Science (ENTCS)
Automated refinement checking of concurrent systems
Proceedings of the 2007 IEEE/ACM international conference on Computer-aided design
Imperative-program transformation by instrumented-interpreter specialization
Higher-Order and Symbolic Computation
Validating High-Level Synthesis
CAV '08 Proceedings of the 20th international conference on Computer Aided Verification
Validation of GCC optimizers through trace generation
Software—Practice & Experience
From Specification to Optimisation: An Architecture for Optimisation of Java Bytecode
CC '09 Proceedings of the 18th International Conference on Compiler Construction: Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2009
A Framework for Exploring Optimization Properties
CC '09 Proceedings of the 18th International Conference on Compiler Construction: Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2009
Formalising and Verifying Reference Attribute Grammars in Coq
ESOP '09 Proceedings of the 18th European Symposium on Programming Languages and Systems: Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2009
Proving optimizations correct using parameterized program equivalence
Proceedings of the 2009 ACM SIGPLAN conference on Programming language design and implementation
SAS '09 Proceedings of the 16th International Symposium on Static Analysis
Safe composition of non-monotonic features
GPCE '09 Proceedings of the eighth international conference on Generative programming and component engineering
Silver: An extensible attribute grammar system
Science of Computer Programming
A Formally Verified Compiler Back-end
Journal of Automated Reasoning
Cobalt: A Language for Writing Provably-Sound Compiler Optimizations
Electronic Notes in Theoretical Computer Science (ENTCS)
The semantics of "semantic patches" in Coccinelle: program transformation for the working programmer
APLAS'07 Proceedings of the 5th Asian conference on Programming languages and systems
Internal and external logics of abstract interpretations
VMCAI'08 Proceedings of the 9th international conference on Verification, model checking, and abstract interpretation
Translation validation of high-level synthesis
IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems
The essence of compiling with traces
Proceedings of the 38th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
On the correctness of transformations in compiler back-ends
ISoLA'04 Proceedings of the First international conference on Leveraging Applications of Formal Methods
Catching and identifying bugs in register allocation
SAS'06 Proceedings of the 13th international conference on Static Analysis
A framework for formal verification of compiler optimizations
ITP'10 Proceedings of the First international conference on Interactive Theorem Proving
A framework for the checking and refactoring of crosscutting concepts
ACM Transactions on Software Engineering and Methodology (TOSEM)
| Hi-index | 0.00 |
Many classical compiler optimizations can be elegantly expressed using rewrite rules of form: I ⇒ I′ if &phis;, where I, I′ are intermediate language instructions and &phis; is a property expressed in a temporal logic suitable for describing program data flow. Its reading: If the current program π contains an instruction of form I at some control point p, and if flow condition &phis; is satisfied at p, then replace I by I′.The purpose of this paper is to show how such transformations may be proven correct. Our methodology is illustrated by three familiar optimizations, dead code elimination, constant folding and code motion. The meaning of correctness is that for any program π, if Rewrite(π, π′, p,I ⇒ I′ if &phis;) then [[π]] = [[π′]], i.e. π and π′ have exactly the same semantics.