SPL Decompositions for Structured CFGs

• SPL Decompositions are a graph-theoretic framework that exactly characterizes structured control-flow graphs using a four-terminal boundary.
• They enable linear-time dynamic programming algorithms that outperform treewidth/pathwidth-based methods in compiler optimization tasks.
• Practical applications include lifetime-optimal speculative partial redundancy elimination and register allocation in modern compilers.

A Series-Parallel-Loop (SPL) decomposition is a canonical graph-theoretic framework that exactly characterizes control-flow graphs (CFGs) of structured (goto-free) programs. It encodes the recursive syntactic structure of source code directly into a parse tree over an SPL grammar, where each nonterminal represents a four-terminal graph with boundary vertices for entry ($S$), exit ($T$), break-target ($B$), and continue-target ($C$). This decomposition yields constant-size cuts at every step, enabling highly efficient, linear-time dynamic programming algorithms for a wide range of problems in compiler optimization and program analysis on structured programs, particularly outperforming classical approaches based on treewidth or pathwidth for these graph classes (Cai et al., 7 Feb 2026, Cai, 22 Jul 2025, Cai et al., 3 Feb 2026).

1. SPL Grammar and Expressiveness

The SPL grammar generates all and only the control-flow graphs arising from goto-free structured source code, as captured by the following productions:

• $$G ::= A_{\epsilon} \mid A_{\mathrm{break}} \mid A_{\mathrm{continue}}$$
• $$G ::= G\ \circ_{\mathrm{series}}\ G \mid G\ \circ_{\mathrm{parallel}}\ G \mid \mathrm{loop}(G)$$

Here, atomic graphs correspond to minimal program fragments (empty, break, continue), and the operations correspond to sequential composition, branching, and loop encapsulation:

• Series merges $T_1 = S_2$, $B_1 = B_2$, $C_1 = C_2$
• Parallel merges all four terminals across two subgraphs
• Loop wraps a subgraph to represent structured while-loops, introducing new terminals and connecting loop-exit, break, and continue edges

SPL decomposition precisely captures program syntax: any structured CFG admits a unique such decomposition, obtainable in $O(|G|)$ time via syntactic parsing or direct analysis of the program’s grammar derivation (Cai et al., 7 Feb 2026, Cai, 22 Jul 2025).

2. Algorithmic Framework—SPL-Based Dynamic Programming

For optimization tasks reducible to local or binary domain partial constraint satisfaction problems (PCSPs), the SPL parse tree facilitates a dynamic programming (DP) scheme where each node $u$ maintains a table over possible “life-masks” or abstract states $X \subseteq \Gamma_u$ for the boundary vertices $\Gamma_u = \{S_u, T_u, B_u, C_u\}$. For each such mask, the DP computes the optimal cost of completing the solution on the subgraph $G_u$ with boundary conditions $X$ (Cai et al., 3 Feb 2026).

• Atomic nodes: Table entries are computed directly from the cost structure (e.g., liveness and injection costs for LOSPRE).
• Series nodes: Enumerate compatible child masks, glue subsolutions, adjust for double counting on merged terminals.
• Parallel nodes: Child tables are merged for identical interface states, subtracting duplicated terminal costs.
• Loop nodes: Backedge and loop entry/exit connections are handled, merging subproblem solutions with local cost contributions from the new loop-specific edges and vertices.

The DP fills $O(2^4) = 16$ table entries per node for LOSPRE (liveness problem), and for richer PCSP domains (e.g., three bits per node for use, live, and invalidate), one obtains $O(8^4)$ combinatorial states per node. In practice, only a constant number of compatible child masks need to be checked per parent mask due to the structural properties of SPL gluing (Cai, 22 Jul 2025, Cai et al., 7 Feb 2026).

3. Applications: Lifetime-Optimal Speculative Partial Redundancy Elimination (LOSPRE)

LOSPRE exemplifies the power of SPL decomposition, as it seeks to minimize:

$$\text{Cost}(G, U, I, L) = \sum_{e \in C(U, L, I)} c(e) + \sum_{v \in L} \ell(v)$$

where $$C(U, L, I) = \{ (x, y) \in E \mid x \notin (L \setminus I),\ y \in (U \cup L) \}$$ denotes edges where the target requires the expression value but the source either does not have it alive or was invalidated.

