Program Logics for Certified Compilers

Separation Logic is the twenty-first-century variant of Hoare Logic that permits verification of pointer-manipulating programs. This book covers practical and theoretical aspects of Separation Logic at a level accessible to beginning graduate students interested in software verification. On the practical side it offers an introduction to verification in Hoare and Separation logics, simple case studies for toy languages, and the Verifiable C program logic for the C programming language. On the theoretical side it presents separation algebras as models of separation logics; step-indexed models of higher-order logical features for higher-order programs; indirection theory for constructing step-indexed separation algebras; tree-shares as models for shared ownership; and the semantic construction (and soundness proof) of Verifiable C. In addition, the book covers several aspects of the CompCert verified C compiler, and its connection to foundationally verified software analysis tools. All constructions and proofs are made rigorous and accessible in the Coq developments of the open-source Verified Software Toolchain.

[1]  Andrew W. Appel,et al.  Oracle Semantics for Concurrent Separation Logic , 2008, ESOP.

[2]  Jonghyun Park,et al.  A theorem prover for Boolean BI , 2013, POPL.

[3]  Aquinas Hobor,et al.  The ramifications of sharing in data structures , 2013, POPL.

[4]  James Brotherston,et al.  Classical BI: Its Semantics and Proof Theory , 2010, Log. Methods Comput. Sci..

[5]  Jerzy Tiuryn,et al.  A New Characterization of Lambda Definability , 1993, TLCA.

[6]  Michael Huth,et al.  Logic in computer science - modelling and reasoning about systems , 2000 .

[7]  Karl Crary,et al.  Toward a foundational typed assembly language , 2003, POPL '03.

[8]  Adam Chlipala,et al.  Certified Programming with Dependent Types - A Pragmatic Introduction to the Coq Proof Assistant , 2013 .

[9]  Xuan Bach Le,et al.  Decision Procedures over Sophisticated Fractional Permissions , 2012, APLAS.

[10]  Richard Bornat,et al.  Proving Pointer Programs in Hoare Logic , 2000, MPC.

[11]  Andrew W. Appel,et al.  A very modal model of a modern, major, general type system , 2007, POPL '07.

[12]  Andrew W. Appel,et al.  An indexed model of recursive types for foundational proof-carrying code , 2001, TOPL.

[13]  Andrew W. Appel,et al.  A Fresh Look at Separation Algebras and Share Accounting , 2009, APLAS.

[14]  Lars Birkedal,et al.  Charge! - A Framework for Higher-Order Separation Logic in Coq , 2012, ITP.

[15]  Frank Pfenning,et al.  Higher-order abstract syntax , 1988, PLDI '88.

[16]  Peter W. O'Hearn,et al.  Local Action and Abstract Separation Logic , 2007, 22nd Annual IEEE Symposium on Logic in Computer Science (LICS 2007).

[17]  Peter W. O'Hearn,et al.  BI as an assertion language for mutable data structures , 2001, POPL '01.

[18]  Andrew K. Wright.  Simple imperative polymorphism , 1995, LISP Symb. Comput..

[19]  Elena Petrova,et al.  Pervasive Compiler Verification - From Verified Programs to Verified Systems , 2008, Electron. Notes Theor. Comput. Sci..

[20]  Andrew W. Appel,et al.  Operational refinement for compiler correctness , 2012 .

[21]  Gordon D. Plotkin,et al.  An ideal model for recursive polymorphic types , 1984, Inf. Control..

[22]  Arak M. Mathai,et al.  The H-Function , 2010 .

[23]  Guillaume Melquiond,et al.  Flocq: A Unified Library for Proving Floating-Point Algorithms in Coq , 2011, 2011 IEEE 20th Symposium on Computer Arithmetic.

[24]  Andrew W. Appel,et al.  A theory of indirection via approximation , 2010, POPL '10.

[25]  Andrew W. Appel,et al.  Verified Software Toolchain , 2012, NASA Formal Methods.

[26]  Edsger W. Dijkstra,et al.  Cooperating sequential processes , 2002 .

[27]  Tobias Nipkow,et al.  A machine-checked model for a Java-like language, virtual machine, and compiler , 2006, TOPL.

[28]  Peter W. O'Hearn,et al.  Symbolic Execution with Separation Logic , 2005, APLAS.

[29]  Michael J. Flynn,et al.  Program counter , 2003 .

[30]  Benjamin C. Pierce,et al.  Types and programming languages: the next generation , 2003, 18th Annual IEEE Symposium of Logic in Computer Science, 2003. Proceedings..

[31]  Dana S. Scott,et al.  Data Types as Lattices , 1976, SIAM J. Comput..

[32]  Michael Norrish,et al.  Types, bytes, and separation logic , 2007, POPL '07.

[33]  Peter W. O'Hearn,et al.  Resources, Concurrency and Local Reasoning , 2004, CONCUR.

[34]  Robert Harper,et al.  A Simplified Account of Polymorphic References , 1994, Inf. Process. Lett..

[35]  Xavier Leroy,et al.  Formal Verification of a C-like Memory Model and Its Uses for Verifying Program Transformations , 2008, Journal of Automated Reasoning.

[36]  John Tang Boyland,et al.  Checking Interference with Fractional Permissions , 2003, SAS.

[37]  M. Schönfinkel.  Über die Bausteine der mathematischen Logik , 1924 .

