Re: non trivial constant folding

> +(+(1.000000,var),1.000000)


Even if it is quite far from the direct question, it might help to
know how Mathematica handles this. Each operator has attributes
including "Flat" (associative) and "Unordered" (commutative).
Mathematica uses lists internally and automatically converts for
"Flat" operators


    Dot(Dot(a,b),c) ---> Dot(a,b,c)


(Dot is matrix multiplication). For "Unordered" operators it also sorts
items in a canonical order; for example:


    Plus(1,a,1) ---> Plus(1,1,a)


Then it does not do constant folding, but having the expression in this
state makes it simple.


What I'd call "non trivial folding" (not really constant folding, but
generically parse tree folding), instead, is converting for example


        !((a < b) && (b < c)) to
        !(a < b) || !(b < c) to
        a >= b || b >= c


or


        (a >= 5) && (a < 10) to
        (unsigned) (a - 5) < 5


or finally


        a * 16 to
        a << 4


I know that GCC does some of these. The source file is fold.c if
memory serves me correctly, but it is dauntingly long for taking a
quick look at it (in the order of 5k lines).


Paolo

Return to the comp.compilers page.
Search the comp.compilers archives again.