6.31.1 Атрибуты общих функций

Следующие атрибуты поддерживаются на большинстве целевых платформ.

alias ("target")

Атрибут alias заставляет объявление генерироваться как псевдоним для другого символа, который должен быть указан. Например,

void __f () { /* Do something. */; }
void f () __attribute__ ((weak, alias ("__f")));

определяет ‘f’ как слабый псевдоним для ‘__f’. В C++, должно использоваться закодированное имя целевой платформы. Ошибка возникает, если ‘__f’ не определено в том же трансляционном блоке.

Для этого атрибута требуется поддержка ассемблера и объектных файлов, и он может быть недоступен на всех целевых платформах.

aligned (alignment)

Этот атрибут задаёт минимальное выравнивание для функции, измеряемое в байтах.

Вы не можете использовать этот атрибут для уменьшения выравнивания функции, только для его увеличения. Однако, когда вы явно задаёте выравнивание функции, это переопределяет эффект опции -falign-functions (см. Параметры оптимизации) для этой функции.

Обратите внимание, что эффективность атрибутов aligned может быть ограничена внутренними ограничениями вашего компоновщика. На многих системах компоновщик может только обеспечить выравнивание функций до определенного максимального значения. (Для некоторых компоновщиков максимальное поддерживаемое выравнивание может быть очень малым.) Обратитесь к документации вашего компоновщика для получения дополнительной информации.

Атрибут aligned также может использоваться для переменных и полей (см. Атрибуты переменных).

alloc_align

Атрибут alloc_align используется для указания компилятору, что возвращаемое значение функции указывает на память, где минимальное выравнивание возвращаемого указателя задаётся одним из параметров функции. GCC использует эту информацию для улучшения анализа выравнивания указателей.

Параметр функции, обозначающий выравнивание выделенной памяти, задаётся одним целочисленным аргументом, число которого является аргументом атрибута. Нумерация аргументов начинается с единицы.

Например,

void* my_memalign(size_t, size_t) __attribute__((alloc_align(1)))

объявляет, что my_memalign возвращает память с минимальным выравниванием, заданным параметром 1.

alloc_size

Атрибут alloc_size используется для указания компилятору, что возвращаемое значение функции указывает на память, где размер задаётся одним или двумя параметрами функции. GCC использует эту информацию для повышения корректности __builtin_object_size.

Параметр(ы) функции, обозначающий(ие) выделенный размер, задаются одним или двумя целочисленными аргументами, предоставленными атрибуту. Размер выделенной памяти либо равен значению единственного указанного параметра функции, либо равен произведению двух указанных параметров функции. Нумерация аргументов начинается с единицы.

Например,

void* my_calloc(size_t, size_t) __attribute__((alloc_size(1,2)))
void* my_realloc(void*, size_t) __attribute__((alloc_size(2)))

объявляет, что my_calloc возвращает память размером, равным произведению параметров 1 и 2, а my_realloc возвращает память размером, равным параметру 2.

always_inline

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

artificial

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

assume_aligned

Атрибут assume_aligned используется для указания компилятору, что возвращаемое значение функции указывает на память, где минимальное выравнивание возвращаемого указателя задаётся первым аргументом. Если атрибут имеет два аргумента, второй аргумент — это смещение несовпадения.

Например

void* my_alloc1(size_t) __attribute__((assume_aligned(16)))
void* my_alloc2(size_t) __attribute__((assume_aligned(32, 8)))

объявляет, что my_alloc1 возвращает 16-байтовый выровненный указатель, а my_alloc2 возвращает указатель, чьё значение по модулю 32 равно 8.

bnd_instrument

Атрибут bnd_instrument для функций используется для информирования компилятора о том, что функция должна быть инструментирована при компиляции с опцией -fchkp-instrument-marked-only.

bnd_legacy

Атрибут bnd_legacy для функций используется для информирования компилятора о том, что функция не должна быть инструментирована при компиляции с опцией -fcheck-pointer-bounds.

cold

Атрибут cold для функций используется для информирования компилятора о том, что функция, скорее всего, не будет выполнена. Функция оптимизируется по размеру, а не по скорости, и на многих платформах она размещается в специальной подсекции секции текста, так что все холодные функции находятся близко друг к другу, улучшая локальность кода для нехолодных частей программы. Пути, ведущие к вызовам холодных функций в коде, отмечаются механизмом предсказания ветвлений как маловероятные. Поэтому полезно помечать функции, используемые для обработки маловероятных условий, такие как perror, как холодные, чтобы улучшить оптимизацию горячих функций, которые в редких случаях вызывают помеченные функции.

