Value Numbering (cont.)

Value Numbering (cont.)

1. Value number identifies common subexpressions, by using a table lookup mechanism to associate numbers with instances of expressions in a program in such a way that:
   • If two expressions are certain to produce the same value at run-time, then they may be assigned the same value number.
   • If two expressions may produce different values at run-time, then they are certain to be assigned different value numbers.
2. The algorithm proceeds assigning value numbers while traversing a sequence of statements that must be executed sequentially.

   • Each variable used in the statements being processed is assigned a distinct value number before processing begins (at least logically).
   • Constants and expressions using unary and binary operators are assigned value numbers using a hash table lookup. When a constant is encountered we just hash it and look it up. When an expression is encountered, first determine the value numbers of its sub-expressions and then hash the tuple composed of the operator and sub-expression value numbers.
     • If the lookup fails, assign a new value number.

3. This scheme will work fairly well for straight line code containing nothing but references to simple, local variables. In the real world, unfortunately, there are a few more complications to deal with.

   • First, consider references to array elements that look like:

     x = a[i] + z
     a[k] = k;
     z = a[i] + z
                              

     Even though the value of k is likely to be different from the value of i, our value numbering scheme doesn't provide a way to know this for sure. It only tells us when two variables definitely have the same value, not when they definitely are different. So, we would have to be careful and assume that the second copy of "a[i] + z" might produce a different value from the first copy.
   • We can handle cases like this if we simply change the value number associate with "a" after any assignment that changes an element of "a". That is, we won't really make any effort to keep individual value numbers for array elements. The array variable itself will have a value number. We will treat array subscripting as a binary operation. We will combine an array's value number with the value number of the index expression and the subscripting operator and look the combination up in our hash table to determine what value number to associate with the combination.

     This value number associated with an array should clearly be changed when we process an assignment such as

     a = new int[ size ];
     

     or

     a = b;
     

     but to play it safe, we will also change it when we encounter

     a[i] = n;
     

   • The example

     a = b;
     

     points up other horrible issues. Suppose we have to deal with code that looks like:

     a = b;
     x = a[i] + z
     b[k] = k;
     z = a[i] + z
                              

     Because "a" and "b" now refer to the same array, the assignment to b[k] may change a[i]. Once again, we cannot safely treat a[i] + z as a CSE. Somehow, when we process an assignment that changes b, we have to know enough to change the value number associated with a!

     We can either do much more sophisticated analysis to estimate the set of variable that may refer to the same array as a name like "b" and change all the value numbers in this set when we assign to b, or we can just update the value numbers of all array variables that refer to arrays of the same type as b.

4. The handling of array elements is a fine example of the conservative nature of the analysis algorithms one uses when performing optimization. Such algorithms do not give exact information, but they only make "safe" mistakes. In this case, the algorithm will often fail to identify pairs of expressions that actually are CSE's. The result will be that the code generated will be less efficient (but correct!). On the other hand, the alternative of sometimes accidentally concluding that two expressions are CSE's when they are not is unacceptable. It would result in the generation of incorrect (though efficient) code.

5. BUT WAIT! It get's worse. We still need to account for control structures and method invocations.

6. Let's put off control structures for a few more moments.

7. Finally, if we encounter an invocation, we must:
   • change any value numbers assigned to instance variable in all the classes enclosing the method whose body we are processing.
   • change any value numbers associated with array variables (unless we can determine that the arrays associated with local variable names were allocated locally rather than obtained as parameters or through instance variables, and not assigned to any instance variable name.

Value Numbering (cont.)