Использованием встраивания (inline) для функции Вы можете дать указание для GCC сделать вызовы функции быстрее. Один из путей, которым GCC может достичь этого - вставить код тела функции в то место, где функция вызывается. Это быстрее обрабатывается процессором, потому что устраняются расходы на вызов функции и возврат из неё. Кроме того, если любой из действительных аргументов функции константа, то их известные значения могут быть учтены на этапе компиляции, в результате чего может быть встроено не все тело функции. В результате получится, что размер кода будет менее предсказуемым; объектный код может увеличиться или уменьшиться с применением встраивания функций, в зависимости от каждого конкретного случая. Вы можете также указать для GCC пытаться интегрировать все "достаточно простые" функции в места их вызова, если используете опцию -finline-functions. Здесь приведены переводы статей [1, 2].

GCC реализует 3 разные семантики декларирования inline-функций. Одна из них доступна с опцией -std=gnu89 или -fgnu89-inline, или когда присутствует атрибут для всех inline-деклараций, другой при использовании опций -std=c99, -std=c11, -std=gnu99 или -std=gnu11 (без -fgnu89-inline), и третья с использованием компилирования в режиме C++.

Чтобы декларировать встроенную функцию, используйте в её декларации ключевое слово inline, примерно так:

static inline intinc (int *a)
{
  return (*a)++;
}

Если Вы пишете заголовочный файл, подключаемый в программах ISO C90, вместо ключевого слова inline используйте __inline__ (подробнее см. врезку "Замена ключевых слов").

#ifndef __GNUC__

#define __asm__ asm

#endif

Эти три типа встраивания ведут себя подобным образом в двух важных случаях: когда ключевое слово inline используется в статической (static) функции, Наподобие в вышеприведенном примере, и когда функция сначала была декларирована без ключевого слова inline, и затем была определена как inline, примерно так:

extern int inc (int *a);

inline int inc (int *a)
{
  return (*a)++;
}

В обоих этих случаях программы ведут себя так же, как если бы Вы не использовали ключевое слово inline, за исключением того, что изменится скорость выполнения.

Когда функция определена и как inline и как static, если все вызовы функции в виде её тела интегрированы в вызывающий код, и адреса функции не используются, то нет ссылок к собственному ассемблерному коду функции. Тогда GCC не делает вывод актуального кода для функции, за исключением случая, когда Вы укажете опцию -fkeep-inline-functions. Если здесь сделан вызов без встраивания, то функция будет скомпилирована в ассемблерный код, как обычно. Эта функция также должна быть скомпилирована как обычная функция, если программа обращается к ней по адресу функции, потому что она тогда не может быть встраиваемой.

Обратите внимание, что некоторые использования определений функции делают невозможным inline-подстановки. Например: variadic-функции (функции с переменным количеством аргументов), использование alloca, используемого вычисляемого goto (см. врезку "Метки как значения"), использование не локального goto, использование вложенных (nested) функций, использование setjmp, использование __builtin_longjmp и использование __builtin_return или __builtin_apply_args. Опция -Winline будет предупреждать о ситуациях, когда функция помечена как inline, но для неё не может быть осуществлено встраивание, и также выдает причину этого.

void *ptr;

/* ... */
ptr = &&foo;

goto *ptr;

static void *array[] = { &&foo, &&bar, &&hack };

goto *array[i];

static const int array[] = { &&foo - &&foo, &&bar - &&foo,

                             &&hack - &&foo };

goto *(&&foo + array[i]);

Как требуется стандартом ISO C++, GCC считает функции - члены класса (т. е. функции, определенные в теле класса) помеченными как inline, даже если они не декларированы явно с ключевым словом inline. Вы можете отменить это поведение использованием опции -fno-default-inline (подробнее см. описание опций, управляющих диалектом C++ [3]).

GCC не делает встраивание любых функций, когда не делается оптимизация, за исключением если Вы укажете атрибут always_inline для функции, примерно так:

/* Прототип. */

inline void foo (const char) __attribute__((always_inline));

Остальная часть этой секции относится к встраиванию GNU C90.

