CompCertS: A Memory-Aware Verified C Compiler Using Pointer as Integer Semantics

@inproceedings{Besson2017CompCertSAM,
  title={CompCertS: A Memory-Aware Verified C Compiler Using Pointer as Integer Semantics},
  author={Fr{\'e}d{\'e}ric Besson and Sandrine Blazy and Pierre Wilke},
  booktitle={ITP},
  year={2017}
}
The CompCert C compiler provides the formal guarantee that the observable behaviour of the compiled code improves on the observable behaviour of the source code. In this paper, we present a formally verified C compiler, CompCertS, which is essentially the CompCert compiler, albeit with a stronger formal guarantee: it gives a semantics to more programs and ensures that the memory consumption is preserved by the compiler. CompCertS is based on an enhanced memory model where, unlike CompCert but… 
Verified compilation of C programs with a nominal memory model
TLDR
A series of extensions of CompCert show that the nominal memory model supports a general framework for verified compilation of C programs, enables intuitive reasoning of compiler transformations on partial memory; and enables modular reasoning about programs working with contextual memory.
An abstract stack based approach to verified compositional compilation to machine code
TLDR
The proposed Stack-Aware CompCert is a complete extension of CompCert that enforces the finiteness of the stack and fine-grained stack permissions and is based on the enrichment of Comp cert's memory model with an abstract stack that keeps track of the history of stack frames to bound the stack consumption and enforces a uniform stack access policy by assigning fine- grained permissions to stack memory.
The Trusted Computing Base of the CompCert Verified Compiler
CompCert is the first realistic formally verified compiler: it provides a machine-checked mathematical proof that the code it generates matches the source code. Yet, there could be loopholes in this
Reconciling high-level optimizations and low-level code in LLVM
TLDR
This work developed a novel memory model for LLVM IR and formalized it, which requires a handful of problematic IR-level optimizations to be removed, but it also supports the addition of new optimizations that were not previously legal.
Compiling Sandboxes: Formally Verified Software Fault Isolation
TLDR
This work design, implement and prove correct a program instrumentation phase as part of the formally verified compiler CompCert that enforces a sandboxing security property a priori and eliminates the need for a binary verifier and leverages the soundness proof of the compiler to prove the security of the sandboxing transformation.
Do you have space for dessert? a verified space cost semantics for CakeML programs
TLDR
The work described in this paper is the first to be able to answer questions of the form: what is a sufficient amount of memory for my program to never reach an out-of-memory error with proofs in the context of a language that depends on garbage collection.
Gillian, part i: a multi-language platform for symbolic execution
TLDR
A parametric soundness result is proved, introducing restriction on abstract states, which generalises path conditions used in classical symbolic execution and proves the viability of the parametric approach to symbolic analysis.
Gillian, Part I: A Multi-language Platform for Symbolic Execution
TLDR
A parametric soundness result is proved, introducing restriction on abstract states, which generalises path conditions used in classical symbolic execution, thus demonstrating the viability of the parametric approach.
CompCertELF: Verified Separate Compilation of C Programs into ELF Object Files
TLDR
CompCertELF is presented, the first extension to CompCert that supports verified compilation from C programs all the way to a standard binary file format, i.e., the ELF object format, by introducing a notion of syntactical equivalence between programs and proving the commutativity between syntactic equivalence and the two different kinds of linking.
CompCertELF: verified separate compilation of C programs into ELF object files
TLDR
CompCertELF is presented, the first extension to CompCert that supports verified compilation from C programs all the way to a standard binary file format, i.e., the ELF object format, by introducing a notion of syntactical equivalence between programs and proving the commutativity between syntactic equivalence and the two different kinds of linking.
...
1
2
...

References

SHOWING 1-10 OF 22 REFERENCES
A Concrete Memory Model for CompCert
TLDR
This paper presents the proof of an enhanced and more concrete memory model for the CompCert C compiler which assigns a definite meaning to more C programs and proves formally the soundness of CompCert’s abstract semantics of pointers.
CompCertTSO: A Verified Compiler for Relaxed-Memory Concurrency
TLDR
The semantic design and verified compilation of a C-like programming language for concurrent shared-memory computation on x86 multiprocessors is considered, and some verified fence-elimination optimizations, integrated into CompCertTSO are described.
A formal C memory model supporting integer-pointer casts
TLDR
This work presents the first formal memory model that allows many common optimizations and fully supports operations on the representation of pointers and all arithmetic operations are well-defined for pointers that have been cast to integers.
A Precise and Abstract Memory Model for C Using Symbolic Values
TLDR
This work proposes a formal semantics which gives a well-defined meaning to those behaviours for the C dialect of the CompCert compiler which builds upon a novel memory model leveraging a notion of symbolic values.
A Verified CompCert Front-End for a Memory Model Supporting Pointer Arithmetic and Uninitialised Data
TLDR
This work proposes a novel memory model for CompCert which gives a defined semantics to challenging features such as bitwise pointer arithmetics and access to uninitialised data and shows how to tame the expressive power of the normalisation so that the memory model fits the proof framework of CompCert.
Verified peephole optimizations for CompCert
TLDR
Peek is presented, a framework for expressing, verifying, and running meaning-preserving assembly-level program trans- formations in CompCert, and a set of local properties are proved are sufficient to ensure global transformation correctness.
Formal Verification of a C-like Memory Model and Its Uses for Verifying Program Transformations
TLDR
This article presents the formal verification, using the Coq proof assistant, of a memory model for low-level imperative languages such as C and compiler intermediate languages that supports reasoning over transformations of such programs.
End-to-end verification of stack-space bounds for C programs
TLDR
A framework that enables the formal verification of stack-space bounds of compiled machine code at the C level consisting of a verified CompCert-based compiler that preserves quantitative properties, a verified quantitative program logic for interactive stack-bound development, and a verified stack analyzer that automatically derives stack bounds during compilation.
Portable Software Fault Isolation
TLDR
This work presents a new technique for architecture portable software fault isolation (SFI), together with a prototype implementation in the Coq proof assistant, that allows the same SFI analysis to be used across multiple architectures, greatly simplifying the most difficult part of deploying trustworthy SFI systems.
Formal verification of a realistic compiler
TLDR
This paper reports on the development and formal verification of CompCert, a compiler from Clight (a large subset of the C programming language) to PowerPC assembly code, using the Coq proof assistant both for programming the compiler and for proving its correctness.
...
1
2
3
...