CFA2: A Context-Free Approach to Control-Flow Analysis

Vardoulakis, Dimitris; Shivers, Olin

doi:10.1007/978-3-642-11957-6_30

Cited by 41 publications

(11 citation statements)

References 24 publications

(22 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Pushdown Control-Flow Analysis. There have been significant efforts to achieve precise call/return matching based on small-step abstract abstract machines [Earl et al 2012;Gilray et al 2016b;Johnson and Van Horn 2014;Vardoulakis and Shivers 2010].…”

Section: Related Workmentioning

confidence: 99%

“…CFA2 is the first solution that solves the return-flow problem [Vardoulakis and Shivers 2010], but CFA2 has several limitations: it only works on continuation-passing style programs, and does not support polyvariant analysis, in addition to having an exponential time complexity. Pushdown control-flow analysis (PDCFA) is a mechanism which maintains this precision through the use of a Dyke state graph representing all possible stacks contained within the unbounded-stack machine [Earl et al 2010[Earl et al , 2012.…”

Section: Related Workmentioning

confidence: 99%

See 1 more Smart Citation

Refunctionalization of abstract abstract machines: bridging the gap between abstract abstract machines and abstract definitional interpreters (functional pearl)

Wei

Decker

Rompf

2018

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

machines is a systematic methodology for constructing sound static analyses for higherorder languages, by deriving small-step abstract abstract machines (AAMs) that perform abstract interpretation from abstract machines that perform concrete evaluation. Darais et al. apply the same underlying idea to monadic definitional interpreters, and obtain monadic abstract definitional interpreters (ADIs) that perform abstract interpretation in big-step style using monads. Yet, the relation between small-step abstract abstract machines and big-step abstract definitional interpreters is not well studied. In this paper, we explain their functional correspondence and demonstrate how to systematically transform small-step abstract abstract machines into big-step abstract definitional interpreters. Building on known semantic interderivation techniques from the concrete evaluation setting, the transformations include linearization, lightweight fusion, disentanglement, refunctionalization, and the left inverse of the CPS transform. Linearization expresses nondeterministic choice through first-order data types, after which refunctionalization transforms the first-order data types that represent continuations into higher-order functions. The refunctionalized AAM is an abstract interpreter written in continuation-passing style (CPS) with two layers of continuations, which can be converted back to direct style with delimited control operators. Based on the known correspondence between delimited control and monads, we demonstrate that the explicit use of monads in abstract definitional interpreters is optional. All transformations properly handle the collecting semantics and nondeterminism of abstract interpretation. Remarkably, we reveal how precise call/return matching in control-flow analysis can be obtained by refunctionalizing a small-step abstract abstract machine with proper caching.

show abstract

Section: Related Workmentioning

confidence: 99%

Section: Related Workmentioning

confidence: 99%

Refunctionalization of abstract abstract machines: bridging the gap between abstract abstract machines and abstract definitional interpreters (functional pearl)

Wei

Decker

Rompf

2018

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

show abstract

“…js 0 is a higher‐order, functional, and object‐oriented language. Because function call and return is the dominant control flow pattern in higher‐order, functional programs, the flow analysis models call/return as a pushdown analysis() instead of a more classic but less precise finite‐state analysis.…”

Section: Flow Analysismentioning

confidence: 99%

Purity analysis for JavaScript through abstract interpretation

Nicolay

Stiévenart

Meuter

et al. 2017

J Software Evolu Process

View full text Add to dashboard Cite

We present a static analysis for determining whether and to what extent functions in JavaScript programs are pure. To this end, the analysis classifies functions as pure functions, observers, or procedures. A function is pure if none of its executions generate or depend upon externally observable side effects. A function is an observer as soon as one of its executions depends on an external side effect, but none of its executions generate observable side effects. Otherwise, the function is classified as a procedure. Function executions and associated callers are found by traversing all reachable function execution contexts on the call stack at the point where an effect occurs. Our approach is based on a flow analysis that, in addition to computing traditional control and value flow, keeps track of read and write effects. To increase the precision of our purity analysis, we combine it with an intraprocedural analysis that determines freshness of variables and objects. We formalize the core aspects of our technique and discuss its implementation and results on common JavaScript benchmarks. Results show that our approach is capable of determining function purity in the presence of higher‐order functions, dynamic property expressions, and prototypal inheritance. When compared with existing purity analyses, we find that our approach is as precise or more precise than the existing analyses.

show abstract

“…Higher-order functions are extremely useful to structure programs but also pose a significant obstacle for compilers, recent advances on higher-order control-flow analysis notwithstanding [46,22]. While we would like to retain the structuring aspect for DSL programs, we would like to avoid higher-order control flow in generated code.…”

Section: Leveraging Higher-order Functions In the Generatormentioning

confidence: 99%

Building-Blocks for Performance Oriented DSLs

Rompf

Sujeeth

Lee

et al. 2011

Electron. Proc. Theor. Comput. Sci.

View full text Add to dashboard Cite

Domain-specific languages raise the level of abstraction in software development. While it is evident that programmers can more easily reason about very high-level programs, the same holds for compilers only if the compiler has an accurate model of the application domain and the underlying target platform. Since mapping high-level, general-purpose languages to modern, heterogeneous hardware is becoming increasingly difficult, DSLs are an attractive way to capitalize on improved hardware performance, precisely by making the compiler reason on a higher level. Implementing efficient DSL compilers is a daunting task however, and support for building performance-oriented DSLs is urgently needed. To this end, we present the Delite Framework, an extensible toolkit that drastically simplifies building embedded DSLs and compiling DSL programs for execution on heterogeneous hardware. We discuss several building blocks in some detail and present experimental results for the OptiML machine-learning DSL implemented on top of Delite

show abstract

CFA2: A Context-Free Approach to Control-Flow Analysis

Cited by 41 publications

References 24 publications

Refunctionalization of abstract abstract machines: bridging the gap between abstract abstract machines and abstract definitional interpreters (functional pearl)

Refunctionalization of abstract abstract machines: bridging the gap between abstract abstract machines and abstract definitional interpreters (functional pearl)

Purity analysis for JavaScript through abstract interpretation

Building-Blocks for Performance Oriented DSLs

Contact Info

Product

Resources

About