The Reaching Definitions Problem

The Reaching Definitions Problem

1. To give you a sense that data flow analysis is a technique that can be applied to many problems (not just identifying available expressions), I'd like to consider one more problem related to common sub-expression elimination.
2. Recognizing which instances of a common sub-expression are redundant isn't enough to enable us to eliminate the redundant expressions. We also have to make sure that the code generated for certain instances of common sub-expressions leaves their values in places (temporaries) from which they can be retrieved when redundant instances are encountered.

   This can get tricky. In the example program, for instance, we somehow have to arrange to use the same temporary to hold z/n when evaluated before the loop and at the end of the loop.

3. One simple solution to this difficulty would be to ensure that the code generator used the same temporary for all instances of any expression that appears repeatedly in a program.

   This puts more constraints on the code generator than necessary. In the example, there is no reason to put the result of the first instance of y*z in the same location as the result of the instance used for the while loop boolean. Only the value produced for the boolean is used to eliminate evaluation of a redundant CSE.

4. So, we would like to figure out which instances of a CSE are interconnected in the sense that their results have to be left in a common location so that this location can be known when redundant instances are encountered.
5. Somewhat surprisingly, this turns into another data flow problem:
   • In this problem, we will again be computing sets of expressions, but this time instances of CSE's will be considered distinct.
   • We will only consider CSE's with at least one redundant instance.
   • Given a set of identical expressions appearing in the program, we will say that an instance which is not redundant defines or generates the value of the expression while a redundant instance uses the value.
   • Each "use" of a CSE depends on some subset of the instances that "define" the value. For each use, we want to determine the set of definitions on which it depends.
   • Given a program point p, an expression alpha and some "definition", d, for alpha we say that the d "reaches" p if there is some path from the start of the program to p that passes through d such that d is the last definition of alpha on the path.
   • The reaching definitions problem involves associating with each program point p the set of definitions that reach p.
   • We will again associate a KILL set with each variable and a GEN set with each expression. This time KILL will contain the set of all defining instances of all expressions referencing a given variable.

6. With all this said, the equations needed are almost identical to those for AVAIL.

   assignment statements

   Given an assignment of the form

   < p₁ > x := exp < p₂ >

   REACHING(p₂) = ( REACHING(p₁) + { GEN(exp) } -

   { other instances of GEN(exp) } - KILL(x))

   if statement

   Given an if statement of the form:

   < p0 >	if exp	then	< p1 > stmt1 < p3 >
   		else	< p2 > stmt2 < p4 >
   	end < p5 >

   REACHING( p₅ ) = REACHING( p₃ ) U REACHING( p₄ )

   REACHING( p₁ ) = REACHING( p₂ ) = REACHING( p₀ ) -

   {  other instances of subexpressions of exp } + {  GEN(exp)  }

   while loop

   Given a while loop of the form:

   < p0 >	while < p1 >	exp do
   		< p2 > stmt < p3 >
   	end < p4 >

   REACHING( p₁ ) = ( REACHING( p₀ ) U REACHING( p₃ ))

   REACHING( p₂ ) = REACHING( p₄ ) = REACHING( p₁ ) -

   {  other instances of subexpressions of exp } + {  GEN(exp)  }

7. There is one interesting difference between the equations for the reaching definitions problem and those we wrote for the available expressions problem. Reaching definitions uses set union while available expressions uses intersection. This reflects the fact that determining available expressions requires "MUST" information. An expression must be evaluated on all program paths to be available. Reaching definitions, on the other hand, involves "MAY" information. A definition reaches a program point if it may be the last instance evaluated on a path to that program point.

The Reaching Definitions Problem