Environment analysis via ΔCFA

MightMatthew,; ShiversOlin,

doi:10.1145/1111320.1111049

Cited by 6 publications

(4 citation statements)

References 9 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…We have excised portions of the proofs that do not differ from an ordinary proof of correctness for a control-flow analysis. These portions are the same as the ones we have presented in earlier work (Shivers 1991;Might & Shivers 2006a). To show the correctness of the abstract semantics, we must show that they simulate the concrete semantics.…”

Section: Soundness Of the Abstract Semanticsmentioning

confidence: 91%

“…(Control-flow analysis for which abstract garbage collection enhances precision offers a number of applications, including but certainly not limited to constant propagation, useless-variable elimination and induction-variable elimination (Shivers 1991).) Environment analysis drives globalization, lightweight closure conversion, super-β lambda propagation, super-β copy propagation and continuation promotion (Shivers 1991;Wand & Steckler 1944;Might & Shivers 2006a;.…”

Section: Applicationsmentioning

confidence: 99%

“…In other work (Might & Shivers 2006a;, we have developed a technique, ΔCFA, for performing environment analysis using abstract frame strings. Like other environment analyses, ΔCFA relies upon the ability to infer concrete equality from certain abstract conditions.…”

Section: Related Workmentioning

confidence: 99%

See 2 more Smart Citations

Exploiting reachability and cardinality in higher-order flow analysis

Might¹,

Shivers²

2008

J. Funct. Prog.

Self Cite

View full text Add to dashboard Cite

We present two complementary improvements for abstract-interpretation-based flow analysis of higher-order languages: (1) abstract garbage collection and (2) abstract counting. 1,2 Abstract garbage collection is an analog to its concrete counterpart: the analysis determines when an abstract resource has become unreachable, and then, re-allocates it as fresh. This prevents flow sets from joining during abstract interpretation, which has two immediate effects: (1) the precision of the interpretation increases and (2) its running time often falls. In abstract counting, the analysis tracks how many times an abstract resource has been allocated. A count of one implies that the abstract resource momentarily represents only one concrete resource. This knowledge, in turn, drives environment analysis, expanding the kind (rather than just the degree) of optimization available to the compiler.

show abstract

Section: Soundness Of the Abstract Semanticsmentioning

confidence: 91%

Section: Applicationsmentioning

confidence: 99%

See 1 more Smart Citation

Exploiting reachability and cardinality in higher-order flow analysis

Might¹,

Shivers²

2008

J. Funct. Prog.

Self Cite

View full text Add to dashboard Cite

show abstract

“…The flow analysis portion of this work descends directly from Shivers' original work [17] and from earlier work on ΓCFA and ΔCFA [11,10]. LFA has also been influenced by efforts in improving speed and precision, such as work by Rehof, et al [15] and Agesen [1].…”

Section: Related Workmentioning

confidence: 99%

Logic-flow analysis of higher-order programs

Might¹

2007

Proceedings of the 34th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages

Self Cite

View full text Add to dashboard Cite

This work presents a framework for fusing flow analysis and theorem proving called logic-flow analysis (LFA). The framework itself is the reduced product of two abstract interpretations: (1) an abstract state machine and (2) a set of propositions in a restricted first-order logic. The motivating application for LFA is the safe removal of implicit array-bounds checks without type information, user interaction or program annotation. LFA achieves this by delegating a given task to either the prover or the flow analysis depending on which is best suited to discharge it. Described within are a concrete semantics for continuation-passing style; a restricted, firstorder logic; a woven product of two abstract interpretations; proofs of correctness; and a worked example. float[][3] vertices = vector of points ; int[] mesh = indices into vertices ; for (int i = 0; i < mesh.length; i++) // Safe if 0 ≤ mesh[i] < vertices.length. emitv( vertices[mesh[i]] );The safety of the access to vertices depends upon the manner in which mesh is built and modified. Furthermore, at certain points during its lifetime, mesh will only partially satisfy the invariants required to prove the safety of the subsequent accesses to vertices. Section 6 steps through an example of vertex arrays to show how LFA proves safety under these circumstances. High-level mechanicsIn Section 2, an operational semantics defines a concrete state machine. The analysis then performs two abstract interpretations of this machine: one where a concrete machine state (ς) abstracts component-wise into an abstract machine state (b ς), and one where it abstracts into a set of propositions (Π). However, rather than run each interpretation independently, as in the following diagram: b ς

show abstract

A Posteriori Soundness for Non-deterministic Abstract Interpretations

Might

Manolios

2008

Lecture Notes in Computer Science

Self Cite

View full text Add to dashboard Cite

Abstract. An abstract interpretation's resource-allocation policy (e.g., one heap summary node per allocation site) largely determines both its speed and precision. Historically, context has driven allocation policies, and as a result, these policies are said to determine the "contextsensitivity" of the analysis. This work gives analysis designers newfound freedom to manipulate speed and precision by severing the link between allocation policy and context-sensitivity: we find that abstract allocation policies may be unhinged not only from context, but also from even a predefined correspondence with a concrete allocation policy. We do so by proving that abstract allocation policies can be made non-deterministic without sacrificing correctness; this non-determinism permits precisionguided allocation policies previously assumed to be unsafe. To prove correctness, we introduce the notion of a posteriori soundness for an analysis. A proof of a posteriori soundness differs from a standard proof of soundness in that the abstraction maps used in an a posteriori proof cannot be constructed until after an analysis has been run. Delaying construction allows them to be built so as to justify the decisions made by non-determinism. The crux of the a posteriori soundness theorem is to demonstrate that a justifying abstraction map can always be constructed.

show abstract

Environment analysis via ΔCFA

Abstract: We describe a new program-analysis framework, based on CPS and procedure-string abstractions, that can handle critical analyses which the k -CFA framework cannot. We present the main theorems concerning correctness, show an application analysis, and describe a running implementation.

Cited by 6 publications

References 9 publications

Exploiting reachability and cardinality in higher-order flow analysis

Exploiting reachability and cardinality in higher-order flow analysis

Logic-flow analysis of higher-order programs

A Posteriori Soundness for Non-deterministic Abstract Interpretations

Contact Info

Product

Resources

About