Abstracting abstract machines

@article{Horn2011AbstractingAM,
  title={Abstracting abstract machines},
  author={David Van Horn and Matthew Might},
  journal={Communications of the ACM},
  year={2011},
  volume={54},
  pages={101 - 109}
}
Predictive models are fundamental to engineering reliable software systems. However, designing conservative, computable approximations for the behavior of programs (static analyses) remains a difficult and error-prone process for modern high-level programming languages. What analysis designers need is a principled method for navigating the gap between semantics and analytic models: analysis designers need a method that tames the interaction of complex languages features such as higher-order… 

Figures from this paper

Systematic abstraction of abstract machines
TLDR
It is demonstrated that the derivational approach to abstract interpretation that yields novel and transparently sound static analyses when applied to well-established abstract machines for higher-order and imperative programming languages scales up uniformly to allow static analysis of realistic language features.
Mailbox Abstractions for Static Analysis of Actor Programs
TLDR
A static technique based on abstract interpretation is developed to soundly reason in a finite amount of time about the possible executions of an actor-based program, and to compute upper bounds on the actors' mailboxes.
Precise Reasoning with Structured Heaps and Collective Operations à la Map / Reduce What Static Analysis can Learn From High-Performance DSLs
TLDR
A formal model, based on a highlevel intermediate analysis language, a practical realization in a prototype tool that analyzes C code, and an experimental evaluation that demonstrates competitive results on a series of benchmarks are presented.
Data flow refinement type inference
TLDR
This work proposes a new refinement type system that is parametric with the choice of the abstract domain of type refinements as well as the degree to which it tracks context-sensitive control flow information, and derives an accompanying parametric inference algorithm as an abstract interpretation of a novel data flow semantics of functional programs.
Type and Control-Flow Analysis for Scheme in Sturdy
TLDR
The here presented type and control-flow analysis is capable to soundly analyze programs with complex control- flow, however this comes at the cost of a high complexity and a reduction in precision.
Optimizing abstract abstract machines
TLDR
This article contributes a complementary step-by-step process for going from a naive analyzer derived under the AAM approach, to an efficient and correct implementation.
Correctly Optimizing Abstract Abstract Machines
TLDR
This article contributes a complementary step-by-step process for going from a naive analyzer derived under the AAM approach, to an efficient and correct implementation.
Skeletal semantics and their interpretations
TLDR
This work defines a general notion of interpretation, which provides a systematic and language-independent way of deriving semantic judgements from the skeletal semantics of a language, and proves general consistency results between interpretations, depending only on simple language-dependent lemmas.
Size-change termination as a contract: dynamically and statically enforcing termination for higher-order programs
TLDR
The approach combines the robustness of the size-change principle for termination with the precise information available at run-time, and has tunable overhead and can check for nontermination without the conservativeness necessary in static checking.
Collapsing towers of interpreters
TLDR
Pink, a meta-circular Lisp-like evaluator on top of a multi-level lambda calculus that features staging constructs and stage polymorphism, is presented, and it is shown how user programs can be compiled and recompiled under user-modified semantics.
...
1
2
...

References

SHOWING 1-10 OF 37 REFERENCES
The essence of compiling with continuations
TLDR
The combined effect of the three phases is equivalent to a source-to-source transformation that simulates the compaction phase and fully developed CPS compilers do not need to employ the CPS transformation but can achieve the same results with a simple source-level transformation.
A concrete framework for environment machines
TLDR
Back to Curien's original calculus of closures (an early calculus with explicit substitutions), it is extended minimally so that it can also express one-step reduction strategies, and a series of environment machines are derived from the specification of two one- step reduction strategies for the lambda-calculus.
Revised6 Report on the Algorithmic Language Scheme
TLDR
Scheme demonstrates that a very small number of rules for forming expressions, with no restrictions on how they are composed, suffice to form a practical and efficient programming language that is flexible enough to support most of the major programming paradigms in use today.
A Calculational Approach to Control-Flow Analysis by Abstract Interpretation
TLDR
A derivation of a control-flow analysis by abstract interpretation of a transition system semantics defined as an abstract machine for a small functional language in continuation-passing style produces a novel characterization of demand-driven 0-CFA.
Polymorphic splitting: an effective polyvariant flow analysis
TLDR
A general-purpose program analysis that computes global control-flow and data-flow information for higher-order, call-by-value languages using a novel form of polyvariance called polymorhic splitting that uses let-expressions as syntactic clues to gain precision.
Improving flow analyses via ΓCFA: abstract garbage collection and counting
We present two independent and complementary improvements for flow-based analysis of higher-order languages: (1) abstract garbage collection and (2) abstract counting, collectively titled
Control-flow analysis of higher-order languages of taming lambda
TLDR
This dissertation presents a technique for recovering the control-flow graph of a Scheme program at compile time, and gives examples of how this information can be used to perform several data-flow analysis optimisations, including copy propagation, induction- variable elimination, useless-variable elimination, and type recovery.
Abstract interpretation: a unified lattice model for static analysis of programs by construction or approximation of fixpoints
A program denotes computations in some universe of objects. Abstract interpretation of programs consists in using that denotation to describe computations in another universe of abstract objects, so
Modular Analysis via Specifications as Values
TLDR
This work introduces a notion of abstract reduction semantics, which is derived from modular static analyzers from these semantics, soundly predicting evaluation, contract violations, and blame assignment.
Control-flow analysis of function calls and returns by abstract interpretation
We derive a control-flow analysis that approximates the interprocedural control-flow of both function calls and returns in the presence of first-class functions and tail-call optimization. In
...
1
2
3
4
...