如果我针对大小而不是速度进行优化，为什么 GCC 生成的代码速度会快 15-20%?

It looks like to me the distance of add() from the call site matters a lot. I have tried perf, but the output of perf stat and perf report makes very little sense to me. However, I could only get one consistent result out of it:

-O2:

 602,312,864 stalled-cycles-frontend   #    0.00% frontend cycles idle
       3,318 cache-misses
 0.432703993 seconds time elapsed
 [...]
 81.23%  a.out  a.out              [.] work(int, int)
 18.50%  a.out  a.out              [.] add(int const&, int const&) [clone .isra.0]
 [...]
       |   __attribute__((noinline))
       |   static int add(const int& x, const int& y) {
       |       return x + y;
100.00 |     lea    (%rdi,%rsi,1),%eax
       |   }
       |   ? retq
[...]
       |            int z = add(x, y);
  1.93 |    ? callq  add(int const&, int const&) [clone .isra.0]
       |            sum += z;
 79.79 |      add    %eax,%ebx

对于fno-align-*:

 604,072,552 stalled-cycles-frontend   #    0.00% frontend cycles idle
       9,508 cache-misses
 0.375681928 seconds time elapsed
 [...]
 82.58%  a.out  a.out              [.] work(int, int)
 16.83%  a.out  a.out              [.] add(int const&, int const&) [clone .isra.0]
 [...]
       |   __attribute__((noinline))
       |   static int add(const int& x, const int& y) {
       |       return x + y;
 51.59 |     lea    (%rdi,%rsi,1),%eax
       |   }
[...]
       |    __attribute__((noinline))
       |    static int work(int xval, int yval) {
       |        int sum(0);
       |        for (int i=0; i<LOOP_BOUND; ++i) {
       |            int x(xval+sum);
  8.20 |      lea    0x0(%r13,%rbx,1),%edi
       |            int y(yval+sum);
       |            int z = add(x, y);
 35.34 |    ? callq  add(int const&, int const&) [clone .isra.0]
       |            sum += z;
 39.48 |      add    %eax,%ebx
       |    }

对于-fno-omit-frame-pointer:

 404,625,639 stalled-cycles-frontend   #    0.00% frontend cycles idle
      10,514 cache-misses
 0.375445137 seconds time elapsed
 [...]
 75.35%  a.out  a.out              [.] add(int const&, int const&) [clone .isra.0]                                                                                     |
 24.46%  a.out  a.out              [.] work(int, int)
 [...]
       |   __attribute__((noinline))
       |   static int add(const int& x, const int& y) {
 18.67 |     push   %rbp
       |       return x + y;
 18.49 |     lea    (%rdi,%rsi,1),%eax
       |   const int LOOP_BOUND = 200000000;
       |
       |   __attribute__((noinline))
       |   static int add(const int& x, const int& y) {
       |     mov    %rsp,%rbp
       |       return x + y;
       |   }
 12.71 |     pop    %rbp
       |   ? retq
 [...]
       |            int z = add(x, y);
       |    ? callq  add(int const&, int const&) [clone .isra.0]
       |            sum += z;
 29.83 |      add    %eax,%ebx

在缓慢的情况下，我们似乎在对 add() 的调用上拖延.

00000000004004fd <_ZL3addRKiS0_.isra.0>:
  4004fd:       8d 04 37                lea    eax,[rdi+rsi*1]
  400500:       c3   

00000000004004fa <_ZL3addRKiS0_.isra.0>:
  4004fa:       8d 04 37                lea    eax,[rdi+rsi*1]
  4004fd:       c3                      ret

[...]

  40051a:       e8 db ff ff ff          call   4004fa <_ZL3addRKiS0_.isra.0>

  4004f2:       e8 db ff ff ff          call   4004d2 <_ZL3addRKiS0_.isra.0>
  4004f7:       01 c3                   add    ebx,eax
  4004f9:       ff cd                   dec    ebp
  4004fb:       75 ec                   jne    4004e9 <_ZL4workii+0x13>

// add.cpp
int add(const int& x, const int& y) {
    return x + y;
}

// main.cpp
int add(const int& x, const int& y);

const int LOOP_BOUND = 200000000;

__attribute__((noinline))
static int work(int xval, int yval) {
    int sum(0);
    for (int i=0; i<LOOP_BOUND; ++i) {
        int x(xval+sum);
        int y(yval+sum);
        int z = add(x, y);
        sum += z;
    }
    return sum;
}

int main(int , char* argv[]) {
    int result = work(*argv[1], *argv[2]);
    return result;
}