Interactive Abstract Interpretation: Reanalyzing Whole Programs for Cheap

  title={Interactive Abstract Interpretation: Reanalyzing Whole Programs for Cheap},
  author={Julian Erhard and Simmo Saan and Sarah Tilscher and Michael Schwarz and Karoliine Holter and Vesal Vojdani and Helmut Seidl},
To put static program analysis at the fin-gertips of the software developer, we propose a framework for interactive abstract interpretation. While pro-viding sound analysis results, abstract interpretation in general can be quite costly. To achieve quick response times, we incrementalize the analysis infrastructure, including postprocessing, without necessitating any modifications to the analysis specifications themselves. We rely on the local generic fixpoint engine TD , which dynamically tracks… 

Figures from this paper

Incremental Abstract Interpretation

It is shown that incremental static analysis reuses analysis results computed for earlier versions of the source code where possible and can seamlessly be achieved for the analysis of C programs if a local generic solver such as the top-down solver is used as the fixed-point engine.

Demanded abstract interpretation

It is proved that desirable abstract interpretation meta-properties, including soundness and termination, are preserved in the approach, and that demanded analysis results are equal to those computed by a batch abstract interpretation.

Incremental analysis of constraint logic programs

The fixed-point algorithms used in current generic analysis engines for (constraint) logic programming languages can be extended to support incremental analysis to show significant benefits when using the proposed incremental analysis algorithms.

Incremental Flow Analysis through Computational Dependency Reification

This work presents a general approach to render a modular static analysis for highly dynamic programs incremental, by exploiting dependencies between intermediate analysis results, and finds reductions of the analysis time from 6% to 99% on 14 out of 16 benchmark programs, and on most programs the impact on precision is limited.

Reviser: efficiently updating IDE-/IFDS-based data-flow analyses in response to incremental program changes

The Reviser algorithm is formulated as an extension to the IDE framework for Inter-procedural Finite Distributed Environment problems and automatically updates arbitrary IDE-based analyses and shows performance gains of up to 80% in comparison to a full recomputation.

Improving Thread-Modular Abstract Interpretation

It is shown that a generalization of the analysis provided by the static analyzer Goblint as well as a natural improvement of Antoine Miné’s approach can be obtained as instances of this general scheme of thread-modular non-relational value analyses.

Scalable and incremental software bug detection

This work presents a technique for parallel and incremental static analysis using top-down, bottom-up and global specification inference based around the concept of a work unit, a self-contained atom of analysis input that deterministically maps to its output.

Incremental and Modular Context-sensitive Analysis

The experimental results show that the proposed modular algorithm shows significant improvements, in both time and memory consumption, when compared to existing non-modular, fine-grain incremental analysis techniques, and outperforms traditional modular analysis even when analyzing from scratch.

Side-Effecting Constraint Systems: A Swiss Army Knife for Program Analysis

This paper shows how this side-effecting constraint systems formalism provides a unified framework for realizing efficient interprocedural analyses where the amount of context-sensitivity can be tweaked and where the context-sensitive analyses of local properties can be combined with flow-insensitive analyses of global properties.

Sound static deadlock analysis for C/Pthreads

A static deadlock analysis for C/Pthreads that is sound for programs that have defined behaviour according to the C standard and the Pthreads specification, and precise enough to prove deadlock-freedom for a large number of such programs.