[38]  Zhong Shao,et al.  A Syntactic Approach to Foundational Proof-Carrying Code , 2004, Journal of Automated Reasoning.

[39]  Andrey Rybalchenko,et al.  Separation logic + superposition calculus = heap theorem prover , 2011, PLDI '11.

[40]  François Pottier,et al.  Syntactic soundness proof of a type-and-capability system with hidden state , 2013, J. Funct. Program..

[41]  Amal Ahmed,et al.  Semantics of types for mutable state , 2004 .

[42]  Peter W. O'Hearn,et al.  Smallfoot: Modular Automatic Assertion Checking with Separation Logic , 2005, FMCO.

[43]  Lars Birkedal,et al.  Fictional Separation Logic , 2012, ESOP.

[44]  Benjamin Grégoire,et al.  Certificate translation for optimizing compilers , 2009, TOPL.

[45]  Andrew W. Appel,et al.  An Indexed Model of Impredicative Polymorphism and Mutable References , 2003 .

[46]  Philippa Gardner,et al.  Small Specifications for Tree Update , 2009, WS-FM.

[47]  Hans-Juergen Boehm,et al.  HP Laboratories , 2006 .

[48]  Aquinas Hobor,et al.  Improving the Compositionality of Separation Algebras , 2011 .

[49]  Thomas Tuerk,et al.  A Formalisation of Smallfoot in HOL , 2009, TPHOLs.

[50]  Matthew J. Parkinson,et al.  Local reasoning for Java , 2005 .

[51]  Peter W. O'Hearn,et al.  Permission accounting in separation logic , 2005, POPL '05.

[52]  Maulik A. Dave,et al.  Compiler verification: a bibliography , 2003, SOEN.

[53]  C. A. R. Hoare,et al.  Monitors: an operating system structuring concept , 1974, CACM.

[54]  John C. Reynolds,et al.  Separation logic: a logic for shared mutable data structures , 2002, Proceedings 17th Annual IEEE Symposium on Logic in Computer Science.

[55]  Andrew W. Appel,et al.  A Trustworthy Proof Checker , 2004, Journal of Automated Reasoning.

[56]  Aquinas Hobor,et al.  A Theory of Termination via Indirection , 2010, Modelling, Controlling and Reasoning About State.

[57]  Andrew W. Appel,et al.  Foundational proof-carrying code , 2001, Proceedings 16th Annual IEEE Symposium on Logic in Computer Science.

[58]  Andrew W. Appel,et al.  VeriSmall: Verified Smallfoot Shape Analysis , 2011, CPP.

[59]  Andrew W. Appel,et al.  Verified heap theorem prover by paramodulation , 2012, ICFP.

[60]  David Pichardie,et al.  Formal Verification of a C Value Analysis Based on Abstract Interpretation , 2013, SAS.

[61]  Alexey Gotsman,et al.  Local Reasoning for Storable Locks and Threads , 2007, APLAS.

[62]  Hiroshi Nakano,et al.  A modality for recursion , 2000, Proceedings Fifteenth Annual IEEE Symposium on Logic in Computer Science (Cat. No.99CB36332).

[63]  Andrew W. Appel,et al.  The approximation modality in models of higher-order types , 2010 .

[64]  Sarita V. Adve,et al.  Memory models: a case for rethinking parallel languages and hardware , 2009, PODC '09.

[65]  Peter W. O'Hearn,et al.  A Primer on Separation Logic (and Automatic Program Verification and Analysis) , 2012, Software Safety and Security.

[66]  Andrew McCreight,et al.  Practical Tactics for Separation Logic , 2009, TPHOLs.

[67]  Andrew W. Appel,et al.  Separation Logic for Small-Step cminor , 2007, TPHOLs.

[68]  Andrew W. Appel,et al.  Semantic foundations for typed assembly languages , 2010, TOPL.

[69]  Marc Pantel,et al.  Towards Optimizing Certified Compilation in Flight Control Software ∗ , 2010 .

[70]  R. M. Burstall,et al.  Some Techniques for Proving Correctness of Programs which Alter Data Structures , 2013 .

[71]  Peter W. O'Hearn,et al.  A Decidable Fragment of Separation Logic , 2004, FSTTCS.

[72]  Mads Tofte,et al.  Type Inference for Polymorphic References , 1990, Inf. Comput..

[73]  Xavier Leroy,et al.  A Formally Verified Compiler Back-end , 2009, Journal of Automated Reasoning.

[74]  J. Strother Moore,et al.  A mechanically verified language implementation , 1989, Journal of Automated Reasoning.

[75]  Cheryl Dunye,et al.  Above the Line , 2015 .

[76]  Xavier Leroy,et al.  Mechanized Semantics for the Clight Subset of the C Language , 2009, Journal of Automated Reasoning.

[77]  Laurie J. Hendren,et al.  Is it a tree, a DAG, or a cyclic graph? A shape analysis for heap-directed pointers in C , 1996, POPL '96.

[78]  Hongseok Yang,et al.  Step-indexed kripke models over recursive worlds , 2011, POPL '11.

[79]  Peter W. O'Hearn,et al.  Compositional Shape Analysis by Means of Bi-Abduction , 2011, JACM.

[80]  Adam Chlipala,et al.  Mostly-automated verification of low-level programs in computational separation logic , 2011, PLDI '11.

[81]  Samin Ishtiaq,et al.  SLAyer: Memory Safety for Systems-Level Code , 2011, CAV.