More precise construction of static single assignment programs using reaching definitions

Abstract

The Static Single Assignment (SSA) form is an intermediate representation used for the analysis and optimization of programs in modern compilers. The ϕ-function placement is the most computationally expensive part of converting any program into its SSA form. The most widely-used ϕ-function placement algorithms are based on computing dominance frontiers (DF). However, this kind of algorithms works under the limiting assumption that all variables are defined at the beginning of the program, which is not the case for local variables. In this paper, we introduce an innovative ϕ-placement algorithm based on computing reaching definitions (RD), which generates a precise number of ϕ-functions. We provided theorems and proofs showing the correctness and the theoretical computational complexity of our algorithms. We implemented our approach and a well-known DF-based algorithm in the Clang/LLVM compiler framework, and performed experiments on a number of benchmarks. The results show that the limiting assumption of the DF-based algorithm when compared with the more accurate results of our RD-based approach leads to generating up to 87% (69% on average) superfluous ϕ-functions on all benchmarks, and thus brings about a significant precision loss. Moreover, even though our approach computes more information to generate precise results, it is able to analyze up to 92.96% procedures (65.63% on average) of all benchmarks with execution time within twice the execution time of the reference DF-based approach.

Introduction

Most current compilers and virtual machines, including the well-known GNU Compiler Collection (GCC)¹, the LLVM Compiler Infrastructure (LLVM)², and the Java Hotspot³, use the so-called static single assignment (SSA) form as an intermediate representation (IR) of programs. SSA programs are often used for efficient program analysis, transformation, optimization, and efficient register allocation. Programs represented in the SSA form require that each variable is defined exactly once, but it may be used multiple times. Moreover, the variable definition should always appear before its use.

Any straight-line sequence of non-SSA code can be converted to SSA form by using a suitable renaming of the program variables that adheres to the definition of SSA program as shown in Fig. 1. However, if the code contains branching instructions, the renaming process becomes complicated by the fact that multiple definitions of a program variable may reach at control flow merge points. For example, the print statement in Fig. 2 receives two distinct definitions of Y from two different branches of the if statement. It may be hard, or even impossible, to statically decide which definition of that variable to use afterwards. Any non-SSA program is transformed to the SSA form by performing the following two steps:

• identifying the merge points in the control flow graph (CFG) of the program to place pseudo-assignments of the form $x=\varphi (x,\dots ,x)$ for each variable x, where multiple distinct definitions of x may arrive through different branches of the control flow, and

• renaming each x such that any assignment or pseudo-assignment to x (i.e., a definition of x) is uniquely renamed and uses the renamed x at each reference of that particular definition.

Each argument of the ϕ-function corresponds to a particular reaching definition of x coming from one of the branches. Thus, a so-called join set $J^{+}\left(S\right)$ identifying all those merge points requiring pseudo-assignments for each variable x needs to be constructed, where S is the set of CFG nodes containing assignments to x.

Cytron et al. (1991) have carried out pioneering work on the establishment of a pragmatically efficient construction of the SSA form based on computing so called dominance frontiers (DF), which are relations among CFG nodes based on dominators.⁴ This approach is currently leveraged by most SSA construction algorithms used by modern compilers, such as LLVM. A closer look to Cytron et al.’s approach shows that, on the assumption that computing the aforementioned join set $J^{+}\left(S\right)$ is practically inefficient, an efficient alternative would be instead to compute the iterated dominance frontier $D{F}^{+}\left(S\right)$. This is an approximation that is possible thanks to the equality relation $D{F}^{+}\left(S\right)=J^{+}\left(S\right),$ that holds when S contains the Entry node of the CFG (Cytron, Ferrante, Rosen, Wegman, Zadeck, 1991, Weiss, 1992). The set S contains all CFG nodes in which a particular program variable is defined. Since the Entry node is considered to be included into S due to $D{F}^{+}\left(S\right)=J^{+}\left(S\right),$ DF-based SSA construction methods implicitly consider that all program variables are defined at the beginning of the program. This is a limiting restriction and it cannot always hold, especially for local variables, which are mostly declared at the beginning, but defined later in the program. Thus, all DF-based SSA construction algorithms produce superfluous ϕ-functions and hence construct larger SSA programs than necessary.

Our Contribution In this work, we explore the impact of the seemingly benign equality condition by which S includes the Entry node of $D{F}^{+}\left(S\right)=J^{+}\left(S\right)$. To do so, we provide an algorithm based on computing reaching definitions (RDs) (Nielson et al., 1999) that can accurately compute the join set $J^{+}\left(S\right)$ where we can freely choose the set S of variable definitions. Computing RDs for SSA construction is nontrivial and more complex than computing RDs for program analysis. Our novel approach to compute the $J^{+}\left(S\right)$ set is efficient on most of our benchmarks. By including the Entry node into S, then DF-based approaches and ours produce the same number of ϕ-functions.

On the other hand, our algorithm is able to produce more accurate ϕ-functions by considering that only global variables and formal parameters are defined at the Entry node of the CFG. Our experiments on a number of benchmarks reveal that DF-based SSA construction approach generates (i) up to 87% and on an average 69% superfluous ϕ-functions compared to the ϕ-functions generated by our RD-based approach. Our approach is applicable to both structured and unstructured programs containing dense or sparse variable definitions. Moreover, along with constructing the SSA form, our RD information can be re-used to optimize the generated SSA program.

Note that this is an invited extended version of the paper entitled “Towards constructing the SSA form using reaching definitions over dominance frontiers” (Masud and Ciccozzi, 2019) and published at the IEEE International Working Conference on Source Code Analysis and Manipulation. More specifically, this article has been extended as follows:

• We have included a new section with a detailed description of where and how the DF-based approach loses precision in computing ϕ-functions (Section 3).

• We have extended the formal development of RD-based SSA construction in Section 4.2. Three new algorithms (Algorithm 3, Algorithm 5) are included to provide a complete and detailed picture of how we perform the computation.

• We have added a new section (Section 5) providing discussion about the proof of correctness of our algorithms and their computational complexity. Section 5.1 provides Theorem 1 and its proof along with some auxiliary lemmas to prove the correctness of our algorithms and Section 5.2 includes Theorem 2, some auxiliary lemmas and their proofs stating the computational complexity of our algorithms.

• We have extended our experimental evaluation by running our solution on six additional benchmarks, which confirmed our positive results (Section 6).

Paper organization The remainder of the paper is organized as follows. In Section 2 we provide core concepts and terminology upon which our approach is based. In Section 3 we provide a description of precision loss in the DF-based approach. Our RD-based approach is described in detail in Section 4, while a discussion of the its correctness and computational complexity is given in Section 5. The extended experimental evaluation is presented in Section 6. Related works are outlined in Section 7 and the paper is concluded by Section 8 with a summary and future work.