Если доступна обратная связь с профилем через -fprofile-use, холодные функции автоматически обнаруживаются, и этот атрибут игнорируется.

const

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

Обратите внимание, что функция, имеющая указательные аргументы и проверяющая данные, к которым указывают эти аргументы, не должна быть объявлена как const. Аналогично, функция, вызывающая не-const функцию, обычно не должна быть const Функция const, обычно, не должна возвращать void.

constructor

destructor

constructor (priority)

destructor (priority)

Атрибут constructor вызывает функцию автоматически перед тем, как выполнение войдёт в main (). Аналогично, атрибут destructor вызывает функцию автоматически после того, как main () завершится или будет вызвано exit (). Функции с этими атрибутами полезны для инициализации данных, которые неявно используются во время выполнения программы.

Вы можете указать необязательный целочисленный приоритет для управления порядком выполнения конструкторов и деструкторов. Конструктор с меньшим номером приоритета выполняется перед конструктором с большим номером приоритета; обратное соотношение справедливо для деструкторов. Таким образом, если у вас есть конструктор, который выделяет ресурс, и деструктор, который освобождает тот же ресурс, обе функции, как правило, имеют одинаковый приоритет. Приоритеты конструкторов и деструкторов совпадают с приоритетами объектов C++ на уровне пространства имён (см. Атрибуты C++).

Эти атрибуты в настоящее время не реализованы для Objective-C.

deprecated

deprecated (msg)

Атрибут deprecated приводит к появлению предупреждения, если функция используется где-либо в исходном файле. Это полезно для идентификации функций, которые, как ожидается, будут удалены в будущей версии программы. Предупреждение также включает местоположение объявления устаревшей функции, что позволяет пользователям легко найти дополнительную информацию о том, почему функция устарела или что им следует делать вместо этого. Обратите внимание, что предупреждения появляются только при использовании:

int old_fn () __attribute__ ((deprecated));
int old_fn ();
int (*fn_ptr)() = old_fn;

приводит к появлению предупреждения на строке 3, но не на строке 2. Необязательный аргумент msg, который должен быть строкой, выводится в предупреждении, если он присутствует.

Атрибут deprecated также может использоваться для переменных и типов (см. Атрибуты переменных, см. Атрибуты типов).

error ("message")

warning ("message")

Если атрибут error или warning используется в объявлении функции, и вызов такой функции не исключается через удаление неиспользуемого кода или другие оптимизации, диагностируется ошибка или предупреждение (соответственно), включающее сообщение. Это полезно для проверки во время компиляции, особенно в сочетании с __builtin_constant_p и встраиваемыми функциями, где проверка аргументов встраиваемой функции невозможна с помощью extern char [(condition) ? 1 : -1]; уловок.

Хотя можно оставить функцию неопределённой и тем самым вызвать ошибку компоновки (для определения функции с сообщением в разделе .gnu.warning*), при использовании этих атрибутов проблема диагностируется раньше и с точным местоположением вызова, даже в случае присутствия встраиваемых функций или при отсутствии вывода отладочной информации.

externally_visible

Этот атрибут, прикреплённый к глобальной переменной или функции, делает опцию командной строки -fwhole-program недействительной, так что объект остаётся видимым за пределами текущей единицы компиляции.

Если -fwhole-program используется вместе с -flto и gold используется в качестве плагина компоновщика, атрибуты externally_visible автоматически добавляются к функциям (ещё не к переменным из-за текущей проблемы gold), к которым осуществляется доступ за пределами объектов LTO в соответствии с файлом разрешений, созданным gold. Для других компоновщиков, которые не могут создать файл разрешений, явные атрибуты externally_visible всё ещё необходимы.

flatten

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

format (archetype, string-index, first-to-check)

Атрибут format указывает, что функция принимает аргументы типа printf, scanf, strftime или strfmon стиля, которые должны быть проверены на соответствие строке формата. Например, объявление:

extern int
my_printf (void *my_object, const char *my_format, ...)
      __attribute__ ((format (printf, 2, 3)));

приводит к тому, что компилятор проверяет аргументы в вызовах функции my_printf на соответствие строке формата printf стиля my_format.

