Formal verification of SSA-based optimizations for LLVM

Authors:
Jianzhou Zhao;Santosh Nagarakatte;Milo M.K. Martin;Steve Zdancewic
Affiliations:
University of Pennsylvania, Philadelphia, Pennsylvania, USA;Rutgers University, New Brunswick, New Jersey, USA;University of Pennsylvania, Philadelphia, Pennsylvania, USA;University of Pennsylvania, Philadelphia, Pennsylvania, USA
Venue:
Proceedings of the 34th ACM SIGPLAN conference on Programming language design and implementation
Year:
2013

Citing 18
Cited 1

Efficiently computing static single assignment form and the control dependence graph

ACM Transactions on Programming Languages and Systems (TOPLAS)
A linear time algorithm for placing &phgr;-nodes

POPL '95 Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A correspondence between continuation passing style and static single assignment form

IR '95 Papers from the 1995 ACM SIGPLAN workshop on Intermediate representations
SSA is functional programming

ACM SIGPLAN Notices
Advanced compiler design and implementation

Advanced compiler design and implementation
Simple Generation of Static Single-Assignment Form

CC '00 Proceedings of the 9th International Conference on Compiler Construction
A verifiable SSA program representation for aggressive compiler optimization

Conference record of the 33rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A type system equivalent to static single assignment

Proceedings of the 8th ACM SIGPLAN international conference on Principles and practice of declarative programming
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
A Formally Verified Compiler Back-end

Journal of Automated Reasoning
Optimizing Code Generation from SSA Form: A Comparison Between Two Formal Correctness Proofs in Isabelle/HOL

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
Finding and understanding bugs in C compilers

Proceedings of the 32nd ACM SIGPLAN conference on Programming language design and implementation
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
A framework for formal verification of compiler optimizations

ITP'10 Proceedings of the First international conference on Interactive Theorem Proving
A formally verified SSA-Based middle-end: Static single assignment meets compcert

ESOP'12 Proceedings of the 21st European conference on Programming Languages and Systems
Mechanized verification of computing dominators for formalizing compilers

CPP'12 Proceedings of the Second international conference on Certified Programs and Proofs

Formal Verification of an SSA-Based Middle-End for CompCert

ACM Transactions on Programming Languages and Systems (TOPLAS)

Quantified Score

Hi-index	0.00

Visualization

Abstract

Modern compilers, such as LLVM and GCC, use a static single assignment(SSA) intermediate representation (IR) to simplify and enable many advanced optimizations. However, formally verifying the correctness of SSA-based optimizations is challenging because SSA properties depend on a function's entire control-flow graph. This paper addresses this challenge by developing a proof technique for proving SSA-based program invariants and compiler optimizations. We use this technique in the Coq proof assistant to create mechanized correctness proofs of several "micro" transformations that form the building blocks for larger SSA optimizations. To demonstrate the utility of this approach, we formally verify a variant of LLVM's mem2reg transformation in Vellvm, a Coq-based formal semantics of the LLVM IR. The extracted implementation generates code with performance comparable to that of LLVM's unverified implementation.