101 research outputs found
Crowfoot: a verifier for higher-order store programs
We present Crowfoot, an automatic verification tool for imperative programs that manipulate procedures dynamically at runtime; these programs use a heap that can store not only data but also code (commands or procedures). Such heaps are often called higher-order store, and allow for instance the creation of new recursions on the fly. One can use higher-order store to model phenomena such as runtime loading and unloading of code, runtime update of code and runtime code generation. Crowfoot's assertion language, based on separation logic, features nested Hoare triples which describe the behaviour of procedures stored on the heap. The tool addresses complex issues like deep frame rules and recursion through the store, and is the first verification tool based on recent developments in the mathematical foundations of Hoare logics with nested triples
COSMICAH 2005: workshop on verification of COncurrent Systems with dynaMIC Allocated Heaps (a Satellite event of ICALP 2005) - Informal Proceedings
Lisboa Portugal, 10 July 200
The 1st Verified Software Competition, Extended Experience Report
We, the organizers and participants, report our experiences
from the 1st Veried Software Competition, held in August 2010 in Edinburgh
at the VSTTE 2010 conferenc
Gradual C0: Symbolic Execution for Gradual Verification
Current static verification techniques support a wide range of programs.
However, such techniques only support complete and detailed specifications,
which places an undue burden on users. To solve this problem, prior work
proposed gradual verification, which handles complete, partial, or missing
specifications by soundly combining static and dynamic checking. Gradual
verification has also been extended to programs that manipulate recursive,
mutable data structures on the heap. Unfortunately, this extension does not
reward users with decreased dynamic checking as specifications are refined. In
fact, all properties are checked dynamically regardless of any static
guarantees. Additionally, no full-fledged implementation of gradual
verification exists so far, which prevents studying its performance and
applicability in practice.
We present Gradual C0, the first practicable gradual verifier for recursive
heap data structures, which targets C0, a safe subset of C designed for
education. Static verifiers supporting separation logic or implicit dynamic
frames use symbolic execution for reasoning; so Gradual C0, which extends one
such verifier, adopts symbolic execution at its core instead of the weakest
liberal precondition approach used in prior work. Our approach addresses
technical challenges related to symbolic execution with imprecise
specifications, heap ownership, and branching in both program statements and
specification formulas. We also deal with challenges related to minimizing
insertion of dynamic checks and extensibility to other programming languages
beyond C0. Finally, we provide the first empirical performance evaluation of a
gradual verifier, and found that on average, Gradual C0 decreases run-time
overhead between 11-34% compared to the fully-dynamic approach used in prior
work. Further, the worst-case scenarios for performance are predictable and
avoidable.Comment: 37 pages without appendix supplement, preprin
- …