SSA without Dominance for Higher-Order Programs

TL;DR

This paper introduces a dominance-free approach to SSA for higher-order programs, using free variables to improve analysis precision and extend applicability beyond traditional control-flow graphs.

Contribution

It proposes a novel foundation based on free variables, along with new algorithms and data structures like the nesting tree for higher-order program analysis.

Findings

Algorithms scale log-linearly with program size

Free-variable-based analysis improves precision over dominance-based methods

Extends SSA analysis to higher-order languages without explicit CFGs

Abstract

Dominance is a fundamental concept in compilers based on static single assignment (SSA) form. It underpins a wide range of analyses and transformations and defines a core property of SSA: every use must be dominated by its definition. We argue that this reliance on dominance has become increasingly problematic -- both in terms of precision and applicability to modern higher-order languages. First, control flow overapproximates data flow, which makes dominance-based analyses inherently imprecise. Second, dominance is well-defined only for first-order control-flow graphs (CFGs). More critically, higher-order programs violate the assumptions underlying SSA and classic CFGs: without an explicit CFG, the very notion that all uses of a variable must be dominated by its definition loses meaning. We propose an alternative foundation based on free variables. In this view, $\phi$-functions and function parameters directly express data dependencies, enabling analyses traditionally built on dominance while improving precision and naturally extending to higher-order programs. We further present an efficient technique for maintaining free-variable sets in a mutable intermediate representation (IR). For analyses requiring additional structure, we introduce the nesting tree -- a relaxed analogue of the dominator tree constructed from variable dependencies rather than control flow. Our benchmarks demonstrate that the algorithms and data structures presented in this paper scale log-linearly with program size in practice.