Параметр archetype определяет, как интерпретируется строка формата, и должен быть printf, scanf, strftime, gnu_printf, gnu_scanf, gnu_strftime или strfmon. (Можно также использовать __printf__, __scanf__, __strftime__ или __strfmon__. ) На целевых платформах MinGW также присутствуют ms_printf, ms_scanf и ms_strftime. Значения archetype, такие как printf, относятся к форматам, поддерживаемым системной библиотекой C runtime, в то время как значения, начинающиеся с 'gnu_', всегда относятся к форматам, поддерживаемым GNU C Library. На целевых платформах Microsoft Windows значения, начинающиеся с 'ms_', относятся к форматам, поддерживаемым библиотекой msvcrt.dll. Параметр string-index указывает, какой аргумент является аргументом строки формата (начиная с 1), а first-to-check — номер первого аргумента для проверки на соответствие строке формата. Для функций, где аргументы недоступны для проверки (например, vprintf), укажите третий параметр как ноль. В этом случае компилятор проверяет только соответствие строки формата. Для форматов strftime третий параметр должен быть равен нулю. Поскольку у нестатических методов C++ есть неявный аргумент this, аргументы таких методов следует считать с двух, а не с одного, при указании значений для string-index и first-to-check.

В приведённом примере строка формата (my_format) является вторым аргументом функции my_print, а аргументы для проверки начинаются с третьего аргумента, поэтому правильные параметры для атрибута format — 2 и 3.

Атрибут format позволяет идентифицировать собственные функции, принимающие строки формата в качестве аргументов, чтобы GCC мог проверять вызовы этих функций на ошибки. Компилятор всегда (если не используется -ffreestanding или -fno-builtin) проверяет форматы для стандартных функций библиотеки printf, fprintf, sprintf, scanf, fscanf, sscanf, strftime, vprintf, vfprintf и vsprintf, когда такие предупреждения запрошены (с помощью -Wformat), поэтому нет необходимости изменять заголовочный файл stdio.h. В режиме C99 также проверяются функции snprintf, vsnprintf, vscanf, vfscanf и vsscanf. За исключением строго совместимых режимов стандарта C, также проверяется функция X/Open strfmon, а также printf_unlocked и fprintf_unlocked. См. Параметры, управляющие диалектом C.

Для диалектов Objective-C распознаётся NSString (или __NSString__) в том же контексте. Объявления, включающие эти атрибуты format, анализируются для правильности синтаксиса, однако результат проверки таких строк формата пока не определён и не выполняется этой версией компилятора.

Целевая платформа может также предоставлять дополнительные типы проверок формата. См. Проверки формата, специфичные для конкретных целевых платформ.

format_arg (string-index)

Атрибут format_arg указывает, что функция принимает строку формата для функции стиля printf, scanf, strftime или strfmon и модифицирует её (например, для перевода на другой язык), так что результат может быть передан функции стиля printf, scanf, strftime или strfmon (с остальными аргументами функции формата такими же, как и для немодифицированной строки). Например, объявление:

extern char *
my_dgettext (char *my_domain, const char *my_format)
      __attribute__ ((format_arg (2)));

приводит к тому, что компилятор проверяет аргументы в вызовах функции типа printf, scanf, strftime или strfmon, где аргументом строки формата является вызов функции my_dgettext, на соответствие строке формата my_format. Если атрибут format_arg не был указан, компилятор мог бы определить только то, что аргумент строки формата не является константой; это вызвало бы предупреждение при использовании -Wformat-nonliteral, но вызовы нельзя было бы проверить без атрибута.

Параметр string-index указывает, какой аргумент является аргументом строки формата (начиная с единицы). Поскольку у нестатических методов C++ есть неявный аргумент this, аргументы таких методов следует считать с двух.

Атрибут format_arg позволяет идентифицировать собственные функции, модифицирующие строки формата, чтобы GCC мог проверять вызовы функции типа printf, scanf, strftime или strfmon, операнды которых являются вызовом одной из собственных функций. Компилятор всегда обрабатывает gettext, dgettext, и dcgettext таким образом, за исключением случаев, когда строгая поддержка стандарта ISO C запрошена с помощью -ansi или соответствующего параметра -std, или используется -ffreestanding или -fno-builtin. См. Параметры, управляющие диалектом C.

Для диалектов Objective-C атрибут format-arg может ссылаться на NSString ссылку для совместимости с атрибутом format выше.

Целевая платформа также может допускать дополнительные типы в атрибутах format-arg. См. Проверки формата, специфичные для конкретных целевых платформ.

gnu_inline

Этот атрибут следует использовать с функцией, также объявленной с ключевым словом inline. Он сообщает GCC рассматривать функцию так, как будто она определена в режиме gnu90, даже при компиляции в режиме C99 или gnu99.

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

В C, если функция не extern и не static, то функция компилируется как самостоятельная функция, а также встраивается при возможности.

