内联中的file-static out-of-line、global out-of-line和no out-of-line copy of function是什么意思

Question

我正在阅读 OS/161 的源代码并遇到内联支持代码。我无法理解所提供的评论。评论是：-

/*                                                                                                                                                                                                          
 * Material for supporting inline functions.                                                                                                                                                                
 *                                                                                                                                                                                                          
 * A function marked inline can be handled by the compiler in three                                                                                                                                         
 * ways: in addition to possibly inlining into the code for other                                                                                                                                           
 * functions, the compiler can (1) generate a file-static out-of-line                                                                                                                                       
 * copy of the function, (2) generate a global out-of-line copy of the                                                                                                                                      
 * function, or (3) generate no out-of-line copy of the function.                                                                                                                                           
 *                                                                                                                                                                                                          
 * None of these alone is thoroughly satisfactory. Since an inline                                                                                                                                          
 * function may or may not be inlined at the compiler's discretion, if                                                                                                                                      
 * no out-of-line copy exists the build may fail at link time with                                                                                                                                          
 * undefined symbols. Meanwhile, if the compiler is told to generate a                                                                                                                                      
 * global out-of-line copy, it will generate one such copy for every                                                                                                                                        
 * source file where the inline definition is visible; since inline                                                                                                                                         
 * functions tend to appear in header files, this leads to multiply                                                                                                                                         
 * defined symbols and build failure. The file-static option isn't                                                                                                                                          
 * really an improvement, either: one tends to get compiler warnings                                                                                                                                        
 * about inline functions that haven't been used, which for any                                                                                                                                             
 * particular source file tends to be at least some of the ones that                                                                                                                                        
 * have been defined. Furthermore, this method leads to one                                                                                                                                                 
 * out-of-line copy of the inline function per source file that uses                                                                                                                                        
 * it, which not only wastes space but makes debugging painful.                                                                                                                                             
 */                                                                                                                                                                                                          

谁能解释一下文件静态外联、全局外联和无外联函数副本是什么意思

Answer 1

函数的“正常”实现将其创建为编译器生成的汇编语言或机器代码中的子例程：它是由其他例程调用的指令序列，它 returns什么时候完成。

由于调用函数并从中返回可能会产生一些开销，因此编译器可能会生成函数的 内联 实现。例如，使用此代码：

int square(int x) { return x*x; }
...
void foo(...)
{
    ...
    y = square(x);
}

编译器可以选择将 foo 编译为：

void foo(...)
{
    ...
    y = x*x;
}

因此，编译器将函数的内容嵌入到调用它的例程中。这称为内联实现。

您引用的注释使用行外 将函数的正常实现称为实际子例程。这不是常用的措辞，但也不罕见。