Operational reasoning for functions with local state
Higher order operational techniques in semantics
An indexed model of recursive types for foundational proof-carrying code
ACM Transactions on Programming Languages and Systems (TOPLAS)
A very modal model of a modern, major, general type system
Proceedings of the 34th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A certified type-preserving compiler from lambda calculus to assembly language
Proceedings of the 2007 ACM SIGPLAN conference on Programming language design and implementation
Proceedings of the 2007 ACM SIGPLAN conference on Programming language design and implementation
A general framework for certifying garbage collectors and their mutators
Proceedings of the 2007 ACM SIGPLAN conference on Programming language design and implementation
Local reasoning about a copying garbage collector
ACM Transactions on Programming Languages and Systems (TOPLAS)
State-dependent representation independence
Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Biorthogonality, step-indexing and compiler correctness
Proceedings of the 14th ACM SIGPLAN international conference on Functional programming
A Formally Verified Compiler Back-end
Journal of Automated Reasoning
A verified compiler for an impure functional language
Proceedings of the 37th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
CSL'09/EACSL'09 Proceedings of the 23rd CSL international conference and 18th EACSL Annual conference on Computer science logic
The impact of higher-order state and control effects on local relational reasoning
Proceedings of the 15th ACM SIGPLAN international conference on Functional programming
A certified framework for compiling and executing garbage-collected languages
Proceedings of the 15th ACM SIGPLAN international conference on Functional programming
Step-Indexed syntactic logical relations for recursive and quantified types
ESOP'06 Proceedings of the 15th European conference on Programming Languages and Systems
The marriage of bisimulations and Kripke logical relations
POPL '12 Proceedings of the 39th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A rely-guarantee-based simulation for verifying concurrent program transformations
POPL '12 Proceedings of the 39th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
On construction of a library of formally verified low-level arithmetic functions
Proceedings of the 27th Annual ACM Symposium on Applied Computing
LICS '12 Proceedings of the 2012 27th Annual IEEE/ACM Symposium on Logic in Computer Science
On construction of a library of formally verified low-level arithmetic functions
Innovations in Systems and Software Engineering
Abstract effects and proof-relevant logical relations
Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages
Rely-Guarantee-Based Simulation for Compositional Verification of Concurrent Program Transformations
ACM Transactions on Programming Languages and Systems (TOPLAS)
Hi-index | 0.00 |
There has recently been great progress in proving the correctness of compilers for increasingly realistic languages with increasingly realistic runtime systems. Most work on this problem has focused on proving the correctness of a particular compiler, leaving open the question of how to verify the correctness of assembly code that is hand-optimized or linked together from the output of multiple compilers. This has led Benton and other researchers to propose more abstract, compositional notions of when a low-level program correctly realizes a high-level one. However, the state of the art in so-called "compositional compiler correctness" has only considered relatively simple high-level and low-level languages. In this paper, we propose a novel, extensional, compiler-independent notion of equivalence between high-level programs in an expressive, impure ML-like λ-calculus and low-level programs in an (only slightly) idealized assembly language. We define this equivalence by means of a biorthogonal, step-indexed, Kripke logical relation, which enables us to reason quite flexibly about assembly code that uses local state in a different manner than the high-level code it implements (e.g. self-modifying code). In contrast to prior work, we factor our relation in a symmetric, language-generic fashion, which helps to simplify and clarify the formal presentation, and we also show how to account for the presence of a garbage collector. Our approach relies on recent developments in Kripke logical relations for ML-like languages, in particular the idea of possible worlds as state transition systems.