Когда inline-функция не является статической (без атрибута static), тогда компилятор должен подразумевать, что здесь могут иметь место вызовы из других исходных файлов; поскольку глобальный символ может быть определен только в одном месте программы, эта функция не должна быть определена в других исходных файлах, так что вызовы функции не могут быть встроенными. Таким образом, не статические функции всегда компилируются в выделенный код, как обычно.

Если Вы укажете в определении функции и inline и extern, то это определение будет использовано только для встраивания. Функция ни в коем случае не будет скомпилирована как отдельный код, даже если Вы обращаетесь к ней явно по её адресу. Такой адрес становится внешней ссылкой, как будто Вы только декларировали функцию, и не определили её.

Эта комбинация inline и extern дает эффект макроса. Способ использования - поместить определение функции с этими ключевыми словами в заголовочный файл, и поместить другую копию определения (без inline и extern) в библиотечный файл. Определение в заголовочном файле приведет к тому, что большинство вызовов функции будет встроенными. Если остается любое использование функции, то будет обращение к ней как к единственной копии в библиотеке.

[Встраиваемые функции в языке C в контексте портируемости кода]

У компилятора GNU C (и некоторых других компиляторов) имелись подставляемые (или, как их иногда называют, встраиваемые, inline) функции задолго до того, как они в языке C стали стандартом (стандарт 1999 года). В этой статье сведены в кучу правила использования встраиваемых (inline) функций, и даны некоторые советы по практическому использованию inline-функций.

В точке применения встраиваемой функции компилятору делается подсказка, что нужно предпринять некие действия для того, чтобы вызвать функцию быстрее, чем это было бы сделано как обычно. Чаще всего эти действия заключаются в том, что в месте вызова будет подставлено тело функции без оператора вызова. Поскольку при такой подстановке уже не требуются инструкции для вызова (call) и возврата (ret), а также не надо сохранять в стеке локальные переменные функции и используемые регистры, то это дает компилятору выполнить определенные оптимизации при объединении кода функции и основной программы.

Иногда необходимо для компилятора сгенерировать автономную копию объектного кода для функции даже тогда, когда эта функция встраиваемая - например, когда нужно взять адрес функции, или если функция не может быть встроена в каком-то частном контексте, или когда (возможно) выключена оптимизация. (И конечно, если используете компилятор, который не понимает inline, Вам нужно иметь отдельную копию объектного кода, чтобы все вызовы действительно могли работать.)

Есть несколько способов определить inline-функции; любой имеющийся вид определения мог бы определенно сгенерировать автономный объектный код, или определенно не генерировать автономный объектный код, или сгенерировать автономный объектный код только если известно, что это необходимо. Иногда это может привести к дублированию объектного кода, который является потенциальной проблемой по следующим причинам:

• Впустую расходуется память.
• Может привести к тому, что указатели на одну и ту же функцию не будут равны друг другу.
• Может снизиться эффективность кэша инструкций (хотя встраивание также могло быть сделано другими способами).

Если любое из перечисленного является для Вас проблемой, то можно использовать стратегию для обхода дублирования кода. Это как раз обсуждается в статье.

[Правила для inline стандарта C99]

Спецификация для встраивания описана в секции 6.7.4 стандарта C99 (ISO/IEC 9899:1999). К сожалению, эта информация не находится в свободном доступе. Имеются следующие возможности.

// Декларация, помеченная как inline

inline int max(int a, int b);

// Определение, помеченное как inline

inline int max(int a, int b) {
  return a > b ? a : b;
}

// Декларация, упомянутая как extern и inline

extern inline int max(int a, int b);

// Определение, упомянутое как inline

inline int max(int a, int b) {

  return a > b ? a : b;
}

// Декларация, не помеченная inline

int max(int a, int b);

// Определение, помеченное inline

inline int max(int a, int b) {
  return a > b ? a : b;
}

static inline int max(int a, int b) {
  return a > b ? a : b;
}

Первые два варианта естественно сочетаются. Вы либо пишете везде inline и extern в одном месте для запроса автономного определения, или пишете inline почти везде, но опускаете его обязательно один раз, чтобы получить автономное определение.

Функция main не может быть встроенной (inline) функцией.

(Правила C++ строже: функция, которая появилась где-то как inline, должна быть везде определена как inline, и должна быть определена одинаково во всех юнитах трансляции, где используется.)