Вот как GCC традиционно обрабатывал функции, объявленные inline. Поскольку ISO C99 определяет другую семантику для inline, этот атрибут функции предоставляется как переходная мера и как полезная функция сама по себе. Этот атрибут доступен в GCC 4.1.3 и более поздних версиях. Он доступен, если определён один из препроцессорных макросов __GNUC_GNU_INLINE__ или __GNUC_STDC_INLINE__. См. Функция inline такая же быстрая, как макрос.

В C++, этот атрибут никак не зависит от extern, но для включения его специального поведения всё равно требуется ключевое слово inline.

hot

Атрибут hot для функции используется для информирования компилятора о том, что функция является горячей точкой в скомпилированной программе. Функция оптимизируется более агрессивно, и на многих целевых платформах она размещается в специальном разделе секции текста, так что все горячие функции находятся рядом, улучшая локальность.

Когда доступна обратная связь профилей через -fprofile-use, горячие функции автоматически обнаруживаются, и этот атрибут игнорируется.

ifunc ("resolver")

Атрибут ifunc используется для маркировки функции как косвенной функции, используя расширение типа символа STT_GNU_IFUNC к стандарту ELF. Это позволяет динамически определить значение символа во время загрузки, и для конкретного процессора или других системных характеристик, определённых тогда, может быть выбран оптимизированный вариант процедуры. Для использования этого атрибута сначала определите доступные реализующие функции и функцию разрешения, возвращающую указатель на выбранную реализующую функцию. Объявления реализующих функций должны соответствовать API реализуемой функции, объявление функции разрешения должно быть функцией, возвращающей указатель на функцию типа void, возвращающую void:

void *my_memcpy (void *dst, const void *src, size_t len)
{
  …
}

static void (*resolve_memcpy (void)) (void)
{
  return my_memcpy; // we'll just always select this routine
}

Экспортируемый заголовочный файл, объявляющий вызываемую пользователем функцию, должен содержать:

extern void *memcpy (void *, const void *, size_t);

позволяя пользователю вызывать её как обычную функцию, не зная о реализации. Наконец, косвенная функция должна быть определена в том же модуле трансляции, что и функция разрешения:

void *memcpy (void *, const void *, size_t)
     __attribute__ ((ifunc ("resolve_memcpy")));

Косвенные функции не могут быть слабыми. Для использования этой функции необходимы утилиты binutils версии 2.20.1 или выше и GNU C Library версии 2.11.1 или выше.

interrupt

interrupt_handler

Многие бэкэнды GCC поддерживают атрибуты для указания того, что функция является обработчиком прерываний, что сообщает компилятору генерировать последовательности входа и выхода из функции, отличные от последовательностей обычных функций. Точная синтаксис и поведение зависят от целевой платформы; подробности см. в соответствующих подразделах.

leaf

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

Этот атрибут предназначен для функций библиотек для улучшения анализа потока данных. Компилятор принимает подсказку о том, что любые данные, не покидающие текущий модуль компиляции, не могут использоваться или изменяться функцией-листом. Например, функция sin является функцией-листом, но qsort — нет.

Обратите внимание, что функции-листы могут косвенно запускать обработчик сигналов, определенный в текущем модуле компиляции, который использует статические переменные. Аналогично, при использовании ленивого разрешения символов функции-листы могут вызывать косвенные функции, функция разрешения или функция реализации которых определены в текущем модуле компиляции и используют статические переменные. Нет стандартного способа написать такой обработчик сигналов, функцию разрешения или функцию реализации, и лучше всего вы можете сделать, это убрать атрибут leaf или пометить все такие статические переменные volatile. Наконец, для систем на основе ELF, которые поддерживают интерпозицию символов, следует соблюдать осторожность, чтобы функции, определенные в текущем модуле компиляции, не интерпозировали другие символы неожиданным образом на основе определенного режима стандартов и определенных макросов проверок функций; в противном случае будет добавлен непреднамеренный обратный вызов.

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

malloc

Это сообщает компилятору, что функция является функцией типа malloc, т. е. что указатель P, возвращаемый функцией, не может ссылаться на какой-либо другой указатель, действительный при возвращении функции, и, кроме того, ни один указатель на действительные объекты не появляется в любом хранилище, адресуемом P.

Использование этого атрибута может улучшить оптимизацию. Функции, подобные malloc и calloc, обладают этим свойством, потому что они возвращают указатель на неинициализированное или обнуленное хранилище. Однако функции, подобные realloc, не обладают этим свойством, так как они могут возвращать указатель на хранилище, содержащее указатели.

no_icf

Этот атрибут функции предотвращает объединение функции с другой семантически эквивалентной функцией.

no_instrument_function

