Pushdown flow analysis with abstract garbage collection

Abstract

In the static analysis of functional programs, pushdown flow analysis and abstract garbage collection push the boundaries of what we can learn about programs statically. This work illuminates and poses solutions to theoretical and practical challenges that stand in the way of combining the power of these techniques. Pushdown flow analysis grants unbounded yet computable polyvariance to the analysis of return-flow in higher-order programs. Abstract garbage collection grants unbounded polyvariance to abstract addresses which become unreachable between invocations of the abstract contexts in which they were created. Pushdown analysis solves the problem of precisely analyzing recursion in higherorder languages; abstract garbage collection is essential in solving the "stickiness" problem. Alone, our benchmarks demonstrate that each method can reduce analysis times and boost precision by orders of magnitude. We combine these methods. The challenge in marrying these techniques is not subtle: computing the reachable control states of a pushdown system relies on limiting access during transition to the top of the stack; abstract garbage collection, on the other hand, needs full access to the entire stack to compute a root set, just as concrete collection does. Conditional pushdown systems were developed for just such a conundrum, but existing methods are ill-suited for the dynamic nature of garbage collection. We show fully precise and approximate solutions to the feasible paths problem for pushdown garbage-collecting control-flow analysis. Experiments reveal synergistic interplay between garbage collection and pushdown techniques, and the fusion demonstrates "better-than-bothworlds" precision.

Liberate Abstract Garbage Collection from the Stack by Decomposing the Heap

“…Johnson and Van Horn [8] reformulated this incomplete technique for an operational setting and offered a complete-albeit theoretically more-expensive-technique capable of more precision. Johnson et al [7] unified these techniques within an expanded framework. Darais et al [1] then showed that the Abstracting Definitional Interpreters-approach-currently the state of the art-is compatible with the complete technique by including the set of stack root addresses as a component in the evaluation configuration.…”

“…If evaluation results in a value-store pair, this incoming environment is extended with a binding derived from the bound variable and incoming binding context. 7 The resultant store is extended with mapping from that binding to the resultant value. The body expression is evaluated under the extended environment and store and its result becomes that of the overall expression.…”

“…This question has been addressed by two techniques: The first introspective technique [4] introduces a primitive operation into the analyzing machine which introspects the stack and delivers the set of frames which may be live; this technique has a variety of alternative formulations, some of which alter its complexity-precision profile [8,7]. The second technique [1], which modifies the first to work with definitional interpreters, dictates that the analyzer implement a set-passing style abstract semantics where each passed set contains the heap addresses present in the continuation at that point.…”

Abstracting abstract control

“…But most languages provide features that transgress that discipline, such as garbage collection, first-class control operators, stack inspection, and so on. Some of these features have been successfully combined with pushdown analysis, but required technical innovation and effort [13,19,41]. To avoid further one-off efforts, we develop a general technique for creating pushdown analyses for languages with control operators and reflective mechanisms.…”

“…We then show how the approach scales to stack-reflecting language features such as garbage collection and stack inspection ( §5), and stack-reifying features in the form of first-class delimited control operators ( §6). These case studies show that the approach is robust in the presence of features that need to inspect or alter the run-time stack, which previously have required significant technical innovations [19,41].…”