Constant Folding and Algebraic Transformations

• As discussed above, performing computations involving constants can improve code quality.

• One could easily change your code generators to check to see if all the operands to an operator node were constants and in that case perform the operation at compile time.

• This simple change, however, would miss opportunities for constant folding like:

  (3+x)-1 = 2+x
  	

  and

  4*(2*x - 1) = 8*x - 4
  

  To find examples like this, one has to be willing to perform transformations using rules of arithmetic like commutativity and associativity while looking for constant sub-expressions.

• Note: these transformations may have surprising effects on program results:

  • Consider the evaluation of:

    really-big-constant + variable + pretty-big-constant

    If the sum of the two constants is too big for the arithmetic type being used, combining the constants might result in an arithmetic overflow while, at run-time, the value of "variable" might have been a negative number big enough to avoid the overflow.

  • While these issues exist with integers, they are much more significant with floating point numbers (where the "laws" of arithmetic rarely hold at all!)

  A "real compiler" has to be careful about these issues. We will ignore them (from here on).

  • Even in a real compiler, these issues can usually be ignored in address arithmetic sub-expressions, and this is where we will get the most benefit from these optimizations.

• There are other identities that can be used to reduce computation time when constants are involved:
  • 1*x = x
  • 0+x = x
  • 0*x = 0
  (Not evaluating x, however, may change program behavior if the evaluation of x produced side-effects).

• Constant folding that is willing to perform algebraic transformations can be particularly productive in expressions generated to perform address arithmetic and, in this context, "additive constants" are particularly interesting.
  • A subscripted variable of the form x[i+1] might produce an address arithmetic expression of the form:

    display-pointer + disp(X) + 4*(i+1)

    (assuming the element of the array x occupy 4 units of memory).
  • Since many machines including an address mode that allows one to add a constant displacement to a computed address, rewriting this expression as:

    ( disp(X) + 4) + (4*i + display-pointer)

    makes it possible to use the "disp(x)+4" as such a displacement.

• The tough question is how to organize the process of applying arithmetic identities to find constants and otherwise simplify expressions.