Если указано -finstrument-functions, для большинства функций, скомпилированных пользователем, генерируются профилирующие вызовы функций при входе и выходе. Функции с этим атрибутом не инструментируются таким образом.

no_reorder

Не переупорядочивайте функции или переменные, помеченные no_reorder друг относительно друга или верхнеуровневые инструкции ассемблера в исполняемом файле. Фактический порядок в программе будет зависеть от командной строки компоновщика. Статические переменные, помеченные таким образом, также не удаляются. Это оказывает аналогичное действие, как опция -fno-toplevel-reorder, но применяется только к помеченным символам.

no_sanitize_address

no_address_safety_analysis

Атрибут no_sanitize_address для функций используется для информирования компилятора о том, что он не должен инструментировать обращения к памяти в функции при компиляции с опцией -fsanitize=address. no_address_safety_analysis — устаревший псевдоним атрибута no_sanitize_address, в новом коде следует использовать no_sanitize_address.

no_sanitize_thread

Атрибут no_sanitize_thread для функций используется для информирования компилятора о том, что он не должен инструментировать обращения к памяти в функции при компиляции с опцией -fsanitize=thread.

no_sanitize_undefined

Атрибут no_sanitize_undefined для функций используется для информирования компилятора о том, что он не должен проверять неопределенное поведение в функции при компиляции с опцией -fsanitize=undefined.

no_split_stack

Если задана опция -fsplit-stack, у функций есть небольшой пролог, который определяет, следует ли разделять стек. Функции с атрибутом no_split_stack не имеют этого пролога и поэтому могут работать только с небольшим объемом доступной памяти стека.

no_stack_limit

Этот атрибут локально переопределяет опции командной строки -fstack-limit-register и -fstack-limit-symbol; он имеет эффект отключения проверки предела стека в функции, к которой он применяется.

noclone

Этот атрибут функции предотвращает рассмотрение функции для клонирования — механизма, который создает специализированные копии функций и который (в настоящее время) выполняется межпроцедурной постоянной проработкой.

noinline

Этот атрибут функции предотвращает рассмотрение функции для встраивания. Если функция не имеет побочных эффектов, существуют оптимизации, отличные от встраивания, которые приводят к оптимизации вызовов функций, хотя вызов функции активен. Чтобы предотвратить оптимизацию таких вызовов, поместите

asm ("");

(см. Расширенный ассемблер) в вызываемую функцию, чтобы служить специальным побочным эффектом.

nonnull (arg-index, …)

Атрибут nonnull указывает, что некоторые параметры функции должны быть указателями, не равными нулю. Например, объявление:

extern void *
my_memcpy (void *dest, const void *src, size_t len)
        __attribute__((nonnull (1, 2)));

заставляет компилятор проверять, что в вызовах my_memcpy аргументы dest и src не равны нулю. Если компилятор определяет, что указатель с нулевым значением передается в слот аргумента, помеченный как не равный нулю, и опция -Wnonnull включена, выводится предупреждение. Компилятор также может выбрать выполнение оптимизаций на основе знания о том, что определенные аргументы функций никогда не будут нулевыми.

Если для атрибута nonnull не указан список индексов аргументов, все указатели-аргументы помечаются как не равные нулю. Для иллюстрации, следующее объявление эквивалентно предыдущему примеру:

extern void *
my_memcpy (void *dest, const void *src, size_t len)
        __attribute__((nonnull));

noplt

Атрибут noplt является обратной стороной опции -fno-plt. Вызовы функций, помеченных этим атрибутом в позиционно-независимом коде, не используют PLT.

/* Externally defined function foo.  */
int foo () __attribute__ ((noplt));

int
main (/* … */)
{
  /* … */
  foo ();
  /* … */
}

Атрибут noplt для функции foo сообщает компилятору, что функция foo определена внешним образом и что вызов foo должен избегать PLT в позиционно-независимом коде.

В позиционно-зависимом коде некоторые целевые платформы также преобразуют вызовы функций, помеченных как не использующие PLT, в использование GOT вместо него.

noreturn

Некоторые стандартные функции библиотеки, такие как abort и exit, не могут возвращаться. GCC автоматически знает об этом. Некоторые программы определяют свои собственные функции, которые никогда не возвращаются. Вы можете объявить их noreturn для сообщения об этом факте компилятору. Например,

void fatal () __attribute__ ((noreturn));

void
fatal (/* … */)
{
  /* … */ /* Print error message. */ /* … */
  exit (1);
}

