从内联函数调用内联函数？

Question

这听起来似乎是一个简单的问题，无法在某个地方得到回答，但是我试图四处张望，却找不到任何简单的答案。 请看以下示例：

class vec
{
   double x;
   double y;
};

inline void sum_x(vec & result, vec & a, vec & b)
{
   result.x = a.x + b.x;
}

inline void sum(vec & result, vec & a, vec & b)
{
   sum_x(result, a, b);
   result.y = a.y + b.y;
}

当我调用sum和compile时会发生什么？ 是否将sum和sum_x都内联，以便将其转换为内联汇编代码以对两个组件求和？

这看起来像一个简单的示例，但是我正在使用一个向量类，该向量类具有在模板中定义的维度，因此遍历向量上的操作看起来有点像这样。

Answer 1

inline只是对编译器的提示。 编译器实际上是否内联函数是另一个问题。 对于gcc，有一个Always inline属性可以强制执行此操作。

 __attribute__((always_inline));

通过始终内联，您应该实现所描述的内容（代码生成就像在一个函数中编写的一样）。

但是，通过编译器应用的所有优化和转换，您只能确定是否检查了生成的代码（程序集）

Answer 2

是的，可以递归应用内联。

您在此处执行的整套操作都可以在呼叫站点内联。

请注意，这与您使用inline关键字几乎没有关系，该关键字（除了对ODR的影响（可能非常明显）只是提示），如今实际上出于实际内联的目的而被忽略。 将内联函数，因为您的聪明编译器可以看到它们是理想的候选者。

真正知道它是否正在执行此操作的唯一方法是亲自检查生成的程序集。

Answer 3

这取决于。 inline只是向编译器的提示，它可能想考虑内联该函数。 编译器完全可以内联这两个调用，但这取决于实现。

举例来说，这是一些带有和不带有此简单程序的inline的GCC汇编输出：

int main()                                                                      
{           
  vec a;
  vec b;
  std::cin >> a.x;
  std::cin >> a.y;

  sum(b,a,a);
  std::cout << b.x << b.y;
    return 0;
}

带内联：

main:
    subq    $40, %rsp
    leaq    16(%rsp), %rsi
    movl    std::cin, %edi
    call    std::basic_istream<char, std::char_traits<char> >& std::basic_istream<char, std::char_traits<char> >::_M_extract<double>(double&)
    leaq    24(%rsp), %rsi
    movl    std::cin, %edi
    call    std::basic_istream<char, std::char_traits<char> >& std::basic_istream<char, std::char_traits<char> >::_M_extract<double>(double&)
    movsd   24(%rsp), %xmm0
    movapd  %xmm0, %xmm1
    addsd   %xmm0, %xmm1
    movsd   %xmm1, 8(%rsp)
    movsd   16(%rsp), %xmm0
    addsd   %xmm0, %xmm0
    movl    std::cout, %edi
    call    std::basic_ostream<char, std::char_traits<char> >& std::basic_ostream<char, std::char_traits<char> >::_M_insert<double>(double)
    movsd   8(%rsp), %xmm0
    movq    %rax, %rdi
    call    std::basic_ostream<char, std::char_traits<char> >& std::basic_ostream<char, std::char_traits<char> >::_M_insert<double>(double)
    movl    $0, %eax
    addq    $40, %rsp
    ret
    subq    $8, %rsp
    movl    std::__ioinit, %edi
    call    std::ios_base::Init::Init()
    movl    $__dso_handle, %edx
    movl    std::__ioinit, %esi
    movl    std::ios_base::Init::~Init(), %edi
    call    __cxa_atexit
    addq    $8, %rsp
    ret

没有：

sum_x(vec&, vec&, vec&):
    movsd   (%rsi), %xmm0
    addsd   (%rdx), %xmm0
    movsd   %xmm0, (%rdi)
    ret
