PLDI '88 Proceedings of the ACM SIGPLAN 1988 conference on Programming Language design and Implementation
Automated proofs of object code for a widely used microprocessor
Automated proofs of object code for a widely used microprocessor
A syntactic approach to type soundness
Information and Computation
A mechanized Hoare logic of state transitions
A classical mind
Automated proofs of object code for a widely used microprocessor
Journal of the ACM (JACM)
POPL '96 Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
ALGOL-like languages (v.2)
Proceedings of the 24th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
From system F to typed assembly language
POPL '98 Proceedings of the 25th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Dependent types in practical programming
Proceedings of the 26th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A semantic model of types and machine instructions for proof-carrying code
Proceedings of the 27th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A certifying compiler for Java
PLDI '00 Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation
An axiomatic basis for computer programming
Communications of the ACM
A type system for certified binaries
POPL '02 Proceedings of the 29th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
An indexed model of recursive types for foundational proof-carrying code
ACM Transactions on Programming Languages and Systems (TOPLAS)
Predicate transformer semantics of a higher-order imperative language with record subtyping
Science of Computer Programming
The Definition of Standard ML
The Java Language Specification
The Java Language Specification
An expressive, scalable type theory for certified code
Proceedings of the seventh ACM SIGPLAN international conference on Functional programming
Toward a foundational typed assembly language
POPL '03 Proceedings of the 30th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
The logical approach to stack typing
Proceedings of the 2003 ACM SIGPLAN international workshop on Types in languages design and implementation
Separation Logic: A Logic for Shared Mutable Data Structures
LICS '02 Proceedings of the 17th Annual IEEE Symposium on Logic in Computer Science
A Syntactic Approach to Foundational Proof-Carrying Code
LICS '02 Proceedings of the 17th Annual IEEE Symposium on Logic in Computer Science
Inductive Definitions in the system Coq - Rules and Properties
TLCA '93 Proceedings of the International Conference on Typed Lambda Calculi and Applications
A provably sound TAL for back-end optimization
PLDI '03 Proceedings of the ACM SIGPLAN 2003 conference on Programming language design and implementation
A Sound Framework for Untrusted Verification-Condition Generators
LICS '03 Proceedings of the 18th Annual IEEE Symposium on Logic in Computer Science
Reasoning about Hierarchical Storage
LICS '03 Proceedings of the 18th Annual IEEE Symposium on Logic in Computer Science
Foundational Proof-Carrying Code
LICS '01 Proceedings of the 16th Annual IEEE Symposium on Logic in Computer Science
Compiling with proofs
Building certified libraries for PCC: dynamic storage allocation
Science of Computer Programming - Special issue on 12th European symposium on programming (ESOP 2003)
A compositional logic for polymorphic higher-order functions
PPDP '04 Proceedings of the 6th ACM SIGPLAN international conference on Principles and practice of declarative programming
Verification of safety properties for concurrent assembly code
Proceedings of the ninth ACM SIGPLAN international conference on Functional programming
Semantics of types for mutable state
Semantics of types for mutable state
An Observationally Complete Program Logic for Imperative Higher-Order Frame Rules
LICS '05 Proceedings of the 20th Annual IEEE Symposium on Logic in Computer Science
Modular verification of concurrent assembly code with dynamic thread creation and termination
Proceedings of the tenth ACM SIGPLAN international conference on Functional programming
A logical analysis of aliasing in imperative higher-order functions
Proceedings of the tenth ACM SIGPLAN international conference on Functional programming
A compositional logic for control flow and its application in foundational proof-carrying code
A compositional logic for control flow and its application in foundational proof-carrying code
Frame rules from answer types for code pointers
Conference record of the 33rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Modular verification of assembly code with stack-based control abstractions
Proceedings of the 2006 ACM SIGPLAN conference on Programming language design and implementation
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 garbage-collecting typed assembly language
TLDI '07 Proceedings of the 2007 ACM SIGPLAN international workshop on Types in languages design and implementation
An open framework for foundational proof-carrying code
TLDI '07 Proceedings of the 2007 ACM SIGPLAN international workshop on Types in languages design and implementation
A compositional natural semantics and Hoare logic for low-level languages
Theoretical Computer Science
Integrating a certified memory management runtime with proof-carrying code
Proceedings of the 2007 ACM symposium on Applied computing
Proceedings of the 2007 ACM SIGPLAN conference on Programming language design and implementation
Ynot: dependent types for imperative programs
Proceedings of the 13th ACM SIGPLAN international conference on Functional programming
Combining Domain-Specific and Foundational Logics to Verify Complete Software Systems
VSTTE '08 Proceedings of the 2nd international conference on Verified Software: Theories, Tools, Experiments
Compiling functional types to relational specifications for low level imperative code
Proceedings of the 4th international workshop on Types in language design and implementation
Certifying concurrent programs using transactional memory
Journal of Computer Science and Technology
APLAS '09 Proceedings of the 7th Asian Symposium on Programming Languages and Systems
Semantic foundations for typed assembly languages
ACM Transactions on Programming Languages and Systems (TOPLAS)
WYSINWYX: What you see is not what you eXecute
ACM Transactions on Programming Languages and Systems (TOPLAS)
Abstract predicates and mutable adts in hoare type theory
ESOP'07 Proceedings of the 16th European conference on Programming
Separation logic for small-step cminor
TPHOLs'07 Proceedings of the 20th international conference on Theorem proving in higher order logics
Using XCAP to certify realistic systems code: machine context management
TPHOLs'07 Proceedings of the 20th international conference on Theorem proving in higher order logics
Proceedings of the IEEE/ACM international conference on Automated software engineering
Communications of the ACM
Program verification through characteristic formulae
Proceedings of the 15th ACM SIGPLAN international conference on Functional programming
Certification of thread context switching
Journal of Computer Science and Technology
Mostly-automated verification of low-level programs in computational separation logic
Proceedings of the 32nd ACM SIGPLAN conference on Programming language design and implementation
Specification patterns and proofs for recursion through the store
FCT'11 Proceedings of the 18th international conference on Fundamentals of computation theory
Characteristic formulae for the verification of imperative programs
Proceedings of the 16th ACM SIGPLAN international conference on Functional programming
ARMor: fully verified software fault isolation
EMSOFT '11 Proceedings of the ninth ACM international conference on Embedded software
Certifying assembly programs with trails
Frontiers of Computer Science in China
CSL'06 Proceedings of the 20th international conference on Computer Science Logic
Separation logic for higher-order store
CSL'06 Proceedings of the 20th international conference on Computer Science Logic
Program logics for sequential higher-order control
FSEN'09 Proceedings of the Third IPM international conference on Fundamentals of Software Engineering
Science of Computer Programming
A compositional logic for control flow
VMCAI'06 Proceedings of the 7th international conference on Verification, Model Checking, and Abstract Interpretation
Crowfoot: a verifier for higher-order store programs
VMCAI'12 Proceedings of the 13th international conference on Verification, Model Checking, and Abstract Interpretation
VSTTE'12 Proceedings of the 4th international conference on Verified Software: theories, tools, experiments
High-level separation logic for low-level code
POPL '13 Proceedings of the 40th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Proceedings of the 18th ACM SIGPLAN international conference on Functional programming
A verified information-flow architecture
Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages
Specification patterns for reasoning about recursion through the store
Information and Computation
Hi-index | 0.02 |
Embedded code pointers (ECPs) are stored handles of functions and continuations commonly seen in low-level binaries as well as functional or higher-order programs. ECPs are known to be very hard to support well in Hoare-logic style verification systems. As a result, existing proof-carrying code (PCC) systems have to either sacrifice the expressiveness or the modularity of program specifications, or resort to construction of complex semantic models. In Reynolds's LICS'02 paper, supporting ECPs is listed as one of the main open problems for separation logic.In this paper we present a simple and general technique for solving the ECP problem for Hoare-logic-based PCC systems. By adding a small amount of syntax to the assertion language, we show how to combine semantic consequence relation with syntactic proof techniques. The result is a new powerful framework that can perform modular reasoning on ECPs while still retaining the expressiveness of Hoare logic. We show how to use our techniques to support polymorphism, closures, and other language extensions and how to solve the ECP problem for separation logic. Our system is fully mechanized. We give its complete soundness proof and a full verification of Reynolds's CPS-style "list-append" example in the Coq proof assistant.