Ключевое слово noreturn сообщает компилятору, что fatal не может возвратиться. Тогда он может оптимизировать, не учитывая то, что произойдёт, если fatal вернётся. Это делает код немного лучше. Более важно, что это помогает избежать ложных предупреждений о неинициализированных переменных.

Ключевое слово noreturn не влияет на исключительный путь, когда он применим: функция, помеченная noreturn, всё равно может возвратиться вызывающей функции, выбросив исключение или вызвав longjmp.

Не предполагайте, что регистры, сохранённые вызывающей функцией, восстанавливаются перед вызовом функции noreturn.

Не имеет смысла, чтобы функция noreturn имела тип возвращаемого значения, отличный от void.

nothrow

Атрибут nothrow используется для информирования компилятора о том, что функция не может выбросить исключение. Например, большинство функций в стандартной библиотеке C гарантированно не выбросят исключение, за исключением qsort и bsearch, принимающих указатели на функции в качестве аргументов.

optimize

Атрибут optimize используется для указания того, что функция должна компилироваться с различными параметрами оптимизации, чем указанные в командной строке. Аргументы могут быть числами или строками. Числа считаются уровнем оптимизации. Строки, начинающиеся с O, предполагаются параметрами оптимизации, а остальные — предполагаются используемыми с префиксом -f. Вы также можете использовать директиву ‘#pragma GCC optimize’ для установки параметров оптимизации, влияющих на более чем одну функцию. Подробности о директиве ‘#pragma GCC optimize’ см. в разделе Функционально-специфические опции директивы #pragma.

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

pure

Многие функции не имеют эффектов, кроме возвращаемого значения, и их возвращаемое значение зависит только от параметров и/или глобальных переменных. Такая функция может быть подвергнута оптимизации устранения общих подвыражений и оптимизации циклов так же, как и арифметический оператор. Эти функции должны быть объявлены с атрибутом pure. Например,

int square (int) __attribute__ ((pure));

указывает, что гипотетическая функция square можно вызывать меньше раз, чем указано в программе.

Некоторые общие примеры чистых функций — strlen или memcmp. Интересными нечистыми функциями являются функции с бесконечными циклами или те, которые зависят от переменных volatile или других системных ресурсов, которые могут измениться между двумя последовательными вызовами (например, feof в многопоточной среде).

returns_nonnull

Атрибут returns_nonnull указывает, что возвращаемое значение функции должно быть указателем, отличным от нуля. Например, объявление:

extern void *
mymalloc (size_t len) __attribute__((returns_nonnull));

позволяет компилятору оптимизировать вызывающие функции, зная, что возвращаемое значение никогда не будет нулевым.

returns_twice

Атрибут returns_twice сообщает компилятору, что функция может возвращать значение более одного раза. Компилятор гарантирует, что все регистры будут освобождены перед вызовом такой функции, и выводит предупреждение о переменных, которые могут быть изменены после второго возврата из функции. Примеры таких функций — setjmp и vfork. Соответствующая функция типа longjmp, если она есть, может потребовать маркировки атрибутом noreturn.

section ("section-name")

Обычно компилятор помещает сгенерированный код в секцию text. Иногда, однако, вам требуются дополнительные секции или вы хотите, чтобы определенные функции появлялись в специальных секциях. Атрибут section указывает, что функция находится в определенной секции. Например, объявление:

extern void foobar (void) __attribute__ ((section ("bar")));

помещает функцию foobar в секцию bar.

Некоторые форматы файлов не поддерживают произвольные секции, поэтому атрибут section недоступен на всех платформах. Если вам нужно отобразить все содержимое модуля в определённой секции, воспользуйтесь возможностями компоновщика.

sentinel

Этот атрибут функции гарантирует, что параметр в вызове функции является явным NULL. Атрибут действителен только для функций с переменным числом аргументов. По умолчанию указатель находится на нулевой позиции, в качестве последнего параметра вызова функции. Если в атрибут передаётся необязательный целочисленный аргумент P, указатель должен находиться на позиции P, считая обратный отсчёт от конца списка аргументов.

__attribute__ ((sentinel))
is equivalent to
__attribute__ ((sentinel(0)))

Атрибут автоматически устанавливается с позицией 0 для встроенных функций execl и execlp. Для встроенной функции execle атрибут устанавливается с позицией 1.

Действительным NULL в этом контексте является ноль с любым типом указателя. Если ваша система определяет макрос NULL с целочисленным типом, вам нужно добавить явное приведение типов. GCC заменяет stddef.h на копию, которая соответствующим образом переопределяет NULL.

Предупреждения о пропущенных или неправильных указателях включены с помощью -Wformat.

simd

simd("mask")

