Abstract debugging of higher-order imperative languages

Abstract

interpretation is a formal method that enables the static determination (i.e. at compile-time) of the dynamic properties (i.e. at run-time) of programs. We present an abstract interpretation-based method, called abstract debugging, which enables the static and formal debugging of programs, prior to their execution, by finding the origin of potential bugs as well as necessmy conditions for these bugs not to occur at run-time. We show how invariant assertions and intermittent assertions,such as termination, can be used to formally debug programs. Finally, we show how abstract debugging can be effectively and efficiently applied to higher-order imperative programs with exceptions and jumps to non-local labels, and present the Syntox system that enables the abstract debugging of the Pascal language by the determination of the range of the scalar variables of programs.

Thresher

“…Bourdoncle [9] presents a system for "abstract debugging" of program assertions, in which the compiler aims to discover inputs leading to violations statically. Rival [42] presents a system based on combined forward and backward analysis for elucidating and validating error reports from the Astrée system [15].…”

Putting static analysis to work for verification

“…For instance, in [1], it is shown that intervals can be used to precisely analyze McCarthy's "91-function". There it is also shown how to propagate information in the backwards direction.…”

“…• Discover, locate, and diagnose bugs in incorrect programs. While static analysis has been used previously to find potential bugs ("program anomalies") as well as to demonstrate the absence of bugs in programs that manipulate scalar variables and arrays [12,1], the present paper concerns programs that manipulate pointers and heap-allocated storage. This paper demonstrates that it is possible to create analysis algorithms that are of sufficient precision that the program's partial correctness can be established from the information contained in the "state-descriptors" obtained via static analysis.…”

“…The specification of such an analysis becomes one of the skills needed to apply our verification methodology. 1 However, this seems to present a significant new obstacle to adoption: With the methodology of abstract interpretation, it is typically not an easy task to obtain appropriate abstract state-transformation functions and show that they are correct. On the contrary, papers on program analysis often contain exhaustive (and exhausting) proofs to demonstrate that a given abstract semantics provides answers that are safe with respect to a given concrete semantics.…”

“…Furthermore, as discussed in Sections 2 and 6, it works at the semantic level; that is, it operates directly on explicit representations of logical structures, rather than on implicit representations, such as logical formulae. Because the analysis is carried out with respect to a domain of state descriptors that are a priori 1 The abstract interpretation is actually designed not for a specific program, but for a particular datatype-once designed, it can be used in proving the correctness of multiple programs that manipulate data of that type. /* list.h */ typedef struct node { int d; struct node *n; } *L; Figure 1: A type declaration for singly linked lists.…”