2

我有下面列出的代码：

for(auto i =0;i<k;++i)                                                         
    printf("%d\n",(va1+va2-(va1-va2))[i]);

其中va1和va2是两个valarray<int>对象，k是 和 的va1大小va2。我期待的是编译器优化如下printf行：

printf("%d\n", 2*va2[i]);

但相反，英特尔编译器 (13.1) 和 CLang (3.4) 都没有进行此类优化。例如，英特尔编译器输出汇编代码：

..B1.18:                        # Preds ..B1.19 ..B1.17                            
        movl      (%r14,%r15,4), %r9d                           #18.42             
        movl      $.L_2__STRING.1, %edi                         #18.9              
        movl      (%r12,%r15,4), %r8d                           #18.42             
        xorl      %eax, %eax                                    #18.9              
        lea       (%r9,%r8), %esi                               #18.9              
        subl      %r8d, %r9d                                    #18.9              
        subl      %r9d, %esi                                    #18.9              
..___tag_value_main.18:                                         #18.9              
        call      printf                                        #18.9              
..___tag_value_main.19:                                         #                  
                                # LOE rbx r12 r13 r14 r15                          
..B1.19:                        # Preds ..B1.18                                    
        incq      %r15                                          #17.25             
        cmpq      %r13, %r15                                    #17.21             
        jl        ..B1.18       # Prob 82%                      #17.21

其中r13存储 的值k，r14和分别是和r12的内存的开始。是迭代器变量。从代码来看，它的作用是：va1va2r15i

load va1[i]
load va2[i]
add va1[i], va2[i] ==> %esi
sub va1[i], va2[i] ==> %r9d
sub %esi, %r9d ==> esi
print %esi

为什么它没有优化（即使使用 -O3）

load va2[i]
add va2[i], va2[i] => %esi
print %esi

通过窥视孔优化？Gcc 4.8.2 在这种情况下进行了优化，但无法处理-(va1[i]+va2[i])+(va1[i]-va2[i]).

看起来一个可能的原因是在前面显示的代码中使用了表达式模板。现在的问题是，为什么编译器在完美之前就停止了优化？表达式模板如何阻止向前迈出一步？

注意 嗯，答案总是“因为编译器不是为进行优化而设计的”。但是据我从龙书上了解到，编译器应该迭代地进行优化，直到它不能做任何更好的事情。

4

0 回答 0