[Правила для inline компилятора GNU C]

Правила GNU C описаны в руководстве по компилятору GNU C, которое поставляется вместе с компилятором. Они свободно доступны на сайте http://gcc.gnu.org. Имеются следующие возможности.

С релиза 4.3 компилятор GNU C поддерживает правила встраивания C99, описанные выше, и использует их по умолчанию с опциями -std=c99 или -std=gnu99. Старые правила могут быть запрошены в новых компиляторах опцией -gnu89-inline, или использованием атрибута функции gnu_inline.

Если действуют правила C99, то GCC определит макрос __GNUC_STDC_INLINE__. Начиная с GCC 4.1.3 будет определен макрос __GNUC_GNU_INLINE__, если используются только правила GCC, но старые компиляторы используют эти же правила без определения какого-либо макроса. Вы можете разрулить ситуацию, используя фрагмент кода наподобие следующего:

#if defined __GNUC__ && !defined __GNUC_STDC_INLINE__ && !defined __GNUC_GNU_INLINE__

# define __GNUC_GNU_INLINE__ 1

#endif

[Стратегии использования inline-функций]

Следующие правила советуют возможные модели использования inline-функций, более или менее влияя на портируемость.

Простая модель для портирования. Используйте static inline (либо в общем заголовочном файле, или просто в одном файле). Если компилятору нужно сгенерировать определение (например, чтобы получить его адрес, или потому, что он не хочет делать некоторые вызовы встроенными) то Вы потеряете некоторое место под код; если Вы возьмете адрес функции в двух юнитах трансляции, то взятые адреса не будут одинаковыми при сравнении.

Например, в заголовочном файле:

static inline int max(int a, int b) {
  return a > b ? a : b;
}

Вы можете поддерживать устаревшие компиляторы (например не имеющие inline) через опцию -Dinline="", хотя это приведет к потерям памяти, если компилятор не делает оптимизацию по неиспользуемым функциям.

Модель GNU C. Используйте extern inline в общем заголовочном файле и предоставьте определение где-нибудь в файле .c, возможно используя макрос - чтобы гарантировать появления везде одинакового кода. Например, в заголовочном файле:

#ifndef INLINE

# define INLINE extern inline

#endif

INLINE int max(int a, int b) {
  return a > b ? a : b;
}

... и точно только в одном файле исходного кода:

#define INLINE

#include "header.h"

Поддержка устаревших компиляторов будет затруднительной за исключением случая, когда Вас не заботит лишняя трата памяти, и можно иметь несколько адресов одной и той же функции; Вам нужно ограничить определения пределами одного юнита трансляции (с ключевым словом INLINE, преобразованном препроцессором в пустую строку), и добавить некоторые внешние декларации в заголовочный файл.

Модель C99. Используйте inline в общем заголовочном файле, и предоставьте определения где-нибудь в файле .c, через декларации extern. Например, в файле заголовка:

inline int max(int a, int b) {
  return a > b ? a : b;
}

... и только одном каком-нибудь файле исходного кода:

#include "header.h"

extern int max(int a, int b);

Чтобы добавить поддержку устаревших компиляторов, Вы должны все это обратить кодом для препроцессора так, чтобы декларации были видны в общем заголовке, и определения были ограничены одним юнитом трансляции, в котором определена функция через inline.

Сложная модель портирования. Используйте макрос для выбора определения либо с использованием extern inline для GNU C, inline для C99, либо без ничего из этого. Например, в заголовке:

#ifndef INLINE

# if __GNUC__ && !__GNUC_STDC_INLINE__

#  define INLINE extern inline

# else

#  define INLINE inline

# endif

#endif

INLINE int max(int a, int b) {
  return a > b ? a : b;
}

... и только в одном файле исходного кода:

#define INLINE

#include "header.h"

У поддержки устаревших компиляторов есть те же проблемы, что и с моделью GNU C.

Если Вы заметили какие-либо ошибки, пожалуйста сообщите об этом в комментариях.

[Ссылки]

1. Inline Functions In C site:greenend.org.uk.
2. An Inline Function is As Fast As a Macro site:gcc.gnu.org.
3. Options Controlling C++ Dialect site:gcc.gnu.org.