Detection of Redundant Expressions: A Complete and Polynomial-Time Algorithm in SSA

Abstract

Detection of redundant expressions in a program based on values is a well researched problem done with a view to eliminate the redundancies so as to improve the run-time efficiency of the program. The problem entails the detection of equivalent expressions in a program. Here we present an iterative data-flow analysis algorithm to detect equivalent expressions in SSA for the purpose of detection of redundancies. The central challenge in this static analysis is to define a “join” operation to detect all equivalences at a join point such that any later occurrences of redundant expressions are detected in polynomial time. We achieve this by introducing the notion of value $\phi$ -function. We claim the algorithm is complete and takes only polynomial time. We implemented the algorithm in LLVM and demonstrated its performance.

A Appendix

1.1 A.1 VALUEPHIFUNC

This recursive function computes value $\phi$-function of a given value expression. The function assumes partitions at out of each block is available to it. The function uses equiVE to replace operands of a given value expression with equivalent value $\phi$-functions, whenever possible. Else it returns the value expression as such. The getVN function used here takes a partition at out of either the left or right predecessor of a join block k. It searches for the input value expression in the partition and returns its value number, if present. If the partition was searched for previously then the function returns a new value number. This case can arise with loops in the program.

1.2 A.2 Proof

Correctness of Join Algorithm

Lemma 1

If $e_{1} \equiv e_{2}$ at a point p and the point p dominates join point j then $e_{1} \equiv e_{2}$ at j iff the algorithm detects their equivalence.

Proof

Let expressions $e_{1}$ and $e_{2}$ be equivalent at a point p such that p dominates join point j. Since a variable is defined only once in SSA the expressions are equivalent in each path to j. Line 1 in the algorithm Intersect ensures such common equivalences are detected at the join point.    $\square$

Lemma 2

If variable $x \equiv y$ in each path to join point j then $x \equiv y$ at j iff the algorithm detects their equivalence.

Proof

Let two variables x and y be equivalent in each path to join point j. Then by suitably transforming the $\phi$-functions in the join block j and by line 1 of the Intersect algorithm such equivalences could also be detected.    $\square$

Let there be expressions $e_{i}$ in each path to an expression e and $e_{i} \equiv e$ in respective paths. The equivalences are detected by the transferFunction algorithm which is proved below.

Correctness of transferFunction Algorithm

Lemma 3

Let $x = e$ be a statement at a point p in the program and there exist expressions $e_{i}$ at points $p_{i}$ in each path to p such that at least one of the $p_{i}$’s does not dominate p. Then expression e has a value $\phi$-function, as computed by valuePhiFunc algorithm, iff expressions $e_{i}$ and e are equivalent in respective paths.

Proof

This can be proved by induction on the number of join points in paths with the base case similar to that in Fig. 4.    $\square$

Lemma 4

Let $x = e$ be a statement at a point p in the program and there exists expressions $e_{i}$ in each path to p. Expressions $e_{i}$ and e are equivalent in respective paths iff the transferFunction algorithm detects the equivalences.

Proof

Let the expression(s) $e_{i}$ appear at point $p^{\prime }$ such that $p^{\prime }$ dominate p. Then an equivalence class for $e_{i}$ with its value expression will appear in the partition at $p^{\prime }$ (ensured by lines 7 and 8 in the algorithm). Since a variable is defined only once in SSA the partition at in point of the statement $x = e$ will have a class with the value expression of $e_{i}$. Then line 6 in the algorithm ensures equivalence of $e_{i}$ and e is detected.

Now consider the case where an expression $e_{i}$ appear at a point $p^{\prime }$ such that $p^{\prime }$ does not dominate p. In this case computation of value $\phi$-function in line 5 (Lemma 3) and subsequent check for its existence in line 6 ensures detection of equivalences of $e_{i}$ and e in respective paths.    $\square$

Correctness of Iterative Data-Flow Analysis Algorithm

Theorem 1

(Soundness and Completeness). Let P be a partition at a point p computed by the iterative data-flow analysis algorithm. Two expressions are equivalent at p iff the algorithm detects their equivalence.

Proof

This follows from Lemmas 1, 2, and 4.    $\square$

Correctness of Algorithm for Detection of Redundancies

Theorem 2

(Soundness and Completeness). Let $s: z = x + y$ be a statement at a point p. The expression $x+y$ is redundant iff the algorithm detects its redundancy.

Proof

This follows from Theorem 1.    $\square$