2. Optimized code is harder to debug

更难以推测的原因是,变换者没有按行走方案线。 这只是一种幻想。 这里的例子可能是一个问题:

int main(void) {
    char str[] = "Hello, World!";
    
    int number_of_capital_letters = 0;

    for(int i=0; i<strlen(str); i++) {
        if(isupper(str[i]))
            number_of_capital_letters++;
    }

    printf("%s
", str);

    // Outcommented for debugging reasons
    // printf("%d
", number_of_capital_letters);
}

您向你们的夸大了,并想知道它为什么不跟踪<代码>_of_capital_letters。 并且,你发现,由于你对最后的<条码>print/条码>说明发表了评论,因此该变量没有用于任何可观察到的行为,因此,最优化的改动了你的代码:

int main(void) {
    puts("Hello, World!");
}

3. Sometimes bugs only show up at higher optimization levels.

Imagine that you have a big code base. When you upgrade the compiler, a bug suddenly emerges. And it seems to vanish when you remove optimization. What s the problem here? Well, it could be a bug in the optimizer. But it could also be a bug in your code that manifested itself with the new version of the optimizer. Very often, code with undefined behavior behaves different in code compiled with optimization.

So what do you do? You could try to figure out if the bug is in the optimizer or your code. That can be a VERY time consuming task. Let s assume it s a bug in the optimizer. What to do? You could downgrade your compiler, which is not optimal for several reasons. Especially if it s an open source project. Imagine downloading the source and then run the build script and scratching your head for hours to figure out what s wrong, and then you see in some documentation (provided that the author documented it) that you need a specific version of a specific compiler.

相反,让我们把它推向你们的法典。 当然,要确定这一点是理想的。 但也许你们没有资源这样做。 此时此刻,你还可以要求任何汇编者使用某种版本的具体汇编者。

但是,如果你能够用<条码>-O3替换成<条码>-O2,你可以清楚地看到,它有时在我们的非理想世界中是一种可行的选择,而时间不是无限的资源。 有了一条坏uck的灯光,这种ug子可以花一个星期才能追踪。 或更多。 那天,你可以花在其他地方。

这里就是一个例子:

#include <stdio.h>

int main(void) {
    char str[] = "Hello";
    str[5] =  ! ;
    puts(str);
}

当我用10.2克谢来汇编这一数据时,我根据优化程度得出不同的结果。

Without optimization:

Hello!

优化:

Hello!`@

Try it out yourself:

4. Sometimes bugs only show up at LOWER optimization levels.

情况也可能发生。 在这种情况下,如果你不关心正确性,你就能够提高最佳程度。 但是,如果你谨慎,这可以成为找到ug的办法。 如果你的法典正确操作并且没有优化,那么它就更可能含有今后会困扰你的ug子,而如果你只是以优化的方式汇编成文的话。

我没有发现一个行之有效的例子,但理论上可能这样做。

int main(void) {
    if(1/0) // Division by zero
        puts("An error has occurred");
    else
        puts("Everything is fine");
}

如果这种汇编没有优化,就会发生故障。 但是,最优化者可能认为,没有界定的行为(如零的分裂)永远不会发生,因此它优化了守则,使之公正:

int main(void) {
    puts("Everything is fine");
}

假设<代码>1/0是某种错误核对,很难加以评价,因此,通常会假设节目印刷“每打一次罚款”。 在这里,最优化者隐藏着一杯。

5. The optimizer might produce a binary that s bigger in size, or is using more memory. Or something else that s not desirable.

有时情况如此。 特别是在嵌入式系统中。 通常(途径)<代码>-O0产生非常大的代码,但你可能希望使用<代码>-Os(大小而不是速度的鼓励)而不是<代码>-O3,以获得一个小型双亲。 有时还能加快制定法典。 见下文。

6. The optimizer might produce slower code