• The SPL-based DP for LOSPRE achieves $O(n)$ time and space for all structured programs, asymptotically beating previous treewidth/pathwidth-based methods by an order of magnitude due to the constant four-terminal interface (Cai et al., 7 Feb 2026, Cai, 22 Jul 2025, Cai et al., 3 Feb 2026).
• Unlike bag-based decompositions (treewidth $\leq 7$ implies cut sizes up to 8 for C/Java), SPL’s boundary never exceeds 4.
• Empirically, SPL-based LOSPRE solvers run 4–6× faster than classical treewidth-based DP on >10,000-function datasets, with parsing overhead of only %%%%21$X$22%%%%s per function and DP runtimes of $\approx$222$\mu$s per function (Cai et al., 7 Feb 2026, Cai, 22 Jul 2025).
• The approach extends naturally to more general PCSP-based optimizations, such as cost-minimizing register allocation and optimal placement of bank selection instructions (Cai, 22 Jul 2025, Cai et al., 3 Feb 2026).

4. Theoretical and Practical Advantages

Theoretical:

• SPL grammar exactly characterizes structured CFGs, strictly excluding graphs of low treewidth but with unstructured (irreducible) flow (Cai et al., 7 Feb 2026, Cai, 22 Jul 2025).
• The decomposition is smaller, cut size four versus up to eight for tree decompositions.
• The parse tree is a rooted binary tree with $O(n)$ nodes, permitting bottom-up DP and constant per-node work for all problems expressible as binary-domain PCSPs.

Practical:

• Implementation in SDCC and other compilers demonstrates substantial compile-time overhead reduction: SPL-Lospre averages only $\approx$1.75% of compile time with $66\%$ attributed to optimization, and $29\%$ to supporting safety analyses (Cai et al., 7 Feb 2026, Krause, 2020).
• For register allocation, the SPL-based exact solver handles up to 20 registers in microseconds, while treewidth/FPT-based solvers timeout past 8 registers.
• Results for real-world code (Contiki OS, SDCC regression suites) show SPL-based methods not only outperform heuristics in quality (exact solutions) but also deliver at near-competitive speeds—a 5–10$\times$ cost for a $\approx$55% improvement in optimality (Cai et al., 7 Feb 2026).

Decomposition	Max Boundary Size	Runtime (LOSPRE)	Class Captured
Treewidth-based	≤ 8	$O(n \cdot 2^8)$	All graphs with $\mathrm{tw} \leq 7$
Pathwidth-based	$\leq 2\,n+1$	Superlinear	Path-like graphs
SPL (Series-Parallel-Loop)	4	$O(n)$	Structured CFGs only

5. Limitations and Scope

SPL decompositions are only defined for structured CFGs. Unstructured graphs with arbitrarily placed gotos violate SPL expressibility, necessitating fallback to treewidth- or flow-based approaches, or extensions via cycle cuts or global SDP (Cai et al., 7 Feb 2026, Cai, 22 Jul 2025). Additional limitations include:

• Exclusively intraprocedural: SPL accounts only for control flow within a single function; interprocedural propagation is an open problem.
• Single-expression focus: Each LOSPRE instance applies per expression; joint approaches may incur exponential blow-up in domain size.
• Structuredness required: CFGs with irreducible loops or unstructured control cannot benefit from SPL unless generalized (Cai, 22 Jul 2025).

A plausible implication is that, while SPL yields optimal and fast results on virtually all structured real-world CFGs (empirically, most functions have treewidth $\leq 3$–4 and are SPL-decomposable), it is not directly applicable to low-level systems code or languages relying on heavy goto usage.

6. Extensions and Connections

SPL decomposition subsumes and strengthens classical approaches that model CFG structure using treewidth or pathwidth. Its boundary-focused grammar enables tight integration with program syntax, and the framework is extensible to any dataflow or code motion problem whose solution propagates via a bounded (four-terminal) abstract state (Cai et al., 7 Feb 2026, Cai, 22 Jul 2025, Cai et al., 3 Feb 2026).

Potential extensions discussed in the literature include:

• Generalization to CFGs admitting bounded-pathwidth “if-then-else plus goto” fragments;
• Multi-expression, joint PCSP formulations, subject to domain size constraints;
• Integration with pointer-alias analyses, interprocedural constructs, and richer cost models, e.g., register pressure or bank selection.

Overall, SPL decomposition delivers an exact, efficiently computable, and syntax-aligned representation of structured program control flow, providing the basis for the current state-of-the-art in a range of compiler optimizations (Cai et al., 7 Feb 2026, Cai, 22 Jul 2025, Cai et al., 3 Feb 2026, Krause, 2020).