优化编译器的局限性

考察以下代码:

void Twiddle1(int *xp, int *yp)
{
    *xp += *yp;
    *xp += *yp;
}

void Twiddle2(int *xp, *yp)
{
    *xp += 2 * *yp;
}

这两个过程等价吗? 事实上 Twiddle2 的效率更高, 因为它只要求 3 次存储器引用, 而 Twiddle1 需要 6 次, 但它们不能相互代替, 因为当 xp == yp 时,

*xp += *xp;
*xp += *xp;

之后, xp 的值是原来的 4 倍, 但是类似 Twiddle2 的操作:

*xp += 2 * *xp;

的结果却是原来的 3 倍. 所以编译器不会产生 Twiddle2 的代码作为 Twiddle1 的优化代码.
考察以下代码:

x = 1000; y = 3000;
*q = y;
*p = x;
t1 = *q    // ?

t1 的值依赖于指针 p 和 q 的位置关系, 如果 p == q, 那么 t1 == 1000; 如果不相等, t1 == 3000. 这就是一种妨碍优化的因素, 它严重限制了编译器产生优化代码的机会和优化策略.
两个指针可能指向同一个储存器的位置的情况称为储存器别名使用(memory aliasing). 在直至项安全优化的代码中, 编译器需要假设储存器别名使用的情况.
第二个妨碍优化的因素是函数调用, 考察以下代码:

int F();

int Func1()
{
    return F() + F() + F() + F();
}

int Func2()
{
    return 4 *  F();
}

看上去似乎是相同的结果, 但是 Func2() 只调用 F() 1 次, 而 Func1() 调用 4 次, 考虑以下代码:

int counter = 0;
int F()
{
    return counter++;
}

对于 Func1() 我们可以用内联函数进行优化即将函数调用替换为函数体:

//优化后的版本
int Funct1Inline()
{
    int t = counter++;    // +0
    t = counter++;        // +1
    t = counter++;        // +2
    t = counter++;        // +3
    return t;
}

这样的转换不仅可以减少了函数调用的开销, 也允许编译器对代码进行进一步优化:

//编译器进一步优化
int Func1Opt()
{
    int t = 4 * counter + 6;
    counter = t + 4;
    return t;
}