В чем смысл файловой статики вне строки, глобальной вне строки и отсутствия вне строки копии функции при вставке

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

«Нормальная» реализация функции создает ее как подпрограмму на языке ассемблера или в машинном коде, сгенерированном компилятором: это последовательность инструкций, которая вызывается другими подпрограммами и возвращается после ее завершения.

Поскольку вызов функции и ее возврат могут иметь некоторые издержки, компилятор может вместо этого сгенерировать встроенную реализацию функции.Например, с этим кодом:

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

компилятор может выбрать компиляцию foo, как если бы это было:

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

Таким образом, компилятор встраивает содержимое функции внутрьрутина, которая назвала это.Это называется встроенной реализацией.

В цитируемых вами комментариях используется out-of-line для ссылки на нормальную реализацию функции в качестве фактической подпрограммы.Это не часто используемая фраза, но и она не является необычной.