sum(vec&, vec&, vec&):
    movsd   (%rsi), %xmm0
    addsd   (%rdx), %xmm0
    movsd   %xmm0, (%rdi)
    movsd   8(%rsi), %xmm0
    addsd   8(%rdx), %xmm0
    movsd   %xmm0, 8(%rdi)
    ret
main:
    pushq   %rbx
    subq    $48, %rsp
    leaq    32(%rsp), %rsi
    movl    std::cin, %edi
    call    std::basic_istream<char, std::char_traits<char> >& std::basic_istream<char, std::char_traits<char> >::_M_extract<double>(double&)
    leaq    40(%rsp), %rsi
    movl    std::cin, %edi
    call    std::basic_istream<char, std::char_traits<char> >& std::basic_istream<char, std::char_traits<char> >::_M_extract<double>(double&)
    leaq    32(%rsp), %rdx
    movq    %rdx, %rsi
    leaq    16(%rsp), %rdi
    call    sum(vec&, vec&, vec&)
    movq    24(%rsp), %rbx
    movsd   16(%rsp), %xmm0
    movl    std::cout, %edi
    call    std::basic_ostream<char, std::char_traits<char> >& std::basic_ostream<char, std::char_traits<char> >::_M_insert<double>(double)
    movq    %rbx, 8(%rsp)
    movsd   8(%rsp), %xmm0
    movq    %rax, %rdi
    call    std::basic_ostream<char, std::char_traits<char> >& std::basic_ostream<char, std::char_traits<char> >::_M_insert<double>(double)
    movl    $0, %eax
    addq    $48, %rsp
    popq    %rbx
    ret
    subq    $8, %rsp
    movl    std::__ioinit, %edi
    call    std::ios_base::Init::Init()
    movl    $__dso_handle, %edx
    movl    std::__ioinit, %esi
    movl    std::ios_base::Init::~Init(), %edi
    call    __cxa_atexit
    addq    $8, %rsp
    ret

如您所见，当被要求时，GCC内联了这两个函数。

如果您的程序集有些生锈，只需注意在第二个版本中存在并调用sum ，而在第一个版本中不存在。

Answer 4

如前所述， inline关键字只是一个提示。 但是，编译器在这里做得非常出色（即使没有您的提示），并且它们以递归方式内联。

如果您真的对此东西感兴趣，我建议您学习一些有关编译器设计的知识。 我最近一直在研究它，这让我大吃一惊，今天我们的生产质量的编译器是多么复杂。

关于内联，这是编译器往往会做得非常出色的事情之一。 这样做是有必要的，因为如果您看看我们如何用C ++编写代码，我们经常会编写访问器函数（方法），而无非是返回单个变量的值。 C ++的普及很大程度上取决于我们可以利用诸如信息隐藏之类的概念编写这种代码的想法，而不必强迫自己创建比其类似C的同类软件要慢的软件，因此您常常可以在90年代就发现优化器内联（和递归）非常出色。

对于下一部分，这有点投机，因为我假设我已经阅读和研究的有关编译器设计的内容适用于我们今天使用的生产质量的编译器。 谁能确切知道他们都在应用哪种高级技巧？

...但是我相信编译器通常会在您达到某种机器代码级别之前先内联代码。 这是因为优化器的关键之一是有效的指令选择和寄存器分配。 为此，它需要知道代码将在过程中使用的所有内存（变量）。 它希望以某种有点抽象的形式，即尚未选择特定寄存器但已准备好分配它们。 因此，内联通常在此中间表示阶段完成，然后再进入特定机器指令和寄存器的汇编领域，以便编译器可以在进行神奇的优化之前收集所有这些信息。 它甚至可以在这里应用一些启发式方法，以便在实际执行之前尝试“内联”或内联代码分支。

许多链接器甚至可以内联代码，但我不确定它是如何工作的。 我认为，当他们能够做到这一点时，目标代码实际上仍然处于中间表示形式，并且仍然从特定的机器级指令和寄存器中抽象出来。 然后，链接器仍可以在目标文件之间移动该代码并将其内联，从而将代码生成/优化过程推迟到之后。