Этот атрибут позволяет создавать одну или несколько версий функции, которые могут обрабатывать несколько аргументов с помощью инструкций SIMD из одного вызова. Указание этого атрибута позволяет компилятору предположить, что такие версии доступны во время компоновки (приведены в той же или другой единице трансляции). Сгенерированные версии зависят от целевой платформы и описаны в соответствующем документе Vector ABI. Для целевой платформы x86_64 этот документ можно найти здесь.

Необязательный аргумент mask может иметь значение notinbranch или inbranch, и соответственно указывает компилятору генерировать немаскированные или маскированные копии. По умолчанию генерируются все копии.

Атрибут не должен использоваться совместно с атрибутом Cilk Plus vector для той же функции.

Если атрибут указан и #pragma omp declare simd присутствует в объявлении, а также задан флаг -fopenmp или -fopenmp-simd, то атрибут игнорируется.

stack_protect

Этот атрибут добавляет код защиты стека к функции, если установлены флаги -fstack-protector, -fstack-protector-strong или -fstack-protector-explicit.

target (options)

Несколько целевых бэкэндов реализуют атрибут target для указания того, что функция должна компилироваться с различными параметрами целевой платформы, отличными от заданных в командной строке. Это может быть использовано, например, для компиляции функций с другим набором команд (архитектурой набора команд), отличным от стандартного. Также можно использовать директиву «#pragma GCC target» для установки параметров компиляции для нескольких функций. См. Function Specific Option Pragmas для получения подробной информации о директиве «#pragma GCC target».

Например, на x86 можно объявить одну функцию с атрибутом target("sse4.1,arch=core2") и другую с target("sse4a,arch=amdfam10"). Это эквивалентно компиляции первой функции с параметрами -msse4.1 и -march=core2, а второй — с -msse4a и -march=amdfam10. Вам нужно убедиться, что функция вызывается только на машине, поддерживающей конкретный набор команд, для которого она скомпилирована (например, используя cpuid на x86 для определения используемых битов функций и семейства архитектуры).

int core2_func (void) __attribute__ ((__target__ ("arch=core2")));
int sse3_func (void) __attribute__ ((__target__ ("sse3")));

Вы можете использовать несколько строк, разделённых запятыми, для указания нескольких параметров, или разделить параметры запятой (',') в одной строке.

Поддерживаемые параметры зависят от каждой целевой платформы; обратитесь к x86 Function Attributes, PowerPC Function Attributes, ARM Function Attributes и Nios II Function Attributes для получения подробной информации.

target_clones (options)

Атрибут target_clones используется для указания того, что функция должна быть клонирована в несколько версий, скомпилированных с различными параметрами целевой платформы, отличными от заданных в командной строке. Поддерживаемые параметры и ограничения аналогичны атрибуту target.

Например, на x86 можно скомпилировать функцию с target_clones("sse4.1,avx"). GCC создаёт две копии функции, одну, скомпилированную с -msse4.1, и другую — с -mavx. Также создаётся функция-разрешитель (см. атрибут ifunc выше), которая динамически выбирает копию, подходящую для текущей архитектуры.

unused

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

used

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

При применении к члену функции шаблона класса C++, этот атрибут также означает, что функция будет проинстанцирована, если сам класс будет проинстанцирован.

visibility ("visibility_type")

Этот атрибут влияет на связь объявления, к которому он прикреплен. Он может быть применён к переменным (см. Общие атрибуты переменных) и типам (см. Общие атрибуты типов), а также к функциям.

Поддерживаются четыре значения visibility_type: default, hidden, protected или internal visibility.

void __attribute__ ((visibility ("protected")))
f () { /* Do something. */; }
int i __attribute__ ((visibility ("hidden")));

Возможные значения visibility_type соответствуют настройкам видимости в формате ELF gABI.

default

Видимость по умолчанию — это обычный случай для формата файла объекта. Это значение доступно для атрибута видимости, чтобы переопределить другие параметры, которые могут изменить предполагаемую видимость сущностей.

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

В Darwin видимость по умолчанию означает, что объявление видно другим модулям.

Видимость по умолчанию соответствует «внешней связи» в языке.

hidden

Скрытая видимость указывает, что объявленная сущность имеет новый тип связи, который мы называем «скрытой связью». Два объявления объекта со скрытой связью относятся к одному объекту, если они находятся в одном разделяемом объекте.

internal

