我写了一个非常简单的C ++程序来理解“内联”是如何工作的：
inline int square(int x) {
return x*x;
}
int main() {
int y = square(1234);
return y;
}
我将它编译为汇编代码，没有和“内联”。奇怪的是，在这两种情况下都生成了一个函数，但它是不同的。没有内联代码看起来像这样（删除大多数注释）：
_Z6squarei: # @_Z6squarei
pushq %rbp
movq %rsp, %rbp
movl %edi, -4(%rbp)
movl -4(%rbp), %edi
imull -4(%rbp), %edi
movl %edi, %eax
popq %rbp
retq
.Lfunc_end0:
main: # @main
pushq %rbp
movq %rsp, %rbp
subq $16, %rsp
movl $1234, %edi # imm = 0x4D2
movl $0, -4(%rbp)
callq _Z6squarei
movl %eax, -8(%rbp)
movl -8(%rbp), %eax
addq $16, %rsp
popq %rbp
retq
.Lfunc_end1:
使用内联，它看起来像这样：
main: # @main
.cfi_startproc
pushq %rbp
.Lcfi0:
.cfi_def_cfa_offset 16
.Lcfi1:
.cfi_offset %rbp, -16
movq %rsp, %rbp
.Lcfi2:
.cfi_def_cfa_register %rbp
subq $16, %rsp
movl $1234, %edi # imm = 0x4D2
movl $0, -4(%rbp)
callq _Z6squarei
movl %eax, -8(%rbp)
movl -8(%rbp), %eax
addq $16, %rsp
popq %rbp
retq
.Lfunc_end0:
_Z6squarei: # @_Z6squarei
pushq %rbp
movq %rsp, %rbp
movl %edi, -4(%rbp)
movl -4(%rbp), %edi
imull -4(%rbp), %edi
movl %edi, %eax
popq %rbp
retq
.Lfunc_end1:
除了新的“cfi”指令外，它非常相似。为什么他们只有在我使用“内联”时才会出现？
还有第二个问题：有没有办法告诉编译器真正使这个函数内联？ （我使用的是clang ++ - 5.0）。
答案 0 :(得分：2)
unsigned int fun0 ( unsigned int );
static unsigned int fun1 ( unsigned int x )
{
return(x+1);
}
unsigned int fun2 ( unsigned int x )
{
return(x+2);
}
inline unsigned int fun3 ( unsigned int x )
{
return(x+3);
}
unsigned int hello ( unsigned int x )
{
unsigned int y;
y=fun0(x);
y=fun1(y);
y=fun2(y);
y=fun3(y);
return(y);
}
故意使用不同的指令集：
Disassembly of section .text:
00000000 <fun2>:
0: e2800002 add r0, r0, #2
4: e12fff1e bx lr
00000008 <hello>:
8: e92d4010 push {r4, lr}
c: ebfffffe bl 0 <fun0>
10: e8bd4010 pop {r4, lr}
14: e2800006 add r0, r0, #6
18: e12fff1e
fun0（）是外部的，编译器没有可见性，它必须设置一个调用并获取返回值。
fun1（）被标记为静态，因此我们已经指出我们希望该函数对于此对象/文件/范围是本地的，因此编译器没有理由在那里创建一个函数供其他人远程访问，并且优化器可以看到它在同一个文件中的功能，因此选择内联它。
fun2（）没有特殊标记它被假定为全局因此编译器需要提供执行该函数的代码供其他人使用，但同时优化器看到该函数，它在同一个文件中，所以将其优化为内联和fun1。
fun3（）我们指出编译器可以内联这个，有点暗示它是在这个范围内消费，所以像静态编译器没有为全局消费生成代码，并且优化（内联）
函数hello将x发送到fun0（），将其转换为y。然后我们加1 + 2 + 3 = 6。因此，为了内联fun1，fun2，fun3，你只需在fun0（）的输出中加上6即可。这就是我们所看到的fun1（）fun2（）和fun3（）的内联。
这里的混淆可能是内联意味着它意味着排队。不要调用功能包括与调用者一致的功能。
unsigned int fun2 ( unsigned int x )
{
return(x+2);
}
unsigned int hello ( unsigned int x )
{
return(fun2(x));
}
使用我正在使用的工具我实际上并不需要让它内联
00000000 <fun2>:
0: e2800002 add r0, r0, #2
4: e12fff1e bx lr
00000008 <hello>:
8: e2800002 add r0, r0, #2
c: e12fff1e bx lr
优化器无论如何都做了，而不是设置对fun2的调用，它取得了fun2的功能，即将2加到操作数上，它只是在你好的IN LINE中做到了。
使用您的工具注意，全局函数是以任何一种方式创建的，但是当您要求它内联时，它看起来并没有实际执行任何操作，请检查反汇编以及装配，反汇编通常更容易阅读，更少混淆。
注意，使用我的第一个示例和C ++编译器，所以我没有得到一个＆＃34;嘿，你没有使用C ++编译器＆＃34;：
0000000000000000 <_Z4fun2j>:
0: 8d 47 02 lea 0x2(%rdi),%eax
3: c3 retq
4: 66 90 xchg %ax,%ax
6: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
d: 00 00 00
0000000000000010 <_Z5helloj>:
10: 48 83 ec 08 sub $0x8,%rsp
14: e8 00 00 00 00 callq 19 <_Z5helloj+0x9>
19: 48 83 c4 08 add $0x8,%rsp
1d: 83 c0 06 add $0x6,%eax
20: c3 retq
同样的故事，内联和静态并没有产生其他人使用的全局功能。并且编译器生成了对外部函数的调用，然后为其添加了6。
注意没有优化：
00000000 <fun1>:
0: e52db004 push {r11} ; (str r11, [sp, #-4]!)
4: e28db000 add r11, sp, #0
8: e24dd00c sub sp, sp, #12
c: e50b0008 str r0, [r11, #-8]
10: e51b3008 ldr r3, [r11, #-8]
14: e2833001 add r3, r3, #1
18: e1a00003 mov r0, r3
1c: e28bd000 add sp, r11, #0
20: e49db004 pop {r11} ; (ldr r11, [sp], #4)
24: e12fff1e bx lr
00000028 <fun2>:
28: e52db004 push {r11} ; (str r11, [sp, #-4]!)
2c: e28db000 add r11, sp, #0
30: e24dd00c sub sp, sp, #12
34: e50b0008 str r0, [r11, #-8]
38: e51b3008 ldr r3, [r11, #-8]
3c: e2833002 add r3, r3, #2
40: e1a00003 mov r0, r3
44: e28bd000 add sp, r11, #0
48: e49db004 pop {r11} ; (ldr r11, [sp], #4)
4c: e12fff1e bx lr
00000050 <hello>:
50: e92d4800 push {r11, lr}
54: e28db004 add r11, sp, #4
58: e24dd010 sub sp, sp, #16
5c: e50b0010 str r0, [r11, #-16]
60: e51b0010 ldr r0, [r11, #-16]
64: ebfffffe bl 0 <fun0>
68: e50b0008 str r0, [r11, #-8]
6c: e51b0008 ldr r0, [r11, #-8]
70: ebffffe2 bl 0 <fun1>
74: e50b0008 str r0, [r11, #-8]
78: e51b0008 ldr r0, [r11, #-8]
7c: ebfffffe bl 28 <fun2>
80: e50b0008 str r0, [r11, #-8]
84: e51b0008 ldr r0, [r11, #-8]
88: ebfffffe bl 0 <fun3>
8c: e50b0008 str r0, [r11, #-8]
90: e51b3008 ldr r3, [r11, #-8]
94: e1a00003 mov r0, r3
98: e24bd004 sub sp, r11, #4
9c: e8bd4800 pop {r11, lr}
a0: e12fff1e bx lr
称他们都没有内联......你在测试中使用了什么优化？如果您尝试优化怎么办？ （llvm / clang为你提供了超过gnu的多个优化机会）
使用llvm和优化编辑。
两个单独的文件
unsigned int fun0 ( unsigned int x )
{
return(x+7);
}
和这一个
unsigned int fun0 ( unsigned int );
inline unsigned int fun3 ( unsigned int x )
{
return(x+3);
}
unsigned int hello ( unsigned int x )
{
unsigned int y;
y=fun0(x);
y=fun3(y);
return(y);
}
没有优化的构建
0000000000000000： 0:55推％rbp 1：48 89 e5 mov％rsp，％rbp 4：89 7d fc mov％edi，-0x4（％rbp） 7：8d 47 07 lea 0x7（％rdi），％eax a：5d pop％rbp b：c3 retq
和
0000000000000000 <hello>:
0: 55 push %rbp
1: 48 89 e5 mov %rsp,%rbp
4: 48 83 ec 10 sub $0x10,%rsp
8: 89 7d fc mov %edi,-0x4(%rbp)
b: e8 00 00 00 00 callq 10 <hello+0x10>
10: 89 45 f8 mov %eax,-0x8(%rbp)
13: 89 c7 mov %eax,%edi
15: e8 00 00 00 00 callq 1a <hello+0x1a>
1a: 89 45 f8 mov %eax,-0x8(%rbp)
1d: 48 83 c4 10 add $0x10,%rsp
21: 5d pop %rbp
22: c3 retq
后编译希望fun0被内联，哦，它确实优化了你好
0000000000000000 <fun0>:
0: 55 push %rbp
1: 48 89 e5 mov %rsp,%rbp
4: 8d 47 07 lea 0x7(%rdi),%eax
7: 5d pop %rbp
8: c3 retq
9: 0f 1f 80 00 00 00 00 nopl 0x0(%rax)
0000000000000010 <hello>:
10: 55 push %rbp
11: 48 89 e5 mov %rsp,%rbp
14: 83 c7 07 add $0x7,%edi
17: e8 00 00 00 00 callq 1c <hello+0xc>
1c: 5d pop %rbp
1d: c3 retq
使用优化编译。
0000000000000000 <fun0>:
0: 8d 47 07 lea 0x7(%rdi),%eax
3: c3 retq
0000000000000000 <hello>:
0: 50 push %rax
1: e8 00 00 00 00 callq 6 <hello+0x6>
6: 83 c0 03 add $0x3,%eax
9: 59 pop %rcx
a: c3 retq
clang为您提供了不同的优化机会。
好了，得到它，随着你的文件数量的增加，llvm工具的优化组合几乎呈指数增长，对于更大的项目我发现如果你编译未经优化它会让后来的优化器更有用处，但当然这取决于在许多因素上，不幸的是这些组合变得惊人。如果我首先使用优化进行编译，然后再进行组合和优化，我会得到我想要的结果。
0000000000000000 <fun0>:
0: 8d 47 07 lea 0x7(%rdi),%eax
3: c3 retq
0000000000000010 <hello>:
10: 8d 47 0a lea 0xa(%rdi),%eax
13: c3 retq
fun3添加了3个fun0添加了7个，对fun0的调用是内联的，我最终从两个文件一个外部函数一个内部内联，只需添加10个。
我在这里使用C但是llvm / clang就像gnu那样只是一个前端，如上所示，gnu中间发生的事情应该与C和C ++无关（就优化做自动或建议内联而言）。