A mechanically verified code generator
Journal of Automated Reasoning
Sharlit—a tool for building optimizers
PLDI '92 Proceedings of the ACM SIGPLAN 1992 conference on Programming language design and implementation
Automatic generation and management of interprocedural program analyses
POPL '93 Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
VLISP: a verified implementation of Scheme
Lisp and Symbolic Computation
Commutativity analysis: a new analysis framework for parallelizing compilers
PLDI '96 Proceedings of the ACM SIGPLAN 1996 conference on Programming language design and implementation
ACM Transactions on Programming Languages and Systems (TOPLAS)
An approach for exploring code improving transformations
ACM Transactions on Programming Languages and Systems (TOPLAS)
Advanced compiler design and implementation
Advanced compiler design and implementation
Translation validation for an optimizing compiler
PLDI '00 Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation
Systematic design of program transformation frameworks by abstract interpretation
POPL '02 Proceedings of the 29th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Proving correctness of compiler optimizations by temporal logic
POPL '02 Proceedings of the 29th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
POPL '77 Proceedings of the 4th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
Communication and Concurrency
Finding Legal Reordering Transformations Using Mappings
LCPC '94 Proceedings of the 7th International Workshop on Languages and Compilers for Parallel Computing
Data Flow Analysis as Model Checking
TACS '91 Proceedings of the International Conference on Theoretical Aspects of Computer Software
TACAS '98 Proceedings of the 4th International Conference on Tools and Algorithms for Construction and Analysis of Systems
Automatically proving the correctness of compiler optimizations
PLDI '03 Proceedings of the ACM SIGPLAN 2003 conference on Programming language design and implementation
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
Automated soundness proofs for dataflow analyses and transformations via local rules
Proceedings of the 32nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Simplify: a theorem prover for program checking
Journal of the ACM (JACM)
Translation and Run-Time Validation of Loop Transformations
Formal Methods in System Design
Formal certification of a compiler back-end or: programming a compiler with a proof assistant
Conference record of the 33rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Automated refinement checking of concurrent systems
Proceedings of the 2007 IEEE/ACM international conference on Computer-aided design
Formal verification of translation validators: a case study on instruction scheduling optimizations
Proceedings of the 35th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Verified validation of lazy code motion
Proceedings of the 2009 ACM SIGPLAN conference on Programming language design and implementation
Into the Loops: Practical Issues in Translation Validation for Optimizing Compilers
Electronic Notes in Theoretical Computer Science (ENTCS)
A simple, verified validator for software pipelining
Proceedings of the 37th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Generating compiler optimizations from proofs
Proceedings of the 37th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Bringing extensibility to verified compilers
PLDI '10 Proceedings of the 2010 ACM SIGPLAN conference on Programming language design and implementation
Relational verification using product programs
FM'11 Proceedings of the 17th international conference on Formal methods
Formalizing the LLVM intermediate representation for verified program transformations
POPL '12 Proceedings of the 39th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Validating register allocation and spilling
CC'10/ETAPS'10 Proceedings of the 19th joint European conference on Theory and Practice of Software, international conference on Compiler Construction
Equivalence checking of static affine programs using widening to handle recurrences
ACM Transactions on Programming Languages and Systems (TOPLAS)
Differential assertion checking
Proceedings of the 2013 9th Joint Meeting on Foundations of Software Engineering
Towards modularly comparing programs using automated theorem provers
CADE'13 Proceedings of the 24th international conference on Automated Deduction
Hi-index | 0.00 |
Translation validation is a technique for checking that, after an optimization has run, the input and output of the optimization are equivalent. Traditionally, translation validation has been used to prove concrete, fully specified programs equivalent. In this paper we present Parameterized Equivalence Checking (PEC), a generalization of translation validation that can prove the equivalence of parameterized programs. A parameterized program is a partially specified program that can represent multiple concrete programs. For example, a parameterized program may contain a section of code whose only known property is that it does not modify certain variables. By proving parameterized programs equivalent, PEC can prove the correctness of transformation rules that represent complex optimizations once and for all, before they are ever run. We implemented our PEC technique in a tool that can establish the equivalence of two parameterized programs. To highlight the power of PEC, we designed a language for implementing complex optimizations using many-to-many rewrite rules, and used this language to implement a variety of optimizations including software pipelining, loop unrolling, loop unswitching, loop interchange, and loop fusion. Finally, to demonstrate the effectiveness of PEC, we used our PEC implementation to verify that all the optimizations we implemented in our language preserve program behavior.