Видимость «внутренняя» похожа на скрытую видимость, но с дополнительной семантикой, специфичной для процессора. Если не указано иное psABI, GCC определяет внутреннюю видимость как то, что функция никогда не вызывается из другого модуля. Сравните это со скрытыми функциями, которые, хотя и не могут быть непосредственно упомянуты другими модулями, могут быть упомянуты косвенно через указатели на функции. Указывая, что функция не может быть вызвана извне модуля, GCC может, например, опустить загрузку регистра PIC, поскольку известно, что вызывающая функция загрузила правильное значение.

protected

Защищенная видимость аналогична видимости по умолчанию, за исключением того, что она указывает на то, что ссылки внутри определяющего модуля связываются с определением в этом модуле. То есть, объявленная сущность не может быть переопределена другим модулем.

Все виды видимости поддерживаются во многих, но не во всех, целях ELF (поддерживаются, когда ассемблер поддерживает псевдокоманду «.visibility»). Видимость по умолчанию поддерживается везде. Скрытая видимость поддерживается на целевых платформах Darwin.

Атрибут видимости следует применять только к объявлениям, которые в противном случае имели бы внешнюю связь. Атрибут следует применять последовательно, так чтобы одна и та же сущность не объявлялась с разными настройками атрибута.

В C++, атрибут видимости применяется как к типам, так и к функциям и объектам, потому что в C++ типы имеют связь. Класс не должен иметь большую видимость, чем его нестатические типы данных членов и базовые классы, а члены класса по умолчанию имеют видимость своего класса. Кроме того, объявление без явной видимости ограничено видимостью его типа.

В C++ вы можете пометить методы-члены и статические переменные-члены класса атрибутом видимости. Это полезно, если вы знаете, что определённый метод или статическая переменная-член должны использоваться только из одного разделяемого объекта; в таком случае вы можете пометить его как скрытый, в то время как остальная часть класса имеет видимость по умолчанию. Следует проявлять осторожность, чтобы избежать нарушения Правила одного определения; например, обычно не имеет смысла помечать встроенный метод как скрытый, не помечая весь класс как скрытый.

Объявление пространства имён C++ также может иметь атрибут видимости.

namespace nspace1 __attribute__ ((visibility ("protected")))
{ /* Do something. */; }

Этот атрибут применяется только к телу конкретного пространства имён, а не к другим определениям того же пространства имён; это эквивалентно использованию ‘#pragma GCC visibility’ до и после определения пространства имён (см. Атрибуты видимости).

В C++, если аргумент шаблона имеет ограниченную видимость, это ограничение подразумевается распространяться на экземпляры шаблона. В противном случае экземпляры и специализации шаблонов по умолчанию имеют видимость своего шаблона.

Если у шаблона и содержащего класса есть явная видимость, используется видимость шаблона.

warn_unused_result

Атрибут warn_unused_result вызывает вызов предупреждения, если вызывающая функция с этим атрибутом не использует своё возвращаемое значение. Это полезно для функций, где проверка результата является либо проблемой безопасности, либо всегда ошибкой, например, realloc.

int fn () __attribute__ ((warn_unused_result));
int foo ()
{
  if (fn () < 0) return -1;
  fn ();
  return 0;
}

приводит к появлению предупреждения на строке 5.

weak

Атрибут weak вызывает вывод объявления как слабого символа, а не глобального. Это в первую очередь полезно для определения функций библиотек, которые могут быть переопределены в пользовательском коде, хотя также может быть использовано с объявлениями, не являющимися функциями. Слабые символы поддерживаются для целей ELF, а также для целей a.out при использовании GNU ассемблера и компоновщика.

weakref

weakref ("target")

Атрибут weakref помечает объявление как слабое обращение. Без аргументов он должен сопровождаться атрибутом alias, назначающим целевой символ. Дополнительно, target может быть указан в качестве аргумента для weakref. В любом случае, weakref неявно помечает объявление как weak. Без target, заданного в качестве аргумента для weakref или для alias, weakref эквивалентно weak.

static int x() __attribute__ ((weakref ("y")));
/* is equivalent to... */
static int x() __attribute__ ((weak, weakref, alias ("y")));
/* and to... */
static int x() __attribute__ ((weakref));
static int x() __attribute__ ((alias ("y")));

Слабое обращение — это псевдоним, который сам по себе не требует предоставления определения для целевого символа. Если целевой символ ссылается только через слабые обращения, тогда он становится weak неопределённым символом. Однако, если он непосредственно ссылается, то такие сильные ссылки преобладают, и определение для символа необходимо, не обязательно в одном и том же блоке трансляции.

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

В настоящее время объявление, к которому прикреплён weakref , может быть только static.

Далее: Атрибуты функций AArch64, Назад: Атрибуты функций [Содержание][Индекс]