3.8 Параметры для запроса или подавления предупреждений

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

Следующие независимые от языка параметры не включают определённые предупреждения, но контролируют типы диагностических сообщений, генерируемых GCC.

-fsyntax-only

Проверяет код на синтаксические ошибки, но ничего сверх этого не делает.

-fmax-errors=n

Ограничивает максимальное количество сообщений об ошибках до n, после чего GCC прекращает работу, вместо того, чтобы пытаться продолжить обработку исходного кода. Если n равно 0 (по умолчанию), ограничений на количество сообщений об ошибках нет. Если также указан параметр -Wfatal-errors, то он имеет приоритет над этим параметром.

-w

Запрещает все сообщения о предупреждениях.

-Werror

Превращает все предупреждения в ошибки.

-Werror=

Превращает указанное предупреждение в ошибку. Спецификатор предупреждения добавляется; например, -Werror=switch превращает предупреждения, контролируемые -Wswitch, в ошибки. Этот параметр имеет отрицательную форму, которую следует использовать для отмены -Werror для конкретных предупреждений; например, -Wno-error=switch делает предупреждения -Wswitch не ошибками, даже когда параметр -Werror активен.

Сообщение о предупреждении для каждого контролируемого предупреждения включает параметр, который контролирует предупреждение. Этот параметр затем может использоваться с -Werror= и -Wno-error=, как описано выше. (Вывод параметра в сообщении о предупреждении можно отключить, используя флаг -fno-diagnostics-show-option.)

Обратите внимание, что указание -Werror=foo автоматически подразумевает -Wfoo. Однако -Wno-error=foo ничего не подразумевает.

-Wfatal-errors

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

Вы можете запросить многие конкретные предупреждения с помощью параметров, начинающихся с ‘-W’, например -Wimplicit для запроса предупреждений о неявных объявлениях. Каждый из этих конкретных параметров предупреждения также имеет отрицательную форму, начинающуюся с ‘-Wno-’ для отключения предупреждений; например, -Wno-implicit. В этом руководстве приводится только одна из двух форм, которая не является по умолчанию. Для получения дополнительных параметров, специфичных для языка, также обратитесь к Параметры, управляющие диалектом C++ и Параметры, управляющие диалектами Objective-C и Objective-C++. Дополнительные предупреждения могут быть получены при включении статического анализатора; см. Параметры, которые управляют статическим анализом.

Некоторые параметры, такие как -Wall и -Wextra, включают другие параметры, такие как -Wunused, которые могут включать дополнительные параметры, такие как -Wunused-value. Совместное действие положительных и отрицательных форм заключается в том, что более конкретные параметры имеют приоритет над менее конкретными, независимо от их позиции в командной строке. Для параметров одинаковой специфичности действует последний.

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

Когда запрашивается неизвестный параметр предупреждения (например, -Wunknown-warning), GCC выводит диагностическое сообщение, в котором говорится, что параметр не распознаётся. Однако, если используется форма -Wno-, поведение немного отличается: диагностическое сообщение не выдаётся для -Wno-unknown-warning, если не выдаются другие диагностические сообщения. Это позволяет использовать новые параметры -Wno- со старыми компиляторами, но если что-то пойдёт не так, компилятор предупредит о наличии неизвестного параметра.

Эффективность некоторых предупреждений зависит от того, также включены ли оптимизации. Например, -Wsuggest-final-types более эффективна с оптимизацией на этапе линковки, а некоторые примеры других предупреждений вообще не будут выдаваться, если оптимизация не включена. Хотя оптимизация в целом повышает эффективность предупреждений, связанных с контролем и потоком данных, в некоторых случаях она также может привести к ложным срабатываниям.

-Wpedantic

-pedantic

Выдавать все предупреждения, требуемые строгим стандартом ISO C и ISO C++; отклонять все программы, использующие запрещённые расширения, а также некоторые другие программы, не соответствующие ISO C и ISO C++. Для ISO C используется версия стандарта ISO C, указанная любым параметром -std.

Валидные программы ISO C и ISO C++ должны компилироваться корректно с этим параметром или без него (хотя редкие случаи требуют параметр -ansi или -std с указанием необходимой версии ISO C). Однако без этого параметра также поддерживаются некоторые расширения GNU и традиционные функции C и C++. С этим параметром они отклоняются.

-Wpedantic не вызывает предупреждения о использовании альтернативных ключевых слов, имена которых начинаются и заканчиваются символами ‘__’. Этот альтернативный формат также может использоваться для отключения предупреждений о не-ISO типах ‘__intN’, т.е. ‘__intN__’. Предупреждения pedantic также отключены в выражении, следующему за __extension__. Однако эти обходные пути должны использоваться только в системных заголовочных файлах; приложениям следует их избегать. См. Альтернативные ключевые слова.

Некоторые пользователи пытаются использовать -Wpedantic для проверки программ на соответствие строгому стандарту ISO C. Они быстро понимают, что это не совсем то, что они хотят: он находит некоторые не-ISO практики, но не все — только те, для которых ISO C требует диагностику, а также некоторые другие, для которых диагностика была добавлена.

Функция для отслеживания любых нарушений соответствия стандарту ISO C может быть полезной в некоторых случаях, но потребует значительной дополнительной работы и будет существенно отличаться от -Wpedantic. Мы не планируем поддерживать такую функцию в ближайшем будущем.

Если стандарт, указанный с помощью -std, представляет собой расширенный диалект GNU C, такой как ‘gnu90’ или ‘gnu99’, существует соответствующий базовый стандарт, версия ISO C, на которой основан расширенный диалект GNU. Предупреждения от -Wpedantic выдаются там, где они требуются базовым стандартом. (Не имеет смысла выдавать такие предупреждения только для функций, отсутствующих в указанном диалекте GNU C, поскольку по определению GNU диалекты C включают все функции, которые компилятор поддерживает с данным параметром, и не будет ничего, о чём предупреждать.)

-pedantic-errors

Выдавать ошибку всякий раз, когда базовый стандарт (см. -Wpedantic) требует диагностики, в некоторых случаях, когда возникает неопределённое поведение во время компиляции, и в некоторых других случаях, которые не препятствуют компиляции программ, которые являются допустимыми согласно стандарту. Это не эквивалентно -Werror=pedantic, поскольку есть ошибки, включённые этим параметром, но не включённые последним, и наоборот.

-Wall

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

-Wall включает следующие флаги предупреждений:

-Waddress
-Warray-bounds=1 (only with -O2)
-Warray-compare
-Warray-parameter=2 (C and Objective-C only)
-Wbool-compare
-Wbool-operation
-Wc++11-compat  -Wc++14-compat
-Wcatch-value (C++ and Objective-C++ only)
-Wchar-subscripts
-Wcomment
-Wdangling-pointer=2
-Wduplicate-decl-specifier (C and Objective-C only)
-Wenum-compare (in C/ObjC; this is on by default in C++)
-Wenum-int-mismatch (C and Objective-C only)
-Wformat
-Wformat-overflow
-Wformat-truncation
-Wint-in-bool-context
-Wimplicit (C and Objective-C only)
-Wimplicit-int (C and Objective-C only)
-Wimplicit-function-declaration (C and Objective-C only)
-Winit-self (only for C++)
-Wlogical-not-parentheses
-Wmain (only for C/ObjC and unless -ffreestanding)
-Wmaybe-uninitialized
-Wmemset-elt-size
-Wmemset-transposed-args
-Wmisleading-indentation (only for C/C++)
-Wmismatched-dealloc
-Wmismatched-new-delete (only for C/C++)
-Wmissing-attributes
-Wmissing-braces (only for C/ObjC)
-Wmultistatement-macros
-Wnarrowing (only for C++)
-Wnonnull
-Wnonnull-compare
-Wopenmp-simd
-Wparentheses
-Wpessimizing-move (only for C++)
-Wpointer-sign
-Wrange-loop-construct (only for C++)
-Wreorder
-Wrestrict
-Wreturn-type
-Wself-move (only for C++)
-Wsequence-point
-Wsign-compare (only in C++)
-Wsizeof-array-div
-Wsizeof-pointer-div
-Wsizeof-pointer-memaccess
-Wstrict-aliasing
-Wstrict-overflow=1
-Wswitch
-Wtautological-compare
-Wtrigraphs
-Wuninitialized
-Wunknown-pragmas
-Wunused-function
-Wunused-label
-Wunused-value
-Wunused-variable
-Wuse-after-free=2
-Wvla-parameter (C and Objective-C only)
-Wvolatile-register-var
-Wzero-length-bounds

Обратите внимание, что некоторые флаги предупреждений не подразумеваются -Wall. Некоторые из них предупреждают о конструкциях, которые пользователи, как правило, не считают сомнительными, но иногда вы можете захотеть проверить; другие предупреждают о конструкциях, которые в некоторых случаях необходимы или их трудно избежать, и нет простого способа изменить код, чтобы подавить предупреждение. Некоторые из них включены -Wextra, но многие из них нужно включать индивидуально.

-Wextra

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

-Wclobbered
-Wcast-function-type
-Wdangling-reference (C++ only)
-Wdeprecated-copy (C++ only)
-Wempty-body
-Wenum-conversion (C only)
-Wignored-qualifiers
-Wimplicit-fallthrough=3
-Wmissing-field-initializers
-Wmissing-parameter-type (C only)
-Wold-style-declaration (C only)
-Woverride-init
-Wsign-compare (C only)
-Wstring-compare
-Wredundant-move (only for C++)
-Wtype-limits
-Wuninitialized
-Wshift-negative-value (in C++11 to C++17 and in C99 and newer)
-Wunused-parameter (only with -Wunused or -Wall)
-Wunused-but-set-parameter (only with -Wunused or -Wall)

Параметр -Wextra также выводит сообщения о предупреждениях в следующих случаях:

Указатель сравнивается с целым нулём с <, <=, >, или >=.
(Только C++) Перечислитель и неперечислитель оба появляются в условном выражении.
(Только C++) Неоднозначные виртуальные базы.
(Только C++) Индексирование массива, который был объявлен register.
(Только C++) Получение адреса переменной, которая была объявлена register.
(Только C++) Базовый класс не инициализируется в конструкторе копирования производного класса.

-Wabi (C, Objective-C, C++ and Objective-C++ only)

Выдавать предупреждения о коде, который затронут изменениями ABI. Это включает код, который может быть несовместим с нейтральной относительно поставщика C++ ABI, а также с psABI для конкретной цели.

Поскольку G++ теперь по умолчанию обновляет ABI с каждым основным выпуском, обычно -Wabi выдает предупреждения только о проблемах совместимости C++ ABI, если позже в серии выпусков будет добавлена проверка на проблему ABI, обнаруженную после начального выпуска. -Wabi выдает предупреждения о большем количестве вещей, если выбрана более старая версия ABI (с помощью -fabi-version=n).

-Wabi также может использоваться с явным номером версии, чтобы предупреждать о совместимости C++ ABI с конкретным уровнем -fabi-version, например, -Wabi=2 для предупреждений об изменениях относительно -fabi-version=2.

Если явный номер версии указан, а -fabi-compat-version не указан, то номер версии из этого параметра используется для псевдонимов совместимости. Если явный номер версии не указан с этим параметром, но -fabi-compat-version указан, то этот номер версии используется для предупреждений о C++ ABI.

Хотя была предпринята попытка предупредить обо всех таких случаях, возможно, есть некоторые случаи, которые не предупреждают, даже если G++ генерирует несовместимый код. Также могут быть случаи, когда предупреждения генерируются, даже если сгенерированный код совместим.

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

Известные несовместимости в -fabi-version=2 (который был по умолчанию от GCC 3.4 до 4.9) включают:

Шаблон с параметром шаблона нетипа типа ссылки был закодирован неправильно:
```
extern int N;
template <int &> struct S {};
void n (S<N>) {2}
```
Это было исправлено в -fabi-version=3.
Типы векторов SIMD, объявленные с помощью __attribute ((vector_size)) , были закодированы нестандартным способом, что не позволяет перегружать функции, принимающие векторы разных размеров.
Кодировка была изменена в -fabi-version=4.
__attribute ((const)) и noreturn были закодированы как квалификаторы типа, а decltype обычного объявления было убрано.
Эти проблемы с кодировкой были исправлены в -fabi-version=5.
Перечислители с областью видимости, переданные в качестве аргументов в функцию с переменным числом аргументов, были повышены, как и перечислители без области видимости, что заставляет va_arg жаловаться. На большинстве целей это фактически не влияет на ABI передачи аргументов, так как нет способа передать аргумент, меньший, чем int.
Также ABI изменила кодировку пакетов аргументов шаблонов, const_cast, static_cast, префиксное увеличение/уменьшение, и функция области видимости класса, используемая в качестве аргумента шаблона.

Эти проблемы были исправлены в -fabi-version=6.
Lambda-выражения в области аргумента по умолчанию были закодированы неправильно, и ABI изменила кодировку nullptr_t.
Эти проблемы были исправлены в -fabi-version=7.
При кодировании типа функции с квалификаторами типа функции, неквалифицированный тип функции был неправильно обработан как кандидат подстановки.
Это было исправлено в -fabi-version=8, значение по умолчанию для GCC 5.1.
decltype(nullptr) неправильно имел выравнивание 1, что приводило к доступу без выравнивания. Обратите внимание, что это не повлияло на ABI функции с nullptr_t параметром, поскольку у параметров есть минимальное выравнивание.
Это было исправлено в -fabi-version=9, значение по умолчанию для GCC 5.2.
Атрибуты, специфичные для платформы, которые влияют на идентификатор типа, такие как конвенции вызова ia32 для типа функции (stdcall, regparm и т.д.), не влияли на закодированное имя, что приводило к коллизиям имен, когда указатели на функции использовались в качестве аргументов шаблонов.
Это было исправлено в -fabi-version=10, значение по умолчанию для GCC 6.1.

Этот параметр также включает предупреждения об изменениях, связанных с psABI. Известные изменения psABI на данный момент включают:

Для SysV/x86-64 объединения с long double членами передаются в памяти, как указано в psABI. До GCC 4.4 этого не было. Например:
```
union U {
  long double ld;
  int i;
};
```
union U теперь всегда передаётся в памяти.

-Wno-changes-meaning (C++ and Objective-C++ only)

C++ требует, чтобы неквалифицированные использования имени в классе имели одинаковый смысл в полном объёме класса, поэтому объявление имени после его использования некорректно:

struct A;
struct B1 { A a; typedef A A; }; // warning, 'A' changes meaning
struct B2 { A a; struct A { }; }; // error, 'A' changes meaning

По умолчанию случай B1 является только предупреждением, потому что два объявления имеют одинаковый тип, в то время как случай B2 является ошибкой. Обе диагностики могут быть отключены с помощью -Wno-changes-meaning. В качестве альтернативы, случай ошибки может быть уменьшен до предупреждения с помощью -Wno-error=changes-meaning или -fpermissive.

Обе диагностики также подавляются -fms-extensions.

-Wchar-subscripts

Предупреждать, если индекс массива имеет тип char. Это частая причина ошибок, так как программисты часто забывают, что этот тип на некоторых машинах со знаком. Это предупреждение включено параметром -Wall.

-Wno-coverage-mismatch

Предупреждение, если профили обратной связи не совпадают при использовании опции -fprofile-use. Если исходный файл изменен между компиляцией с -fprofile-generate и -fprofile-use, файлы с профильной обратной связью могут не совпадать с исходным файлом, и GCC не сможет использовать информацию о профильной обратной связи. По умолчанию это предупреждение включено и обрабатывается как ошибка. -Wno-coverage-mismatch можно использовать для отключения предупреждения, или -Wno-error=coverage-mismatch для отключения ошибки. Отключение ошибки для этого предупреждения может привести к плохо оптимизированному коду и полезно только в случае очень незначительных изменений, таких как исправление ошибок в существующей кодовой базе. Полностью отключать предупреждение не рекомендуется.

-Wno-coverage-invalid-line-number

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

По умолчанию это предупреждение включено и обрабатывается как ошибка. -Wno-coverage-invalid-line-number можно использовать для отключения предупреждения, или -Wno-error=coverage-invalid-line-number для отключения ошибки.

-Wno-cpp (C, Objective-C, C++, Objective-C++ and Fortran only)

Подавление сообщений о предупреждениях, выводимых директивами #warning.

-Wdouble-promotion (C, C++, Objective-C and Objective-C++ only)

Выдать предупреждение, если значение типа float неявно повышается до double. ЦП с 32-битным "однозначным" плавающим пунктом реализуют float в аппаратном обеспечении, но эмулируют double в программном обеспечении. На такой машине вычисления с использованием значений double намного дороже из-за накладных расходов, необходимых для эмуляции в программном обеспечении.

Легко случайно выполнить вычисления с double, потому что числовые литералы с плавающей точкой неявно имеют тип double. Например, в:

float area(float radius)
{
   return 3.14159 * radius * radius;
}

компилятор выполняет все вычисления со значением double, так как числовой литерал с плавающей точкой имеет тип double.

-Wduplicate-decl-specifier (C and Objective-C only)

Предупреждение, если в объявлении есть дублирующие спецификаторы const, volatile, restrict или _Atomic. Это предупреждение включается опцией -Wall.

-Wformat

-Wformat=n

Проверка вызовов printf и scanf, и т.д., чтобы убедиться, что предоставленные аргументы имеют типы, соответствующие указанной строке формата, и что преобразования, указанные в строке формата, имеют смысл. Это включает стандартные функции и другие функции, определенные атрибутами формата (см. Определение атрибутов функций), в семействах printf, scanf, strftime и strfmon (расширение X/Open, отсутствующее в стандартном C) (или других семействах, специфичных для целевой системы). Какие функции проверяются без указания атрибутов формата зависит от выбранной версии стандарта, и такие проверки функций без указанного атрибута отключаются опциями -ffreestanding или -fno-builtin.

Форматы проверяются в соответствии с функциями формата, поддерживаемыми версией GNU libc 2.2. Это включает все функции ISO C90 и C99, а также функции из Single Unix Specification и некоторые расширения BSD и GNU. Другие реализации библиотек могут не поддерживать все эти функции; GCC не поддерживает предупреждения о функциях, выходящих за рамки ограничений конкретной библиотеки. Однако, если используется -Wpedantic с -Wformat, выдаются предупреждения о функциях формата, отсутствующих в выбранной версии стандарта (но не для форматов strfmon, так как они не входят в ни одну из версий стандарта C). См. Параметры, контролирующие диалект C.

-Wformat=1
-Wformat: Опция -Wformat эквивалентна -Wformat=1, а -Wno-format эквивалентна -Wformat=0. Поскольку -Wformat также проверяет аргументы формата null для нескольких функций, -Wformat также подразумевает -Wnonnull. Некоторые аспекты этого уровня проверки формата можно отключить с помощью опций: -Wno-format-contains-nul, -Wno-format-extra-args и -Wno-format-zero-length. -Wformat включена опцией -Wall.
-Wformat=2: Включение -Wformat плюс дополнительные проверки формата. В настоящее время эквивалентно -Wformat -Wformat-nonliteral -Wformat-security -Wformat-y2k.

-Wno-format-contains-nul

Если указана -Wformat, не выдавать предупреждений о строках формата, содержащих байты NUL.

-Wno-format-extra-args

Если указана -Wformat, не выдавать предупреждений о дополнительных аргументах для функции формата printf или scanf. Стандарт C определяет, что такие аргументы игнорируются.

Если неиспользуемые аргументы находятся между используемыми аргументами, указанными с помощью спецификаций номера операнда ‘$’, обычно все равно выдаются предупреждения, поскольку реализация не могла знать, какой тип передать va_arg для пропуска неиспользуемых аргументов. Однако в случае форматов scanf эта опция подавляет предупреждение, если все неиспользуемые аргументы являются указателями, так как Single Unix Specification говорит, что такие неиспользуемые аргументы разрешены.

-Wformat-overflow

-Wformat-overflow=level

Предупреждение о вызовах функций форматированного ввода/вывода, таких как sprintf и vsprintf, которые могут переполнить буфер назначения. Когда точное количество байтов, записанных директивой формата, не может быть определено во время компиляции, оно оценивается на основе эвристических правил, зависящих от аргумента level и от оптимизации. Хотя включение оптимизации в большинстве случаев повысит точность предупреждения, это также может привести к ложным срабатываниям.

-Wformat-overflow

-Wformat-overflow=1

Уровень 1 -Wformat-overflow, включенный с -Wformat, использует консервативный подход, который предупреждает только о вызовах, которые, скорее всего, приведут к переполнению буфера. На этом уровне числовые аргументы директивам формата с неизвестными значениями предполагаются равными единице, а строки неизвестной длины - пустыми. Числовые аргументы, известные как ограниченные поддиапазоном своего типа или строковые аргументы, чьи выходные данные ограничены либо точностью их директивы, либо конечным набором строковых литералов, предполагаются принимающими значение в пределах диапазона, что приводит к наибольшему количеству байтов на выходе. Например, вызов sprintf диагностируется, потому что даже если a и b равны нулю, завершающий символ NUL ('\0') прикрепляемый функцией к буферу назначения, будет записан за его пределами. Увеличение размера буфера на один байт достаточно для предотвращения предупреждения, хотя это может быть недостаточно для предотвращения переполнения.

void f (int a, int b)
{
  char buf [13];
  sprintf (buf, "a = %i, b = %i\n", a, b);
}

-Wformat-overflow=2

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

На уровне 2, вызов в приведенном выше примере снова диагностируется, но на этот раз потому, что с a равным 32-битному INT_MIN, первая директива %i запишет некоторые из своих цифр за пределами буфера назначения. Чтобы сделать вызов безопасным независимо от значений двух переменных, размер буфера назначения должен быть увеличен по крайней мере до 34 байтов. GCC включает минимальный размер буфера в информационной заметке после предупреждения.

Альтернативой увеличению размера буфера назначения является ограничение диапазона форматируемых значений. Максимальная длина строковых аргументов может быть ограничена путем указания точности в директиве формата. Если числовые аргументы директивы формата могут быть предположительно ограничены значениями меньше точности их типа, выбор соответствующего модификатора длины для спецификатора формата уменьшит требуемый размер буфера. Например, если a и b в приведенном выше примере могут быть предположительно ограничены точностью типа short int, то использование директивы формата %hi или приведение аргумента к типу short уменьшает максимальный требуемый размер буфера до 24 байтов.

void f (int a, int b)
{
  char buf [23];
  sprintf (buf, "a = %hi, b = %i\n", a, (short)b);
}

-Wno-format-zero-length

Если указана -Wformat, не выдавать предупреждения о форматах нулевой длины. Стандарт C допускает форматы нулевой длины.

-Wformat-nonliteral

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

-Wformat-security

Если указана -Wformat, также предупреждать об использовании функций формата, представляющих потенциальные проблемы безопасности. В настоящее время это предупреждает о вызовах функций printf и scanf, где строка формата не является строковым литералом и нет аргументов формата, как в printf (foo);. Это может быть уязвимость безопасности, если строка формата получена из ненадежного ввода и содержит ‘%n’. (В настоящее время это подмножество того, о чем предупреждает -Wformat-nonliteral, но в будущем могут быть добавлены предупреждения в -Wformat-security, которых нет в -Wformat-nonliteral.)

-Wformat-signedness

Если указан -Wformat, то также выдается предупреждение, если строка формата требует беззнакового аргумента, а аргумент — знаковый, и наоборот.

-Wformat-truncation

-Wformat-truncation=level

Выдавать предупреждения о вызовах функций форматированного ввода/вывода, таких как snprintf и vsnprintf, которые могут привести к усечению вывода. Когда точное количество байтов, записанных директивой формата, нельзя определить на этапе компиляции, оно оценивается на основе эвристик, которые зависят от аргумента level и от оптимизации. Хотя включение оптимизации в большинстве случаев улучшит точность предупреждения, оно также может привести к ложным срабатываниям. За исключением случаев, указанных отдельно, используется та же логика, что и у опции -Wformat-overflow.

-Wformat-truncation
-Wformat-truncation=1: Уровень 1 опции -Wformat-truncation, включённой с помощью -Wformat, использует консервативный подход, который предупреждает только о вызовах ограниченных функций, значение возврата которых не используется и которые, скорее всего, приведут к усечению вывода.
-Wformat-truncation=2: Уровень 2 также предупреждает о вызовах ограниченных функций, значение возврата которых используется, и которые могут привести к усечению с учётом аргумента достаточной длины или величины.

-Wformat-y2k

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

-Wnonnull

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

Опция -Wnonnull включена в -Wall и -Wformat. Её можно отключить с помощью опции -Wno-nonnull.

-Wnonnull-compare

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

Опция -Wnonnull-compare включена в -Wall. Её можно отключить с помощью опции -Wno-nonnull-compare.

-Wnull-dereference

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

-Winfinite-recursion

Предупреждать об бесконечно рекурсивных вызовах. Предупреждение эффективно на всех уровнях оптимизации, но требует оптимизации для обнаружения бесконечной рекурсии в вызовах между двумя или более функциями. -Winfinite-recursion включена в -Wall.

Сравните с -Wanalyzer-infinite-recursion, которая предоставляет аналогичную диагностику, но реализована другим способом (как часть -fanalyzer).

-Winit-self (C, C++, Objective-C and Objective-C++ only)

Предупреждать об неинициализированных переменных, которые инициализируются самими собой. Обратите внимание, что эта опция может быть использована только с опцией -Wuninitialized.

Например, GCC предупреждает о том, что i не инициализировано в следующем фрагменте кода только при указании -Winit-self:

int f()
{
  int i = i;
  return i;
}

Это предупреждение включено -Wall в C++.

-Wno-implicit-int (C and Objective-C only)

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

-Wno-implicit-function-declaration (C and Objective-C only)

Данная опция управляет предупреждениями, когда функция используется до её объявления. Это предупреждение включено по умолчанию в C99 и более поздних диалектах C, а также с помощью -Wall. Предупреждение преобразуется в ошибку с помощью -pedantic-errors.

-Wimplicit (C and Objective-C only)

То же самое, что и -Wimplicit-int и -Wimplicit-function-declaration. Это предупреждение включено с -Wall.

-Wimplicit-fallthrough

-Wimplicit-fallthrough то же самое, что и -Wimplicit-fallthrough=3, а -Wno-implicit-fallthrough то же самое, что и -Wimplicit-fallthrough=0.

-Wimplicit-fallthrough=n

Выдавать предупреждение, когда случай в операторе switch пропускается. Например:

switch (cond)
  {
  case 1:
    a = 1;
    break;
  case 2:
    a = 2;
  case 3:
    a = 3;
    break;
  }

Это предупреждение не выдаётся, когда последний оператор в случае не может быть пропущен, например, когда есть оператор return или вызов функции, объявленной с атрибутом noreturn. -Wimplicit-fallthrough= также учитывает операторы управления потоком, такие как if, и предупреждает только при необходимости. Например:

switch (cond)
  {
  case 1:
    if (i > 3) {
      bar (5);
      break;
    } else if (i < 1) {
      bar (0);
    } else
      return;
  default:
    …
  }

Поскольку в некоторых случаях пропуск случая в операторе switch желателен, GCC предоставляет атрибут __attribute__ ((fallthrough)), который необходимо использовать вместе с пустым оператором для подавления этого предупреждения, которое обычно возникает:

switch (cond)
  {
  case 1:
    bar (0);
    __attribute__ ((fallthrough));
  default:
    …
  }

C++17 предоставляет стандартный способ подавления предупреждения -Wimplicit-fallthrough с помощью [[fallthrough]]; вместо атрибута GNU. В C++11 или C++14 пользователи могут использовать [[gnu::fallthrough]];, что является расширением GNU. Вместо этих атрибутов также можно добавить комментарий fallthrough для подавления предупреждения. Весь текст комментария стиля C или C++ должен соответствовать приведенным ниже регулярным выражениям. Аргумент опции n указывает, какие комментарии принимаются:

-Wimplicit-fallthrough=0 полностью отключает предупреждение.
-Wimplicit-fallthrough=1 соответствует регулярному выражению .*, любой комментарий используется как комментарий fallthrough.
-Wimplicit-fallthrough=2 без учёта регистра соответствует регулярному выражению .*falls?[ \t-]*thr(ough|u).*.
-Wimplicit-fallthrough=3 чувствительно к регистру и соответствует одному из следующих регулярных выражений:
- -fallthrough
- @fallthrough@
- lint -fallthrough[ \t]*
- [ \t.!]*(ELSE,? |INTENTIONAL(LY)? )?FALL(S | |-)?THR(OUGH|U)[ \t.!]*(-[^\n\r]*)?
- [ \t.!]*(Else,? |Intentional(ly)? )?Fall((s | |-)[Tt]|t)hr(ough|u)[ \t.!]*(-[^\n\r]*)?
- [ \t.!]*([Ee]lse,? |[Ii]ntentional(ly)? )?fall(s | |-)?thr(ough|u)[ \t.!]*(-[^\n\r]*)?
-Wimplicit-fallthrough=4 чувствительно к регистру и соответствует одному из следующих регулярных выражений:
- -fallthrough
- @fallthrough@
- lint -fallthrough[ \t]*
- [ \t]*FALLTHR(OUGH|U)[ \t]*
-Wimplicit-fallthrough=5 не распознаёт комментарии как комментарии fallthrough, только атрибуты отключают предупреждение.

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

switch (cond)
  {
  case 1:
    bar (0);
    /* FALLTHRU */
  default:
    …
  }

Предупреждение -Wimplicit-fallthrough=3 включено с -Wextra.

-Wno-if-not-aligned (C, C++, Objective-C and Objective-C++ only)

Управлять тем, должны ли выдаваться предупреждения, которые вызываются атрибутом warn_if_not_aligned. Эти предупреждения включены по умолчанию.

-Wignored-qualifiers (C and C++ only)

Предупреждать, если возвращаемый тип функции имеет квалификатор типа, такой как const. Для ISO C такой квалификатор не имеет эффекта, так как возвращаемое значение функции не является lvalue. Для C++ предупреждение выдаётся только для скалярных типов или void. ISO C запрещает квалифицированные void возвращаемые типы в определениях функций, поэтому такие типы всегда получают предупреждение даже без этой опции.

Это предупреждение также включено с -Wextra.

-Wno-ignored-attributes (C and C++ only)

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

-Wmain

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

Это предупреждение включено по умолчанию в C++ и включено либо с -Wall, либо с -Wpedantic.

-Wmisleading-indentation (C and C++ only)

Предупреждать, если отступы кода не отражают структуру блока. Конкретно, выдается предупреждение для if, else, while, и for с защищенным оператором, который не использует фигурные скобки, за которым следует незащищенный оператор с тем же отступом.

В приведенном ниже примере вызов «bar» вводяще в заблуждение отступом, как будто он был защищен условным оператором «if».

if (some_condition ())
  foo ();
  bar ();  /* Gotcha: this is not guarded by the "if".  */

В случае смешанного использования табуляции и пробелов, предупреждение использует опцию -ftabstop= для определения выравнивания операторов (по умолчанию 8).

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

if (flagA)
    foo (0);
#if SOME_CONDITION_THAT_DOES_NOT_HOLD
  if (flagB)
#endif
    foo (1);

Предупреждение не выдается после директивы #line, так как это обычно указывает на сгенерированный код, и о расположении файла, на который ссылается директива, нельзя делать никаких предположений.

Это предупреждение включено с -Wall в C и C++.

-Wmissing-attributes

Предупреждать, если объявление функции отсутствует один или несколько атрибутов, которыми объявлена связанная функция, и отсутствие которых может негативно повлиять на корректность или эффективность сгенерированного кода. Например, предупреждение выдаётся для объявлений псевдонимов, которые используют атрибуты для указания менее строгих требований, чем у их целевых функций. Это обычно представляет собой потенциальную возможность оптимизации. В отличие от этого, опция -Wattribute-alias=2 управляет предупреждениями, выдаваемыми, когда псевдоним более строгий, чем целевой, что может привести к неверному генерированию кода. Рассматриваемые атрибуты включают alloc_align, alloc_size, cold, const, hot, leaf, malloc, nonnull, noreturn, nothrow, pure, returns_nonnull, и returns_twice.

В C++, предупреждение выдаётся, когда явная специализация первичного шаблона, объявленного с атрибутами alloc_align, alloc_size, assume_aligned, format, format_arg, malloc, или nonnull, объявлена без него. Атрибуты deprecated, error, и warning подавляют предупреждение. (см. Объявление атрибутов функций).

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

-Wmissing-attributes включён опцией -Wall.

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

template <class T>
T* __attribute__ ((malloc, alloc_size (1)))
allocate (size_t);

template <>
void* __attribute__ ((malloc))   // missing alloc_size
allocate<void> (size_t);

-Wmissing-braces

Предупреждать, если инициализатор агрегата или объединения не заключён в полные скобки. В следующем примере инициализатор для a не заключён в полные скобки, а инициализатор для b заключён в полные скобки.

int a[2][2] = { 0, 1, 2, 3 };
int b[2][2] = { { 0, 1 }, { 2, 3 } };

Это предупреждение включено опцией -Wall.

-Wmissing-include-dirs (C, C++, Objective-C, Objective-C++ and Fortran only)

Предупреждать, если пользовательский каталог включения не существует. Эта опция по умолчанию отключена для C, C++, Objective-C и Objective-C++. Для Fortran она частично включена по умолчанию, предупреждая только для -I и -J.

-Wno-missing-profile

Эта опция управляет предупреждениями, если отсутствуют профили отзывов при использовании опции -fprofile-use. Эта опция диагностирует случаи, когда новая функция или новый файл добавлены между компиляцией с -fprofile-generate и -fprofile-use без перегенерации профилей. В этих случаях файлы профилей обратной связи не содержат никакой информации о профиле обратной связи для новой функции или файла соответственно. Также, если файлы данных о количестве профилей (.gcda) удалены, GCC не может использовать информацию о профилях обратной связи. Во всех этих случаях выдаётся предупреждение, чтобы сообщить вам, что требуется этап генерации профиля. Игнорирование предупреждения может привести к плохо оптимизированному коду. -Wno-missing-profile может быть использован для отключения предупреждения, но это не рекомендуется и должно делаться только тогда, когда отсутствующие данные профиля оправданы.

-Wmismatched-dealloc

Предупреждать о вызовах функций освобождения с указателями-аргументами, возвращаемыми из функций выделения, для которых предыдущие не являются подходящим освободителем. Пара функций может быть связана как соответствующие функции выделения и освобождения с помощью атрибута malloc. Если не отключено опцией -fno-builtin, стандартные функции calloc, malloc, realloc, и free, а также соответствующие формы C++ operator new и operator delete неявно связаны как соответствующие функции выделения и освобождения. В следующем примере mydealloc является освободителем для указателей, возвращённых из myalloc.

void mydealloc (void*);

__attribute__ ((malloc (mydealloc, 1))) void*
myalloc (size_t);

void f (void)
{
  void *p = myalloc (32);
  // …use p…
  free (p);   // warning: not a matching deallocator for myalloc
  mydealloc (p);   // ok
}

В C++, связанная опция -Wmismatched-new-delete диагностирует несоответствия, связанные с operator new или operator delete.

Опция -Wmismatched-dealloc включена в -Wall.

-Wmultistatement-macros

Предупреждать о небезопасных макросах с несколькими операторами, которые, похоже, защищены клаузой, такой как if, else, for, switch, или while, в которой после раскрытия макроса фактически защищён только первый оператор.

Например:

#define DOIT x++; y++
if (c)
  DOIT;

будет увеличивать y безусловно, а не только тогда, когда c истинно. Это обычно можно исправить, обернув макрос в цикл do-while:

#define DOIT do { x++; y++; } while (0)
if (c)
  DOIT;

Это предупреждение включено опцией -Wall в C и C++.

-Wparentheses

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

Также предупреждать, если появляется сравнение, такое как x<=y<=z; это эквивалентно (x<=y ? 1 : 0) <= z, что является другим толкованием, чем в обычной математической нотации.

Также предупреждать о небезопасном использовании расширения GNU для ?: с опущенным средним операндом. Когда условие в операторе ? является булевым выражением, опущенное значение всегда равно 1. Часто программисты ожидают, что оно будет вычислено внутри условного выражения вместо этого.

Для C++ это также предупреждает о некоторых случаях ненужных скобок в объявлениях, что может указывать на попытку вызова функции вместо объявления:

{
  // Declares a local variable called mymutex.
  std::unique_lock<std::mutex> (mymutex);
  // User meant std::unique_lock<std::mutex> lock (mymutex);
}

Это предупреждение включено опцией -Wall.

-Wno-self-move (C++ and Objective-C++ only)

Это предупреждение выдаётся, когда значение перемещается в себя с помощью std::move. Такое std::move обычно не имеет эффекта.

struct T {
…
};
void fn()
{
  T t;
  …
  t = std::move (t);
}

Это предупреждение включено опцией -Wall.

-Wsequence-point

Предупреждать о коде, который может иметь неопределённую семантику из-за нарушений правил точек последовательности в стандартах C и C++.

Стандарты C и C++ определяют порядок вычисления выражений в программе C/C++ в терминах точек последовательности, которые представляют собой частичный порядок между выполнением частей программы: те, которые выполняются до точки последовательности, и те, которые выполняются после неё. Они происходят после вычисления полного выражения (которое не является частью большего выражения), после вычисления первого операнда оператора &&, ||, ? : или , (запятой), перед вызовом функции (но после вычисления её аргументов и выражения, обозначающего вызываемую функцию), и в некоторых других местах. Кроме как в выражении правил точки последовательности, порядок вычисления подвыражений выражения не указан. Все эти правила описывают только частичный порядок, а не общий порядок, так как, например, если две функции вызываются в одном выражении без точки последовательности между ними, порядок, в котором вызываются функции, не определён. Однако комитет стандартов постановил, что вызовы функций не перекрываются.

Не определено, когда между точками последовательности вступают в силу изменения значений объектов. Программы, поведение которых зависит от этого, имеют неопределённое поведение; стандарты C и C++ указывают, что «Между предыдущей и следующей точкой последовательности объект должен иметь своё хранимое значение, изменённое не более одного раза вычислением выражения. Кроме того, предыдущее значение должно читаться только для определения хранимого значения». Если программа нарушает эти правила, результаты на любой конкретной реализации полностью непредсказуемы.

Примеры кода с неопределённым поведением — a = a++;, a[n] = b[n++] и a[i++] = i;. Некоторые более сложные случаи не диагностируются этой опцией, и она может давать иногда ложноположительные результаты, но в целом она оказалась довольно эффективной при обнаружении этого типа проблем в программах.

Стандарт C++17 определит порядок вычисления операндов в большем числе случаев: в частности, он требует, чтобы правая часть присваивания вычислялась до левой, поэтому вышеупомянутые примеры больше не являются неопределёнными. Но эта опция всё ещё будет предупреждать о них, чтобы помочь людям избегать написания кода, который неопределён в C и более ранних версиях C++.

Стандарт сформулирован запутанно, поэтому существует некоторое обсуждение точного значения правил точек последовательности в тонких случаях. Ссылки на обсуждения проблемы, включая предлагаемые формальные определения, можно найти на странице чтения GCC, по адресу https://gcc.gnu.org/readings.html.

Это предупреждение включено опцией -Wall для C и C++.

-Wno-return-local-addr

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

-Wreturn-type

Выводить предупреждение всякий раз, когда функция определена с типом возвращаемого значения, который по умолчанию равен int. Также выводить предупреждение об операторе return без значения возврата в функции, тип возврата которой не void (выход за пределы тела функции считается возвратом без значения).

Только для C, выводить предупреждение об операторе return с выражением в функции, тип возврата которой void, если тип выражения также не void. В качестве расширения GNU, в последнем случае предупреждение не выдается, если не используется -Wpedantic. Попытка использовать значение возврата функции, не являющейся void функцией, отличной от main, выходящей за пределы тела функции до закрывающей фигурной скобки, является неопределенным поведением.

В отличие от C, в C++, выход за пределы тела функции, не являющейся void функцией, отличной от main, приводит к неопределённому поведению, даже если значение функции не используется.

Это предупреждение включено по умолчанию в C++ и с помощью -Wall в противном случае.

-Wno-shift-count-negative

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

-Wno-shift-count-overflow

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

-Wshift-negative-value

Выводить предупреждение, если отрицательное значение сдвигается влево. Это предупреждение включено с помощью -Wextra в режимах C99 (и более поздних) и C++11-C++17.

-Wno-shift-overflow

-Wshift-overflow=n

Эти параметры управляют предупреждениями о переполнении при сдвиге влево.

-Wshift-overflow=1: Это уровень предупреждения -Wshift-overflow и включено по умолчанию в режимах C99 и C++11 (и более поздних). Этот уровень предупреждения не выдает предупреждение о сдвиге 1 в разряд знака. (Однако в C такое переполнение все еще отклоняется в контекстах, где требуется целочисленное константное выражение). Предупреждение не выдается в режиме C++20 (и более поздних), так как сдвиги влево со знаком всегда обнуляются.
-Wshift-overflow=2: Этот уровень предупреждения также предупреждает о сдвиге 1 в разряд знака, если не активен режим C++14 (или более поздние).

-Wswitch

Выводить предупреждение всякий раз, когда оператор switch имеет индекс перечислимого типа и не имеет case для одного или нескольких именованных кодов этого перечисления. (Наличие метки default предотвращает это предупреждение). Метки case вне диапазона перечисления также вызывают предупреждения при использовании этого параметра (даже если существует метка default). Это предупреждение включено с -Wall.

-Wswitch-default

Выводить предупреждение всякий раз, когда оператор switch не имеет ветви default.

-Wswitch-enum

Выводить предупреждение всякий раз, когда оператор switch имеет индекс перечислимого типа и не имеет case для одного или нескольких именованных кодов этого перечисления. Метки case вне диапазона перечисления также вызывают предупреждения при использовании этого параметра. Единственное различие между -Wswitch и этим параметром заключается в том, что этот параметр выдает предупреждение об опущенном коде перечисления, даже если существует метка default.

-Wno-switch-bool

Не выводить предупреждение, когда оператор switch имеет индекс типа boolean, а значения ветвей лежат вне диапазона типа boolean. Возможно подавить это предупреждение, применив приведение типа к типу, отличном от bool. Например:

switch ((int) (a == 4))
  {
  …
  }

Это предупреждение включено по умолчанию для программ на C и C++.

-Wno-switch-outside-range

Этот параметр управляет предупреждениями, когда ветвь switch имеет значение, выходящее за пределы диапазона соответствующего типа. Это предупреждение включено по умолчанию для программ на C и C++.

-Wno-switch-unreachable

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

switch (cond)
  {
   i = 15;
  …
   case 5:
  …
  }

-Wswitch-unreachable не выдает предупреждение, если оператор между выражением управления и первой меткой ветви просто объявление:

switch (cond)
  {
   int i;
  …
   case 5:
   i = 5;
  …
  }

Это предупреждение включено по умолчанию для программ на C и C++.

-Wsync-nand (C and C++ only)

Выводить предупреждение при использовании встроенных функций __sync_fetch_and_nand и __sync_nand_and_fetch. Эти функции изменили семантику в GCC 4.4.

-Wtrivial-auto-var-init

Выводить предупреждение, когда -ftrivial-auto-var-init не может инициализировать автоматическую переменную. Типичный случай — автоматическая переменная, объявленная между выражением управления и первой меткой ветви оператора switch.

-Wunused-but-set-parameter

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

Чтобы подавить это предупреждение, используйте атрибут unused (см. Указание атрибутов переменных).

Это предупреждение также включено с -Wunused вместе с -Wextra.

-Wunused-but-set-variable

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

Чтобы подавить это предупреждение, используйте атрибут unused (см. Указание атрибутов переменных).

Это предупреждение также включено с -Wunused, которое включено с -Wall.

-Wunused-function

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

-Wunused-label

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

Чтобы подавить это предупреждение, используйте атрибут unused (см. Указание атрибутов переменных).

-Wunused-local-typedefs (C, Objective-C, C++ and Objective-C++ only)

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

-Wunused-parameter

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

Чтобы подавить это предупреждение, используйте атрибут unused (см. Указание атрибутов переменных).

-Wno-unused-result

Не выводить предупреждение, если вызывающая функция, помеченная атрибутом warn_unused_result (см. Объявление атрибутов функций), не использует её значение возврата. Значение по умолчанию — -Wunused-result.

-Wunused-variable

Выводить предупреждение всякий раз, когда локальная или статическая переменная не используется, кроме её объявления. Этот параметр подразумевает -Wunused-const-variable=1 для C, но не для C++. Это предупреждение включено с -Wall.

Чтобы подавить это предупреждение, используйте атрибут unused (см. Указание атрибутов переменных).

-Wunused-const-variable

-Wunused-const-variable=n

Выводить предупреждение всякий раз, когда константа static переменная не используется, кроме её объявления. -Wunused-const-variable=1 включено с -Wunused-variable для C, но не для C++. В C это объявляет хранилище переменной, но в C++ это не ошибка, так как константные переменные занимают место #define.

Чтобы подавить это предупреждение, используйте атрибут unused (см. Указание атрибутов переменных).

-Wunused-const-variable=1: Это уровень предупреждения, который включён с -Wunused-variable для C. Он выводит предупреждения только об неиспользуемых статических константных переменных, определённых в основном модуле компиляции, но не о статических константных переменных, объявленных в включённых заголовках.
-Wunused-const-variable=2: Этот уровень предупреждения также выводит предупреждения о неиспользуемых константных статических переменных в заголовках (исключая системные заголовки). Это уровень предупреждения -Wunused-const-variable и должен быть явно запрошен, так как в C++ это не ошибка, а в C это может быть сложнее исправить во всех включённых заголовках.

-Wunused-value

Выводить предупреждение всякий раз, когда оператор вычисляет результат, который явно не используется. Чтобы подавить это предупреждение, выполните приведение типа к типу void. Это включает в себя оператор выражения или левую часть оператора запятой, не содержащую побочных эффектов. Например, выражение x[i,j] вызывает предупреждение, в то время как x[(void)i,j] - нет.

Это предупреждение включено с -Wall.

-Wunused

Все вышеуказанные параметры -Wunused объединены.

Чтобы получить предупреждение о неиспользуемом параметре функции, необходимо указать либо -Wextra -Wunused (обратите внимание, что -Wall подразумевает -Wunused), либо отдельно указать -Wunused-parameter.

-Wuninitialized

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

Кроме того, передача указателя (или, в C++, ссылки) на неинициализированный объект в const-квалифицированный аргумент встроенной функции, известной чтением объекта, также диагностируется этим предупреждением. (-Wmaybe-uninitialized выдаётся для обычных функций.)

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

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

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

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

struct A {
  int a;
  int b;
  A() : a(b) { }
};

-Wno-invalid-memory-model

Эта опция управляет предупреждениями об вызовах Встроенных функций для моделей памяти, учитывающих атомарные операции, Зарезервированные __sync встроенные функции для атомарного доступа к памяти и общих атомарных функциях C11 с аргументом согласованности памяти, который либо недействителен для операции, либо выходит за пределы диапазона значений перечисления memory_order. Например, поскольку встроенные функции __atomic_store и __atomic_store_n определены только для расслабленных, выпусков и последовательно согласованных порядков памяти, следующий код диагностируется:

void store (int *i)
{
  __atomic_store_n (i, 0, memory_order_consume);
}

-Winvalid-memory-model включена по умолчанию.

-Wmaybe-uninitialized

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

Кроме того, передача указателя (или, в C++, ссылки) на неинициализированный объект в const-квалифицированный аргумент функции также диагностируется этим предупреждением. (-Wuninitialized выдаётся для встроенных функций, известных чтению объекта.) Аннотирование функции атрибутом access (none) указывает, что аргумент не используется для доступа к объекту и избегает предупреждения (см. Общие атрибуты функций).

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

Эти предупреждения сделаны необязательными, потому что GCC может не определить, когда код корректен, несмотря на то, что кажется ошибочным. Вот один пример, как это может произойти:

{
  int x;
  switch (y)
    {
    case 1: x = 1;
      break;
    case 2: x = 4;
      break;
    case 3: x = 5;
    }
  foo (x);
}

Если значение y всегда 1, 2 или 3, тогда x всегда инициализируется, но GCC этого не знает. Чтобы подавить предупреждение, необходимо предоставить ветвь по умолчанию с assert(0) или аналогичным кодом.

Эта опция также предупреждает, когда не-постоянная автоматическая переменная может быть изменена вызовом longjmp. Компилятор видит только вызовы к setjmp. Он не может знать, где longjmp будет вызван; фактически обработчик сигналов может вызвать его в любой точке кода. В результате вы можете получить предупреждение, даже если на самом деле нет проблемы, потому что longjmp не может фактически быть вызван в месте, которое привело бы к проблеме.

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

Это предупреждение включено -Wall или -Wextra.

-Wunknown-pragmas

Предупреждать, когда встречается #pragma директива, которая не понимается GCC. Если используется эта опция командной строки, предупреждения будут выдаваться даже для неизвестных псевдокоманд в заголовочных файлах системы. Это не так, если предупреждения включены только опцией командной строки -Wall.

-Wno-pragmas

Не предупреждать об ошибках использования псевдокоманд, таких как неправильные параметры, недопустимый синтаксис или конфликты между псевдокомандами. См. также -Wunknown-pragmas.

-Wno-prio-ctor-dtor

Не выдавать предупреждение, если приоритет от 0 до 100 используется для конструктора или деструктора. Использование атрибутов конструктора и деструктора позволяет назначить приоритет конструктору/деструктору для управления порядком его выполнения до main или после его возвращения. Значения приоритета должны быть больше 100, так как компилятор зарезервировал значения приоритетов от 0 до 100 для реализации.

-Wstrict-aliasing

Эта опция активна только когда -fstrict-aliasing активна. Она предупреждает о коде, который может нарушить строгие правила алиасинга, используемые компилятором для оптимизации. Предупреждение не ловит все случаи, но пытается поймать наиболее распространённые ловушки. Оно включено в -Wall. Оно эквивалентно -Wstrict-aliasing=3

-Wstrict-aliasing=n

Эта опция активна только при -fstrict-aliasing. Она предупреждает о коде, который может нарушить правила строгого алиасинга, используемые компилятором для оптимизации. Более высокие уровни соответствуют большей точности (меньше ложных срабатываний). Более высокие уровни также означают большие затраты, аналогично тому, как работает -O. -Wstrict-aliasing эквивалентно -Wstrict-aliasing=3.

Уровень 1: Самый агрессивный, быстрый, наименее точный. Возможно полезен, когда более высокие уровни не предупреждают, но -fstrict-aliasing всё ещё ломает код, так как у него очень мало ложных отрицаний. Однако у него много ложных срабатываний. Предупреждает при всех преобразованиях указателей между потенциально несовместимыми типами, даже если никогда не разыменовываются. Работает только на стадии front-end.

Уровень 2: Агрессивный, быстрый, не слишком точный. Может по-прежнему иметь много ложных срабатываний (хотя не так много, как уровень 1), и мало ложных отрицаний (но, возможно, больше, чем уровень 1). В отличие от уровня 1, он предупреждает только при взятии адреса. Предупреждает об неполных типах. Работает только на стадии front-end.

Уровень 3 (по умолчанию для -Wstrict-aliasing): Должен иметь очень мало ложных срабатываний и мало ложных отрицаний. Чуть медленнее, чем уровни 1 или 2, когда включена оптимизация. Обрабатывает распространённый шаблон pun+dereference на стадии front-end: *(int*)&some_float. Если оптимизация включена, он также работает на стадии back-end, где он обрабатывает несколько случаев с использованием потокочувствительной информации о указателях. Предупреждает только при разыменовании преобразованного указателя. Не предупреждает об неполных типах.

-Wstrict-overflow

-Wstrict-overflow=n

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

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

-Wstrict-overflow=1: Предупреждать о случаях, которые одновременно сомнительны и легко избежимы. Например, компилятор упрощает x + 1 > x до 1. Этот уровень -Wstrict-overflow включен -Wall; более высокие уровни нет и их необходимо явно запросить.
-Wstrict-overflow=2: Также предупреждать об других случаях, когда сравнение упрощается до константы. Например: abs (x) >= 0. Это может быть упрощено только при неопределённом переполнении со знаком целых чисел, потому что abs (INT_MIN) переполняется до INT_MIN, что меньше нуля. -Wstrict-overflow (без уровня) эквивалентно -Wstrict-overflow=2.
-Wstrict-overflow=3: Также предупреждать об других случаях, когда сравнение упрощается. Например: x + 1 > 1 упрощается до x > 0.
-Wstrict-overflow=4: Также предупреждать об других упрощениях, не охваченных вышеприведёнными случаями. Например: (x * 10) / 5 упрощается до x * 2.
-Wstrict-overflow=5: Также предупреждать о случаях, когда компилятор уменьшает величину константы, участвующей в сравнении. Например: x + 2 > y упрощается до x + 1 >= y. Это сообщается только на самом высоком уровне предупреждений, потому что это упрощение применяется ко многим сравнениям, поэтому этот уровень предупреждений даёт очень большое количество ложных срабатываний.

-Wstring-compare

Предупреждать о вызовах strcmp и strncmp, результат которых определяется как нулевой или ненулевой при проверке на равенство из-за длины одного аргумента, превышающей размер массива, в котором хранится другой аргумент (или граница в случае strncmp). Такие вызовы могут быть ошибками. Например, вызов strcmp ниже диагностируется, потому что его результат обязательно ненулевой независимо от содержимого массива a.

extern char a[4];
void f (char *d)
{
  strcpy (d, "string");
  …
  if (0 == strcmp (a, d))   // cannot be true
    puts ("a and d are the same");
}

-Wstring-compare включена -Wextra.

-Wno-stringop-overflow

-Wstringop-overflow

-Wstringop-overflow=type

Предупреждать о вызовах функций обработки строк, таких как memcpy и strcpy, которые определены как вызывающие переполнение буфера назначения. Дополнительный аргумент на единицу больше типа проверки размера объекта, используемого для определения размера назначения. См. Проверку размера объекта. Аргумент имеет значение только для функций, работающих с массивами символов, но не для функций ссылок на сырую память, таких как memcpy, которые всегда используют тип проверки размера объекта 0. Данный параметр также предупреждает о вызовах, которые указывают размер, превышающий максимальный возможный размер объекта или, в крайнем случае, SIZE_MAX / 2 байт. Данный параметр обеспечивает лучшие результаты при включенной оптимизации, но может обнаружить небольшую подгруппу простых переполнений буфера даже без оптимизации при вызовах встроенных функций GCC, таких как __builtin_memcpy, которые соответствуют стандартным функциям. В любом случае, этот параметр предупреждает только о подмножестве переполнений буфера, обнаруженных соответствующими встроенными средствами проверки переполнения. Например, параметр выдает предупреждение для вызова strcpy ниже, поскольку он копирует как минимум 5 символов (строка "blue" включая завершающий NUL) в буфер размером 4 байта.

enum Color { blue, purple, yellow };
const char* f (enum Color clr)
{
  static char buf [4];
  const char *str;
  switch (clr)
    {
      case blue: str = "blue"; break;
      case purple: str = "purple"; break;
      case yellow: str = "yellow"; break;
    }

  return strcpy (buf, str);   // warning here
}

Параметр -Wstringop-overflow=2 включен по умолчанию.

-Wstringop-overflow
-Wstringop-overflow=1: Параметр -Wstringop-overflow=1 использует проверку размера объекта типа 0 для определения размеров объектов назначения. При этом значении параметр не предупреждает о записи за пределами подобъектов больших объектов, к которым осуществляется доступ через указатели, если размер самого большого окружающего объекта неизвестен. Когда место назначения может быть одним из нескольких объектов, предполагается, что это самый большой из них. В системах Linux, при включенной оптимизации при этом значении параметр предупреждает о том же коде, что и при определении макроса _FORTIFY_SOURCE ненулевым значением.
-Wstringop-overflow=2: Параметр -Wstringop-overflow=2 использует проверку размера объекта типа 1 для определения размеров объектов назначения. При этом значении параметр предупреждает о переполнениях при записи в члены самых больших целых объектов, точный размер которых известен. Однако он не предупреждает о чрезмерной записи в те же члены неизвестных объектов, на которые ссылаются указатели, так как они могут указывать на массивы, содержащие неизвестное количество элементов. Это значение параметра по умолчанию.
-Wstringop-overflow=3: Параметр -Wstringop-overflow=3 использует проверку размера объекта типа 2 для определения размеров объектов назначения. При этом значении параметр предупреждает о переполнении самого маленького объекта или элемента данных. Это наиболее ограничительное значение параметра, которое может привести к предупреждениям для безопасного кода.
-Wstringop-overflow=4: Параметр -Wstringop-overflow=4 использует проверку размера объекта типа 3 для определения размеров объектов назначения. При этом значении параметр предупреждает о переполнении любых элементов данных, а когда место назначения является одним из нескольких объектов, он использует размер самого большого из них для решения о выдаче предупреждения. Аналогично параметру -Wstringop-overflow=3, это значение параметра может привести к предупреждениям для безопасного кода.

-Wno-stringop-overread

Предупреждать о вызовах функций обработки строк, таких как memchr, или strcpy, которые определены как вызывающие чтение за пределами исходной последовательности.

Параметр -Wstringop-overread включен по умолчанию.

-Wno-stringop-truncation

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

В следующем примере вызов strncat указывает границу, меньшую длины исходной строки. В результате копия исходной строки будет обрезана, и поэтому вызов будет диагностирован. Чтобы избежать предупреждения, используйте bufsize - strlen (buf) - 1) в качестве границы.

void append (char *buf, size_t bufsize)
{
  strncat (buf, ".txt", 3);
}

Еще один пример. Следующий вызов strncpy приводит к копированию в d только символов, предшествующих завершающему NUL, без добавления NUL в конец. Предположение, что результат strncpy обязательно является строкой, завершенной NUL, является распространённой ошибкой, и поэтому вызов диагностируется. Чтобы избежать предупреждения, когда ожидается, что результат не будет завершен NUL, используйте memcpy вместо этого.

void copy (char *d, const char *s)
{
  strncpy (d, s, strlen (s));
}

В следующем примере вызов strncpy указывает размер буфера назначения в качестве границы. Если длина исходной строки равна или больше этого размера, результат копирования не будет завершён NUL. Следовательно, вызов также диагностируется. Чтобы избежать предупреждения, укажите sizeof buf - 1 в качестве границы и установите последний элемент буфера в NUL.

void copy (const char *s)
{
  char buf[80];
  strncpy (buf, s, sizeof buf);
  …
}

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

-Wstrict-flex-arrays

Предупреждать о неправильном использовании гибких элементов массива в соответствии с уровнем level атрибута strict_flex_array (level) , прикрепленного к последнему полю массива структуры, если оно доступно; в противном случае — в соответствии с уровнем level параметра -fstrict-flex-arrays=level.

Этот параметр эффективен только тогда, когда level больше 0. В противном случае он будет проигнорирован с предупреждением.

При level=1 будут выдаваться предупреждения для ссылки на массив в хвосте структуры, имеющей 2 или более элемента, если к массиву в хвосте обращаются как к гибкому элементу массива.

При level=2, помимо level=1, будут выдаваться дополнительные предупреждения для ссылки на массив в хвосте структуры, имеющей один элемент, если массив используется как гибкий элемент массива.

При level=3, помимо level=2, будут выдаваться дополнительные предупреждения для ссылки на массив в хвосте структуры, имеющей нулевую длину, если массив используется как гибкий элемент массива.

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

-Wsuggest-attribute=pure

-Wsuggest-attribute=const

-Wsuggest-attribute=noreturn

-Wmissing-noreturn

-Wsuggest-attribute=malloc

Предупреждать о функциях, которые могут быть кандидатами на атрибуты pure, const или noreturn или malloc. Компилятор предупреждает только для функций, видимых в других единицах компиляции, или (в случае pure и const) если не может доказать, что функция возвращается нормально. Функция возвращается нормально, если она не содержит бесконечного цикла или не возвращается аномально, выбрасывая исключение, вызывая abort или сбрасывая исключение. Для этого анализа требуется опция -fipa-pure-const, которая включена по умолчанию в -O и выше. Более высокие уровни оптимизации повышают точность анализа.

-Wsuggest-attribute=format

-Wmissing-format-attribute

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

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

-Wsuggest-attribute=cold

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

-Walloc-zero

Предупреждать о вызовах функций выделения, помеченных атрибутом alloc_size , которые указывают на нулевые байты, включая встроенные формы функций aligned_alloc, alloca, calloc, malloc, и realloc. Поскольку поведение этих функций при вызове с нулевым размером различается в разных реализациях (и в случае realloc было устаревшим), полагаться на него может привести к скрытым проблемам переносимости и следует избегать.

-Walloc-size-larger-than=byte-size

Предупреждать о вызовах функций, помеченных атрибутом alloc_size , которые пытаются выделить объекты размером больше указанного количества байтов или когда результат вычисления размера в цельном типе с бесконечной точностью превышает значение «PTRDIFF_MAX» на целевой платформе. -Walloc-size-larger-than=‘PTRDIFF_MAX’ включено по умолчанию. Предупреждения, контролируемые параметром, можно отключить, указав значение byte-size «SIZE_MAX» или больше, или используя -Wno-alloc-size-larger-than. См. Объявление атрибутов функций.

-Wno-alloc-size-larger-than

Отключить предупреждения -Walloc-size-larger-than=. Данный параметр эквивалентен -Walloc-size-larger-than=‘SIZE_MAX’ или большему значению.

-Walloca

Данный параметр выдаёт предупреждение при всех использования alloca в исходном коде.

-Walloca-larger-than=byte-size

Данный параметр выдаёт предупреждение при вызовах alloca с целочисленным аргументом, значение которого равно нулю или не ограничено управляющим предикатом, ограничивающим его значение сверху значением byte-size. Также он выдаёт предупреждение при вызовах alloca, когда ограниченное значение неизвестно. Аргументы нецелочисленного типа считаются неограниченными, даже если они кажутся ограниченными ожидаемым диапазоном.

Например, ограниченный случай alloca может выглядеть так:

void func (size_t n)
{
  void *p;
  if (n <= 1000)
    p = alloca (n);
  else
    p = malloc (n);
  f (p);
}

В приведённом выше примере передача -Walloca-larger-than=1000 не вызовет предупреждение, так как вызов alloca известен как не превышающий 1000 байт. Однако, если будет передано -Walloca-larger-than=500, компилятор выдаст предупреждение.

С другой стороны, неограниченные использования — это использование alloca без управляющего предиката, ограничивающего его целочисленный аргумент. Например:

void func ()
{
  void *p = alloca (n);
  f (p);
}

Если будет передано -Walloca-larger-than=500, вышеприведённый код вызовет предупреждение, но на этот раз из-за отсутствия проверки границ.

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

void func (signed int n)
{
  if (n < 500)
    {
      p = alloca (n);
      f (p);
    }
}

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

Данный параметр также выдаёт предупреждение при использовании alloca в цикле.

-Walloca-larger-than=‘PTRDIFF_MAX’ включено по умолчанию, но обычно эффективно только при активном -ftree-vrp (по умолчанию для -O2 и выше).

См. также -Wvla-larger-than=‘byte-size’.

-Wno-alloca-larger-than

Отключить предупреждения -Walloca-larger-than=. Данный параметр эквивалентен -Walloca-larger-than=‘SIZE_MAX’ или большему значению.

-Warith-conversion

Выдавать предупреждения об имплицитных преобразованиях при арифметических операциях, даже если преобразование операндов к одному типу не может изменить их значения. Это затрагивает предупреждения из -Wconversion, -Wfloat-conversion и -Wsign-conversion.

void f (char c, int i)
{
  c = c + i; // warns with -Wconversion
  c = c + 1; // only warns with -Warith-conversion
}

-Warray-bounds

-Warray-bounds=n

Предупреждать о выходе за пределы индексов или смещений в массивах. Это предупреждение включено параметром -Wall. Оно более эффективно при активном -ftree-vrp (по умолчанию для -O2 и выше), но подмножество случаев выводится и без оптимизации.

По умолчанию конечный массив структуры будет рассматриваться как гибкий элемент массива параметром -Warray-bounds или -Warray-bounds=n, если он объявлен как гибкий элемент массива в соответствии со стандартом C99 и далее (‘[]’), как расширение GCC нулевой длины массива (‘[0]’), или как массив из одного элемента (‘[1]’). В результате, выход за пределы индексов или смещений в массивы нулевой или единичной длины по умолчанию не вызывает предупреждение.

Вы можете добавить параметр -fstrict-flex-arrays или -fstrict-flex-arrays=level, чтобы контролировать, как данный параметр обрабатывает конечный массив структуры как гибкий массив:

при level<=1, поведение не меняется.

при level=2, выводятся дополнительные предупреждения об выходе за пределы индексов или смещений в массивы из одного элемента;

при level=3, в дополнение к level=2, выводятся дополнительные предупреждения об выходе за пределы индексов или смещений в массивы нулевой длины.

-Warray-bounds=1: Это уровень предупреждений по умолчанию для -Warray-bounds и включён по умолчанию параметром -Wall; более высокие уровни не включены и должны быть запрошены явно.
-Warray-bounds=2: Этот уровень предупреждений также предупреждает об промежуточных результатах арифметических операций с указателями, которые могут привести к значениям за пределами границ. Этот уровень предупреждений может давать больше ложных срабатываний и по умолчанию отключен.

-Warray-compare

Предупреждать о сравнениях на равенство и отношения между двумя операндами типа массива. Это сравнение устарело в C++20. Например:

int arr1[5];
int arr2[5];
bool same = arr1 == arr2;

-Warray-compare включено параметром -Wall.

-Warray-parameter

-Warray-parameter=n

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

Если первое объявление функции использует форму массива, предполагается, что граница, указанная в массиве, — это минимальное количество элементов, ожидаемых в вызовах функции, и максимальное количество элементов, доступных в ней. Непредоставление аргументов достаточного размера или доступ к большему количеству элементов, чем максимальное количество, может быть диагностировано с помощью предупреждений, таких как -Warray-bounds. На уровне 1 предупреждение диагностирует несоответствия, связанные с параметрами массивов, объявленных с помощью T[static N] формы.

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

void f (int[static 4]);
void f (int[]);           // warning (inconsistent array form)

void g (void)
{
  int *p = (int *)malloc (4);
  f (p);                  // warning (array too small)
  …
}

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

void g (int*);
void g (int[]);     // no warning
void g (int[8]);    // warning (inconsistent array bound)

-Warray-parameter=2 включено в -Wall. Параметр -Wvla-parameter вызывает предупреждения о подобных несоответствиях, связанных с аргументами массива переменной длины.

-Wattribute-alias=n

-Wno-attribute-alias

Выдавать предупреждение об объявлениях с использованием alias и подобных атрибутов, цель которых несовместима с типом псевдонима. См. Объявление атрибутов функций.

-Wattribute-alias=1

Уровень предупреждений по умолчанию для параметра -Wattribute-alias диагностирует несовместимость между типом объявления псевдонима и типом его цели. Такие несовместимости обычно указывают на ошибки.

-Wattribute-alias=1

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

Рассматриваемые атрибуты включают alloc_align, alloc_size, cold, const, hot, leaf, malloc, nonnull, noreturn, nothrow, pure, returns_nonnull, и returns_twice.

-Wattribute-alias эквивалентно -Wattribute-alias=1. Это значение по умолчанию. Вы можете отключить эти предупреждения с помощью -Wno-attribute-alias или -Wattribute-alias=0.

-Wbidi-chars=[none|unpaired|any|ucn]

Предупреждать о потенциально вводящих в заблуждение двунаправленных управляющих символах UTF-8 в комментариях, строковых литералах, символьных константах и идентификаторах. Такие символы могут изменить направление письма слева направо направо налево (и наоборот), что может вызвать путаницу между логическим и визуальным порядком. Это может быть опасно; например, может показаться, что часть кода не прокомментирована, в то время как она фактически прокомментирована.

GCC поддерживает три уровня предупреждений. По умолчанию используется -Wbidi-chars=unpaired, которое предупреждает об ошибочно завершённых контекстах bidi. -Wbidi-chars=none отключает предупреждение. -Wbidi-chars=any предупреждает обо всех использования двунаправленных управляющих символов.

По умолчанию это предупреждение не предупреждает об UCN. Однако можно включить такую проверку, используя -Wbidi-chars=unpaired,ucn или -Wbidi-chars=any,ucn. Использование -Wbidi-chars=ucn является допустимым и эквивалентно -Wbidi-chars=unpaired,ucn, если ранее не был указан -Wbidi-chars=any.

-Wbool-compare

Выдавать предупреждение об логическом выражении, сравниваемом с целочисленным значением, отличным от true/false. Например, следующее сравнение всегда ложно:

int n = 5;
…
if ((n > 1) == 2) { … }

Это предупреждение включено параметром -Wall.

-Wbool-operation

Предупреждать о подозрительных операциях над выражениями булевого типа. Например, побитовое отрицание булевой величины, очень вероятно, является ошибкой в программе. Для C это предупреждение также предупреждает об инкременте или декременте булевой величины, что редко имеет смысл. (В C++, декремент булевой величины всегда недопустим. Инкремент булевой величины недопустим в C++17 и устарел в противном случае.)

Это предупреждение включено параметром -Wall.

-Wduplicated-branches

Предупреждать при наличии одинаковых ветвей в операторе if-else. Это предупреждение обнаруживает случаи, подобные

if (p != NULL)
  return 0;
else
  return 0;

Оно не выводит предупреждение, если обе ветви содержат только оператор null. Это предупреждение также срабатывает для условных операторов:

int i = x ? *p : *p;

-Wduplicated-cond

Предупреждать о дублированных условиях в цепочке if-else-if. Например, предупреждать о следующем коде:

if (p->q != NULL) { … }
else if (p->q != NULL) { … }

-Wframe-address

Предупреждать, если функция «__builtin_frame_address» или «__builtin_return_address» вызывается с аргументом, большим 0. Такие вызовы могут возвращать неопределённые значения или привести к аварийному завершению программы. Предупреждение включено в -Wall.

-Wno-discarded-qualifiers (C and Objective-C only)

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

-Wno-discarded-array-qualifiers (C and Objective-C only)

Не выводить предупреждение, если квалификаторы типов для массивов, являющихся целевыми объектами указателей, отбрасываются. Обычно компилятор предупреждает, если переменная типа const int (*)[] передаётся функции, принимающей параметр типа int (*)[]. Этот параметр может использоваться для подавления такого предупреждения.

-Wno-incompatible-pointer-types (C and Objective-C only)

Не выводить предупреждение, если происходит преобразование между указателями с несовместимыми типами. Это предупреждение относится к случаям, не охваченным -Wno-pointer-sign, которое предупреждает о передаче аргумента-указателя или присваивании с разной знакостью.

-Wno-int-conversion (C and Objective-C only)

Не выводить предупреждение о несовместимых преобразованиях целого числа в указатель и указателя в целое число. Это предупреждение относится к неявным преобразованиям; для явных преобразований можно использовать предупреждения -Wno-int-to-pointer-cast и -Wno-pointer-to-int-cast.

-Wzero-length-bounds

Предупреждать об обращении к элементам членов массива нулевой длины, которые могут перекрывать другие члены того же объекта. Объявление внутренних массивов нулевой длины не рекомендуется, так как обращения к ним неопределены. См. Массивы нулевой длины.

Например, первые два сохранения в функции bad диагностируются, так как элементы массива перекрывают последующие члены b и c. Третье сохранение диагностируется -Warray-bounds, так как выходит за пределы окружающего объекта.

struct X { int a[0]; int b, c; };
struct X x;

void bad (void)
{
  x.a[0] = 0;   // -Wzero-length-bounds
  x.a[1] = 1;   // -Wzero-length-bounds
  x.a[2] = 2;   // -Warray-bounds
}

Параметр -Wzero-length-bounds включён в -Warray-bounds.

-Wno-div-by-zero

Не выводить предупреждение о целочисленном делении на ноль во время компиляции. Деление с плавающей точкой на ноль не предупреждает, так как это может быть законным способом получения бесконечностей и NaN.

-Wsystem-headers

Выводить сообщения об ошибках для конструкций, найденных в системных заголовочных файлах. Предупреждения из системных заголовков обычно подавляются, исходя из предположения, что они обычно не указывают на реальные проблемы и только усложнят вывод компилятора. Использование этого параметра командной строки сообщает GCC о выводе предупреждений из системных заголовков так, как если бы они произошли в пользовательском коде. Однако обратите внимание, что использование -Wall в сочетании с этим параметром не предупреждает об неизвестных директивах в системных заголовках — для этого необходимо использовать также -Wunknown-pragmas.

-Wtautological-compare

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

int i = 1;
…
if (i > i) { … }

Это предупреждение также предупреждает о побитовых сравнениях, которые всегда оцениваются как истинными или ложными, например:

if ((a & 16) == 10) { … }

всегда будет ложным.

Это предупреждение включено в -Wall.

-Wtrampolines

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

-Wfloat-equal

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

Идея заключается в том, что иногда удобнее (для программиста) рассматривать значения с плавающей точкой как приближения к бесконечно точным действительным числам. Если вы делаете это, то вам нужно вычислить (путем анализа кода или каким-либо другим способом) максимальную или вероятную максимальную ошибку, вносимую вычислением, и учесть её при выполнении сравнений (и при выводе данных, но это другая проблема). В частности, вместо проверки на равенство необходимо проверять, перекрываются ли диапазоны двух значений; и это делается с помощью операторов отношения, поэтому сравнения на равенство, вероятно, ошибочны.

-Wtraditional (C and Objective-C only)

Предупреждать о некоторых конструкциях, которые ведут себя по-разному в традиционном и ISO C. Также предупреждать о конструкциях ISO C, не имеющих эквивалента в традиционном C, и/или о проблемных конструкциях, которых следует избегать.

Параметры макроса, которые появляются в строковых литералах в теле макроса. В традиционном C замена макроса происходит в строковых литералах, но в ISO C это не так.
В традиционном C некоторые директивы препроцессора не существовали. Традиционные препроцессоры рассматривали строку как директиву только если символ ‘#’ появлялся в первом столбце строки. Поэтому -Wtraditional предупреждает о директивах, которые понимает традиционный C, но игнорирует, потому что ‘#’ не появляется как первый символ в строке. Также он предлагает скрыть директивы, такие как #pragma , не понимаемые традиционным C, отступая их. Некоторые традиционные реализации не распознают #elif, поэтому этот параметр предлагает вообще избегать его.
Функциональное макрос, которое появляется без аргументов.
Унарный оператор плюс.
Суффикс целой константы ‘U’ или суффиксы констант с плавающей точкой ‘F’ или ‘L’. (Традиционный C поддерживает суффикс ‘L’ для целочисленных констант.) Обратите внимание, что эти суффиксы появляются в макросах, определённых в системных заголовках большинства современных систем, например, макросы ‘_MIN’/‘_MAX’ в <limits.h>. Использование этих макросов в пользовательском коде может обычно привести к ложным предупреждениям, однако встроенный препроцессор GCC имеет достаточный контекст, чтобы избежать предупреждения в этих случаях.
Функция, объявленная внешней в одном блоке, а затем используемая после конца блока.
Оператор switch имеет операнд типа long.
Объявление функции, не являющейся static, следует за static . Эта конструкция не принимается некоторыми традиционными компиляторами C.
ISO-тип целочисленной константы имеет другую ширину или знаковость, чем её традиционный тип. Это предупреждение выдаётся только если основа константы десять. Т.е. шестнадцатеричные или восьмеричные значения, которые обычно представляют битовые шаблоны, не предупреждаются.
Обнаружено использование ISO-строкового конкатенации.
Инициализация автоматических агрегатов.
Конфликты идентификаторов с метками. Традиционный C не имеет отдельного пространства имён для меток.
Инициализация объединений. Если инициализатор равен нулю, предупреждение пропускается. Это делается исходя из предположения, что нулевой инициализатор в пользовательском коде обусловлен, например, __STDC__, чтобы избежать пропуска предупреждений об инициализаторах и полагается на стандартную инициализацию нулём в традиционном случае C.
Преобразования по прототипам между значениями с фиксированной и плавающей точкой и наоборот. Отсутствие этих прототипов при компиляции с традиционным C вызывает серьёзные проблемы. Это подмножество возможных предупреждений о преобразованиях; для полного набора используйте -Wtraditional-conversion.
Использование определений функций в стиле ISO C. Это предупреждение намеренно не выдается для объявлений прототипов или функций с переменным числом аргументов, потому что эти функции ISO C появляются в вашем коде при использовании традиционных макросов совместимости с libiberty, PARAMS и VPARAMS. Это предупреждение также не выдаётся для вложенных функций, потому что эта функция уже является расширением GCC и, следовательно, не имеет отношения к традиционной совместимости с C.

-Wtraditional-conversion (C and Objective-C only)

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

-Wdeclaration-after-statement (C and Objective-C only)

Предупреждать, когда объявление находится после оператора в блоке. Эта конструкция, известная из C++, была введена с ISO C99 и по умолчанию разрешена в GCC. Она не поддерживается ISO C90. См. Смешанные объявления, метки и код.

-Wshadow

Предупреждать всякий раз, когда локальная переменная или объявление типа затеняют другую переменную, параметр, тип, член класса (в C++) или переменную экземпляра (в Objective-C), или когда затеняется встроенная функция. Обратите внимание, что в C++ компилятор предупреждает, если локальная переменная затеняет явный typedef, но не затеняет структуру/класс/перечисление. Если это предупреждение включено, оно включает также все случаи локального затенения. Это означает, что -Wno-shadow=local и -Wno-shadow=compatible-local игнорируются при использовании -Wshadow. То же самое, что и -Wshadow=global.

-Wno-shadow-ivar (Objective-C only)

Не выводить предупреждение, если локальная переменная затеняет переменную экземпляра в методе Objective-C.

-Wshadow=global

Предупреждать обо всех случаях затенения. То же самое, что и -Wshadow.

-Wshadow=local

Предупреждать, если локальная переменная затеняет другую локальную переменную или параметр.

-Wshadow=compatible-local

Предупреждать, когда локальная переменная затеняет другую локальную переменную или параметр, тип которого совместим с типом затеняющей переменной. В C++, совместимость типов означает, что тип затеняющей переменной может быть преобразован в тип затеняемой переменной. Создание этого флага (в дополнение к -Wshadow=local) основано на том, что когда локальная переменная затеняет другую переменную несовместимого типа, это, скорее всего, сделано намеренно, а не является ошибкой или опечаткой, как показано в следующем примере:

for (SomeIterator i = SomeObj.begin(); i != SomeObj.end(); ++i)
{
  for (int i = 0; i < N; ++i)
  {
    ...
  }
  ...
}

Поскольку две переменные i в примере выше имеют несовместимые типы, включение только -Wshadow=compatible-local не генерирует предупреждение. Поскольку их типы несовместимы, если программист случайно использует одну вместо другой, проверка типов должна поймать это и выдать ошибку или предупреждение. Использование этого флага вместо -Wshadow=local может потенциально уменьшить количество предупреждений, вызываемых намеренным затенением. Обратите внимание, что это также означает, что затенение const char *i переменной char *i не приводит к предупреждению.

Это предупреждение также включается с -Wshadow=local.

-Wlarger-than=byte-size

Предупреждать всякий раз, когда определяется объект, размер которого превышает byte-size. -Wlarger-than=‘PTRDIFF_MAX’ включено по умолчанию. Предупреждения, контролируемые этим параметром, могут быть отключены, задав byte-size равным ‘SIZE_MAX’ или больше, или с помощью -Wno-larger-than.

Также предупреждать о вызовах ограниченных функций, таких как memchr или strnlen, которые задают ограничение больше, чем максимально возможный размер объекта, который по умолчанию составляет ‘PTRDIFF_MAX’ байт. Эти предупреждения можно отключить только с помощью -Wno-larger-than.

-Wno-larger-than

Отключить предупреждения -Wlarger-than=. Параметр эквивалентен -Wlarger-than=‘SIZE_MAX’ или больше.

-Wframe-larger-than=byte-size

Предупреждать, если размер стековой рамки функции превышает byte-size. Вычисление, используемое для определения размера стековой рамки, приблизительное и не консервативное. Фактические требования могут быть несколько больше, чем byte-size, даже если предупреждение не выдается. Кроме того, любой выделенный через alloca память, переменные длины или связанные конструкции не включаются компилятором при определении того, выдавать предупреждение или нет. -Wframe-larger-than=‘PTRDIFF_MAX’ включено по умолчанию. Предупреждения, контролируемые этим параметром, могут быть отключены, задав byte-size равным ‘SIZE_MAX’ или больше, или с помощью -Wno-frame-larger-than.

-Wno-frame-larger-than

Отключить предупреждения -Wframe-larger-than=. Параметр эквивалентен -Wframe-larger-than=‘SIZE_MAX’ или больше.

-Wfree-nonheap-object

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

void f (char *p)
{
  p = stpcpy (p, "abc");
  // ...
  free (p);   // warning
}

-Wfree-nonheap-object включено в -Wall.

-Wstack-usage=byte-size

Предупреждать, если использование стека функцией может превысить byte-size. Вычисление, используемое для определения использования стека, консервативное. Любая память, выделенная через alloca, переменные длины или связанные конструкции включаются компилятором при определении того, следует ли выдавать предупреждение или нет.

Сообщение соответствует выводу -fstack-usage.

Если использование стека полностью статическое, но превышает указанное значение, это:
```
warning: stack usage is 1120 bytes
```
Если использование стека (частично) динамическое, но ограничено, это:
```
warning: stack usage might be 1648 bytes
```
Если использование стека (частично) динамическое и не ограничено, это:
```
warning: stack usage might be unbounded
```

-Wstack-usage=‘PTRDIFF_MAX’ включено по умолчанию. Предупреждения, контролируемые этим параметром, могут быть отключены, задав byte-size равным ‘SIZE_MAX’ или больше, или с помощью -Wno-stack-usage.

-Wno-stack-usage

Отключить предупреждения -Wstack-usage=. Параметр эквивалентен -Wstack-usage=‘SIZE_MAX’ или больше.

-Wunsafe-loop-optimizations

Предупреждать, если цикл не может быть оптимизирован, потому что компилятор не может ничего предположить о границах индексов цикла. С -funsafe-loop-optimizations предупреждать, если компилятор делает такие предположения.

-Wno-pedantic-ms-format (MinGW targets only)

При использовании в сочетании с -Wformat и -pedantic без расширений GNU, этот параметр отключает предупреждения о не-ISO printf / scanf спецификаторах ширины формата I32, I64, и I используемых на целевых платформах Windows, которые зависят от MS runtime.

-Wpointer-arith

Предупреждать о любых зависимостях от «размера» типа функции или void. GNU C присваивает этим типам размер 1 для удобства вычислений с указателями на void * и указателями на функции. В C++, предупреждать также при арифметических операциях, включающих NULL. Это предупреждение также включено с -Wpedantic.

-Wno-pointer-compare

Не выдавать предупреждение, если указатель сравнивается с нулевым символом. Обычно это означает, что указатель должен был быть разыменован. Например:

const char *p = foo ();
if (p == '\0')
  return 42;

Обратите внимание, что код выше недействителен в C++11.

Это предупреждение включено по умолчанию.

-Wtsan

Предупреждать об отсутствующих функциях в ThreadSanitizer.

ThreadSanitizer не поддерживает std::atomic_thread_fence и может выдавать ложные срабатывания.

Это предупреждение включено по умолчанию.

-Wtype-limits

Предупреждать, если сравнение всегда истинно или всегда ложно из-за ограниченного диапазона типа данных, но не предупреждать для константных выражений. Например, предупреждать, если беззнаковая переменная сравнивается с нулем с помощью < или >=. Это предупреждение также включено с -Wextra.

-Wabsolute-value (C and Objective-C only)

Предупреждать о вызовах стандартных функций, вычисляющих абсолютное значение аргумента, когда доступна более подходящая стандартная функция. Например, вызов abs(3.14) вызывает предупреждение, потому что для вычисления абсолютного значения аргумента типа double следует использовать функцию fabs. Параметр также вызывает предупреждения, когда аргумент в вызове такой функции имеет беззнаковый тип. Это предупреждение может быть подавлено явным приведением типов, и оно также включено с -Wextra.

-Wcomment

-Wcomments

Предупреждать всякий раз, когда последовательность комментариев ‘/*’ появляется в комментарии ‘/*’ или когда обратный слэш-новая строка появляется в комментарии ‘//’. Это предупреждение включено с -Wall.

-Wtrigraphs

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

Этот параметр подразумевается -Wall. Если -Wall не задано, этот параметр всё равно включён, если не включены триграфы. Чтобы получить преобразование триграфов без предупреждений, но получить другие предупреждения -Wall, используйте ‘-trigraphs -Wall -Wno-trigraphs’.

-Wundef

Предупреждать, если неопределённый идентификатор оценивается в директиве #if. Такие идентификаторы заменяются нулём.

-Wexpansion-to-defined

Предупреждать всякий раз, когда встречается ‘defined’ в развёртывании макроса (включая случай, когда макрос развёртывается директивой ‘#if’). Такое использование не переносимо. Это предупреждение также включено с -Wpedantic и -Wextra.

-Wunused-macros

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

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

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

#if defined the_macro_causing_the_warning
#endif

-Wno-endif-labels

Не выдавать предупреждения, когда #else или #endif следуют за текстом. Это иногда происходит в старых программах с кодом вида

#if FOO
…
#else FOO
…
#endif FOO

Вторые и третьи FOO должны быть в комментариях. Это предупреждение включено по умолчанию.

-Wbad-function-cast (C and Objective-C only)

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

-Wc90-c99-compat (C and Objective-C only)

Предупреждать о функциях, отсутствующих в ISO C90, но присутствующих в ISO C99. Например, предупреждать об использовании массивов переменной длины, типе long long, типе bool, составных литералах, обозначенных инициализаторах и так далее. Этот параметр независим от режима стандартов. Предупреждения отключены в выражении, следующем за __extension__.

-Wc99-c11-compat (C and Objective-C only)

Предупреждать о функциях, отсутствующих в ISO C99, но присутствующих в ISO C11. Например, предупреждать об использовании анонимных структур и объединений, квалификаторе типа _Atomic, спецификаторе класса хранения _Thread_local, спецификаторе _Alignas, операторе _Generic, ключевом слове Alignof и так далее. Этот параметр независим от режима стандартов. Предупреждения отключены в выражении, следующем за __extension__.

-Wc11-c2x-compat (C and Objective-C only)

Предупреждать о функциях, отсутствующих в ISO C11, но присутствующих в ISO C2X. Например, предупреждать об опущении строки в _Static_assert, использовании синтаксиса ‘[[]]’ для атрибутов, использовании десятичных типов с плавающей точкой и так далее. Этот параметр независим от режима стандартов. Предупреждения отключены в выражении, следующем за __extension__.

-Wc++-compat (C and Objective-C only)

Предупреждать о конструкциях ISO C, которые находятся за пределами общего подмножества ISO C и ISO C++, например, о запросе неявного преобразования из void * в указатель на тип, не являющийся void.

-Wc++11-compat (C++ and Objective-C++ only)

Предупреждать о конструкциях C++, смысл которых отличается между ISO C++ 1998 и ISO C++ 2011, например, об идентификаторах в ISO C++ 1998, которые являются ключевыми словами в ISO C++ 2011. Это предупреждение включает -Wnarrowing и активируется с -Wall.

-Wc++14-compat (C++ and Objective-C++ only)

Предупреждать о конструкциях C++, смысл которых отличается между ISO C++ 2011 и ISO C++ 2014. Это предупреждение активируется с -Wall.

-Wc++17-compat (C++ and Objective-C++ only)

Предупреждать о конструкциях C++, смысл которых отличается между ISO C++ 2014 и ISO C++ 2017. Это предупреждение активируется с -Wall.

-Wc++20-compat (C++ and Objective-C++ only)

Предупреждать о конструкциях C++, смысл которых отличается между ISO C++ 2017 и ISO C++ 2020. Это предупреждение активируется с -Wall.

-Wno-c++11-extensions (C++ and Objective-C++ only)

Не выдавать предупреждений о конструкциях C++11 в коде, компилируемом с более старой версией стандарта C++. Даже без этого параметра некоторые конструкции C++11 будут диагностированы только при использовании -Wpedantic.

-Wno-c++14-extensions (C++ and Objective-C++ only)

Не выдавать предупреждений о конструкциях C++14 в коде, компилируемом с более старой версией стандарта C++. Даже без этого параметра некоторые конструкции C++14 будут диагностированы только при использовании -Wpedantic.

-Wno-c++17-extensions (C++ and Objective-C++ only)

Не выдавать предупреждений о конструкциях C++17 в коде, компилируемом с более старой версией стандарта C++. Даже без этого параметра некоторые конструкции C++17 будут диагностированы только при использовании -Wpedantic.

-Wno-c++20-extensions (C++ and Objective-C++ only)

Не выдавать предупреждений о конструкциях C++20 в коде, компилируемом с более старой версией стандарта C++. Даже без этого параметра некоторые конструкции C++20 будут диагностированы только при использовании -Wpedantic.

-Wno-c++23-extensions (C++ and Objective-C++ only)

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

Также предупреждать при приведении, которое небезопасно добавляет квалификатор типа. Например, приведение char ** к const char ** небезопасно, как показано в этом примере:

/* p is char ** value.  */
const char **q = (const char **) p;
/* Assignment of readonly string to const char * is OK.  */
*q = "string";
/* Now char** pointer points to read-only memory.  */
**p = 'b';

-Wcast-align

Предупреждать при любом приведении указателя, увеличивающем требуемое выравнивание целевого типа. Например, предупреждать, если char * приводится к int * на машинах, где к целым числам можно обращаться только на границах в два или четыре байта.

-Wcast-align=strict

Предупреждать при любом приведении указателя, увеличивающем требуемое выравнивание целевого типа. Например, предупреждать, если char * приводится к int * независимо от целевой машины.

-Wcast-function-type

Предупреждать при приведении указателя на функцию к несовместимому указателю на функцию. При приведении, связанном с функциями с переменным списком аргументов, учитываются только типы начальных аргументов, которые предоставлены. Любой параметр типа указателя соответствует любому другому типу указателя. Любые несущественные различия в целочисленных типах игнорируются, например int против long на ILP32-целевых платформах. Аналогично, квалификаторы типов игнорируются. Тип функции void (*) (void) является особым и соответствует всему, что может использоваться для подавления этого предупреждения. При приведении, связанном с типами указателя на член, это предупреждение активируется, когда приведение меняет тип указателя на член. Это предупреждение активируется с -Wextra.

-Wwrite-strings

При компиляции C, присваивать строковым константам тип const char[length], чтобы копирование адреса одной в не-const char * указатель порождало предупреждение. Эти предупреждения помогают обнаружить во время компиляции код, который может попытаться записать в строковую константу, но только если вы очень осторожно использовали const в объявлениях и прототипах. В противном случае это просто беспокойство. Вот почему мы не заставили -Wall запросить эти предупреждения.

При компиляции C++, предупреждать о устаревшем преобразовании строковых литералов в char *. Это предупреждение включено по умолчанию для C++ программ.

-Wclobbered

Предупреждать о переменных, которые могут быть изменены longjmp или vfork. Это предупреждение также активируется с -Wextra.

-Wno-complain-wrong-lang

По умолчанию, языковые фронтенды жалуются, когда параметр командной строки допустим, но не применим к этому фронтенду. Это можно отключить с -Wno-complain-wrong-lang, что, в основном, полезно при вызове одного компилятора для нескольких исходных файлов, написанных на разных языках, например:

$ g++ -fno-rtti a.cc b.f90

Драйвер g++ вызывает фронтенд C++ для компиляции a.cc и фронтенд Fortran для компиляции b.f90. Последний фронтенд диагностирует «f951: Предупреждение: параметр командной строки '-fno-rtti' допустим для C++/D/ObjC++ но не для Fortran», что можно отключить с -Wno-complain-wrong-lang.

-Wconversion

Предупреждать о неявных преобразованиях, которые могут изменить значение. Это включает преобразования между вещественным и целым типом, например abs (x), когда x равно double; преобразования между знаковыми и беззнаковыми типами, например unsigned ui = -1; и преобразования в типы меньшего размера, например sqrtf (M_PI). Не выдавать предупреждений для явных приведений, например abs ((int) x) и ui = (unsigned) -1, или если значение не изменяется преобразованием, например, в abs (2.0). Предупреждения о преобразованиях между знаковыми и беззнаковыми целыми числами можно отключить с помощью -Wno-sign-conversion.

Для C++, также предупреждать о путанице в разрешении перегрузки для пользовательских преобразований; и о преобразованиях, которые никогда не используют оператор преобразования типа: преобразования в void, тот же тип, базовый класс или ссылка на них. Предупреждения о преобразованиях между знаковыми и беззнаковыми целыми числами отключены по умолчанию в C++, если явно не включен -Wsign-conversion.

Предупреждения о преобразовании арифметических операций с типом меньшего размера обратно в этот тип выдаются только с -Warith-conversion.

-Wdangling-else

Предупреждать о конструкциях, где может быть неясно, к какому оператору if относится ветвь else. Вот пример такого случая:

{
  if (a)
    if (b)
      foo ();
  else
    bar ();
}

В C/C++, каждая ветвь else относится к самому внутреннему возможному оператору if, который в этом примере является if (b). Это часто не соответствует ожиданиям программиста, как показано в примере с форматированием отступа. Когда существует потенциальная путаница, GCC выдает предупреждение при указании этого флага. Чтобы устранить предупреждение, добавьте явные фигурные скобки вокруг самого внутреннего оператора if, чтобы избежать возможности принадлежности else к содержащему оператору if. Результирующий код выглядит так:

{
  if (a)
    {
      if (b)
        foo ();
      else
        bar ();
    }
}

Это предупреждение активируется с -Wparentheses.

-Wdangling-pointer

-Wdangling-pointer=n

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

-Wdangling-pointer=1

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

int f (int c1, int c2, x)
{
  char *p = strchr ((char[]){ c1, c2 }, c3);
  // warning: dangling pointer to a compound literal
  return p ? *p : 'x';
}

В следующей функции хранение адреса локальной переменной x в указателе *p, используемом за пределами области видимости, также вызывает предупреждение.

void g (int **p)
{
  int x = 7;
  // warning: storing the address of a local variable in *p
  *p = &x;
}

-Wdangling-pointer=2

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

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

void f (char *s)
{
  if (!s)
    {
      char a[12] = "tmpname";
      s = a;
    }
  // warning: dangling pointer to a may be used
  strcat (s, ".tmp");
  ...
}

-Wdangling-pointer=2 включено в -Wall.

-Wdate-time

Предупреждать о встречаемых макросах __TIME__, __DATE__ или __TIMESTAMP__, поскольку они могут предотвратить битово-тождественные воспроизводимые компиляции.

-Wempty-body

Предупреждать, если пустое тело встречается в операторе if, else или do while. Это предупреждение также включено в -Wextra.

-Wno-endif-labels

Не выдавать предупреждений о случайных токенах после #else и #endif.

-Wenum-compare

Предупреждать о сравнении значений разных перечислимых типов. В C++ несовпадения типов перечисления в условных выражениях также диагностируются, и предупреждение включено по умолчанию. В C это предупреждение включено в -Wall.

-Wenum-conversion

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

-Wenum-int-mismatch (C and Objective-C only)

Предупреждать о несовпадениях между перечислимым типом и целочисленным типом в объявлениях. Например:

enum E { l = -1, z = 0, g = 1 };
int foo(void);
enum E foo(void);

В C, перечислимый тип совместим с char, знаковым целочисленным типом или беззнаковым целочисленным типом. Однако, так как выбор базового типа перечислимого типа зависит от реализации, такие несоответствия могут привести к проблемам с переносимостью. В C++, такие несоответствия являются ошибкой. В C это предупреждение включено в -Wall и -Wc++-compat.

-Wjump-misses-init (C, Objective-C only)

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

-Wjump-misses-init включено в -Wc++-compat. Его можно отключить с помощью параметра -Wno-jump-misses-init.

-Wsign-compare

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

-Wsign-conversion

Предупреждать о неявных преобразованиях, которые могут изменить знак целочисленного значения, например, присваивание выражения знакового целого типу беззнакового целого. Явное приведение типов отключает предупреждение. В C, этот параметр также включён в -Wconversion.

-Wfloat-conversion

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

-Wno-scalar-storage-order

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

-Wsizeof-array-div

Предупреждать о делениях двух операторов sizeof, когда первый применяется к массиву, а делитель не равен размеру элемента массива. В таком случае вычисление не даст количество элементов в массиве, что, вероятно, и предполагалось пользователем. Это предупреждение предупреждает, например, о

int fn ()
{
  int arr[10];
  return sizeof (arr) / sizeof (short);
}

Это предупреждение включено в -Wall.

-Wsizeof-pointer-div

Предупреждать о подозрительных делениях двух выражений sizeof, которые делят размер указателя на размер элемента, что является обычным способом вычисления размера массива, но не будет работать корректно с указателями. Это предупреждение предупреждает, например, о sizeof (ptr) / sizeof (ptr[0]), если ptr не является массивом, а указателем. Это предупреждение включено в -Wall.

-Wsizeof-pointer-memaccess

Предупреждать о подозрительных параметрах длины для определённых функций строк и памяти, если аргумент использует sizeof. Это предупреждение, например, срабатывает для memset (ptr, 0, sizeof (ptr));, если ptr не является массивом, а указателем, и предлагает возможную корректировку, или о memcpy (&foo, ptr, sizeof (&foo));. -Wsizeof-pointer-memaccess также предупреждает о вызовах функций ограниченной копирования строк, таких как strncat или strncpy, которые в качестве границы задают выражение sizeof исходного массива. Например, в следующей функции вызов strncat указывает размер исходной строки в качестве границы. Это, почти наверняка, ошибка, поэтому вызов диагностируется.

void make_file (const char *name)
{
  char path[PATH_MAX];
  strncpy (path, name, sizeof path - 1);
  strncat (path, ".text", sizeof ".text");
  …
}

Параметр -Wsizeof-pointer-memaccess включён в -Wall.

-Wno-sizeof-array-argument

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

-Wmemset-elt-size

Предупреждать о подозрительных вызовах встроенной функции memset, если первый аргумент ссылается на массив, а третий аргумент — число, равное количеству элементов, но не равное размеру массива в памяти. Это указывает на то, что пользователь опустил умножение на размер элемента. Это предупреждение включено в -Wall.

-Wmemset-transposed-args

Предупреждать о подозрительных вызовах встроенной функции memset, где второй аргумент не ноль, а третий аргумент ноль. Например, вызов memset (buf, sizeof buf, 0) диагностируется, потому что следовало использовать memset (buf, 0, sizeof buf). Диагностика выполняется только в том случае, если третий аргумент — это литерал ноль. В противном случае, если это выражение, сворачивающееся в ноль, или преобразование нуля в некоторый тип, гораздо менее вероятно, что аргументы были ошибочно переставлены, и предупреждение не выводится.

Это предупреждение включено в -Wall.

-Waddress

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

void f (void);
void g (void)
{
  if (!f)   // warning: expression evaluates to false
    abort ();
}

сравнениях указателя на строковый литерал, например, в

void f (const char *x)
{
  if (x == "abc")   // warning: expression evaluates to false
    puts ("equal");
}

и проверке результатов сложения или вычитания указателей на равенство нулю, например, в

void f (const int *p, int i)
{
  return p + i == NULL;
}

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

Сравнения со строковыми литералами приводят к неопределённому поведению и не являются переносимыми и предполагают, что намерением было вызвать strcmp. Предупреждение подавляется, если подозрительное выражение является результатом макрорасширения. Предупреждение -Waddress включено в -Wall.

-Wno-address-of-packed-member

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

-Wlogical-op

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

extern int a;
if (a < 0 && a < 0) { … }

-Wlogical-not-parentheses

Предупреждать об использовании логического отрицания (!) в качестве левого операнда сравнения. Этот параметр не выдаёт предупреждения, если правый операнд рассматривается как логическое выражение. Его цель — обнаруживать подозрительный код, такой как следующий:

int a;
…
if (!a > 1) { … }

Можно подавить предупреждение, обернув левую часть в скобки:

if ((!a) > 1) { … }

Это предупреждение включено в -Wall.

-Waggregate-return

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

-Wno-aggressive-loop-optimizations

Предупреждать, если в цикле с постоянным числом итераций компилятор обнаруживает неопределённое поведение в каком-либо операторе во время одной или нескольких итераций.

-Wno-attributes

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

Кроме того, с помощью -Wno-attributes= можно подавить предупреждения об неизвестных атрибутах области видимости (в C++11 и C2X). Например, -Wno-attributes=vendor::attr отключает предупреждение об следующем объявлении:

[[vendor::attr]] void f();

Также можно отключить предупреждение об всех атрибутах в пространстве имён, используя -Wno-attributes=vendor::, что предотвращает предупреждение об обоих этих объявлениях:

[[vendor::safe]] void f();
[[vendor::unsafe]] void f2();

Обратите внимание, что -Wno-attributes= не подразумевает -Wno-attributes.

-Wno-builtin-declaration-mismatch

Выдавать предупреждение, если встроенная функция объявлена с несовместимой сигнатурой или как не функция, или если встроенная функция, объявленная с типом, не включающим прототип, вызывается с аргументами, типы которых после повышения не соответствуют ожидаемым функцией типам. При указании -Wextra также выдавать предупреждение, когда встроенная функция, принимающая аргументы, объявлена без прототипа. Предупреждение -Wbuiltin-declaration-mismatch включено по умолчанию. Чтобы избежать предупреждения, включите соответствующий заголовок, чтобы прототипы встроенных функций попали в область видимости.

Например, вызов memset ниже диагностируется предупреждением, потому что функция ожидает значение типа size_t в качестве аргумента, но тип 32 равен int. При использовании -Wextra также диагностируется объявление функции.

extern void* memset ();
void f (void *d)
{
  memset (d, '\0', 32);
}

-Wno-builtin-macro-redefined

Не выдавать предупреждение, если некоторые встроенные макросы переопределены. Это подавляет предупреждения о переопределении __TIMESTAMP__, __TIME__, __DATE__, __FILE__, и __BASE_FILE__.

-Wstrict-prototypes (C and Objective-C only)

Выдавать предупреждение, если функция объявлена или определена без указания типов аргументов. (Определение функции старого стиля разрешено без предупреждения, если ему предшествует объявление, которое указывает типы аргументов.)

-Wold-style-declaration (C and Objective-C only)

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

-Wold-style-definition (C and Objective-C only)

Выдавать предупреждение, если используется определение функции старого стиля. Предупреждение выдаётся даже если существует предыдущий прототип. Определение, использующее ‘()’ не считается определением старого стиля в режиме C2X, потому что оно эквивалентно ‘(void)’ в этом случае, но считается определением старого стиля для более ранних стандартов.

-Wmissing-parameter-type (C and Objective-C only)

Параметр функции объявлен без указания типа в функциях стиля К&Р:

void foo(bar) { }

Это предупреждение также включается с -Wextra.

-Wmissing-prototypes (C and Objective-C only)

Выдавать предупреждение, если глобальная функция определена без предварительного объявления прототипа. Это предупреждение выдаётся даже если само определение предоставляет прототип. Используйте этот параметр, чтобы обнаруживать глобальные функции, у которых нет соответствующего объявления прототипа в файле заголовков. Этот параметр недействителен для C++, поскольку все объявления функций предоставляют прототипы, а несоответствующее объявление объявляет перегрузку, а не противоречит ранее объявленной функции. Используйте -Wmissing-declarations для обнаружения отсутствующих объявлений в C++.

-Wmissing-declarations

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

-Wmissing-field-initializers

Выдавать предупреждение, если в инициализаторе структуры отсутствуют некоторые поля. Например, следующий код вызывает такое предупреждение, потому что x.h неявно равен нулю:

struct s { int f, g, h; };
struct s x = { 3, 4 };

Этот параметр не выдаёт предупреждение об обозначенных инициализаторах, поэтому следующее изменение не вызывает предупреждения:

struct s { int f, g, h; };
struct s x = { .f = 3, .g = 4 };

В C этот параметр не выдаёт предупреждение об универсальном инициализаторе нуля ‘{ 0 }’:

struct s { int f, g, h; };
struct s x = { 0 };

Аналогично, в C++ этот параметр не выдаёт предупреждение об пустом инициализаторе { }, например:

struct s { int f, g, h; };
s x = { };

Это предупреждение включено в -Wextra. Чтобы получить другие предупреждения -Wextra без этого, используйте -Wextra -Wno-missing-field-initializers.

-Wno-missing-requires

По умолчанию компилятор выдаёт предупреждение, если идентификатор концепции появляется как простое требование C++20:

bool satisfied = requires { C<T> };

Здесь ‘satisfied’ будет истинным, если ‘C<T>’ является допустимым выражением, что верно для всех T. Вероятно, пользователь хотел написать:

bool satisfied = requires { C<T> };

так что ‘satisfied’ истинно только если концепция ‘C’ удовлетворяется для типа ‘T’.

Это предупреждение можно отключить с помощью -Wno-missing-requires.

-Wno-missing-template-keyword

Операторы доступа к членам ., -> и :: должны быть после ключевого слова template, если родительский объект является зависимым, и член, который называется, является шаблоном.

template <class X>
void DoStuff (X x)
{
  x.template DoSomeOtherStuff<X>(); // Good.
  x.DoMoreStuff<X>(); // Warning, x is dependent.
}

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

void NotATemplate (my_class t)
{
  int N = 5;

  bool test = t.m < N > (0); // Treated as a template.
  test = (t.m < N) > (0); // Same meaning, but not treated as a template.
}

Это предупреждение можно отключить с помощью -Wno-missing-template-keyword.

-Wno-multichar

Не выдавать предупреждение, если используется многосимвольный литерал (‘'FOOF'’). Обычно они указывают на опечатку в коде пользователя, так как имеют значения, определяемые реализацией, и не должны использоваться в переносимом коде.

-Wnormalized=[none|id|nfc|nfkc]

В ISO C и ISO C++ два идентификатора различны, если они представляют собой различные последовательности символов. Однако иногда, когда используются символы за пределами основного набора символов ASCII, у вас могут быть две разные последовательности символов, которые выглядят одинаково. Чтобы избежать путаницы, стандарт ISO 10646 устанавливает некоторые правила нормализации, которые, при применении, гарантируют, что две последовательности, которые выглядят одинаково, преобразуются в одну и ту же последовательность. GCC может предупредить вас, если вы используете идентификаторы, которые не были нормализованы; этот параметр контролирует это предупреждение.

GCC поддерживает четыре уровня предупреждений. По умолчанию установлен -Wnormalized=nfc, который предупреждает об любом идентификаторе, который не находится в нормализованной форме ISO 10646 «C», NFC. NFC является рекомендуемой формой для большинства случаев. Она эквивалентна -Wnormalized.

К сожалению, есть некоторые символы, разрешённые в идентификаторах ISO C и ISO C++, которые, после преобразования в NFC, не разрешены в идентификаторах. То есть нет способа использовать эти символы в переносимом ISO C или C++ и иметь все идентификаторы в NFC. -Wnormalized=id подавляет предупреждение для этих символов. Надеемся, что будущие версии стандартов исправят это, поэтому этот параметр не является по умолчанию.

Вы можете отключить предупреждение для всех символов, написав -Wnormalized=none или -Wno-normalized. Вы должны сделать это только в том случае, если вы используете какую-либо другую схему нормализации (например, «D»), так как иначе вы можете легко создать ошибки, которые буквально невозможно увидеть.

Некоторые символы в ISO 10646 имеют разные значения, но выглядят идентично в некоторых шрифтах или методах отображения, особенно после применения форматирования. Например \u207F, «SUPERSCRIPT LATIN SMALL LETTER N», отображается так же, как обычный n, который помещён в верхний индекс. ISO 10646 определяет схему нормализации NFKC для преобразования всех этих символов в стандартную форму, и GCC предупреждает, если ваш код не находится в NFKC, если вы используете -Wnormalized=nfkc. Это предупреждение сравнимо с предупреждением о каждом идентификаторе, который содержит букву O, потому что она может быть спутана с цифрой 0, и поэтому не является по умолчанию, но может быть полезным локальным соглашением программирования, если среда программирования не может быть исправлена для чёткого отображения этих символов.

-Wno-attribute-warning

Не выдавать предупреждение об использовании функций (см. Объявление атрибутов функций), объявленных с атрибутом warning. По умолчанию это предупреждение включено. -Wno-attribute-warning можно использовать для отключения предупреждения или -Wno-error=attribute-warning для отключения ошибки при компиляции с флагом -Werror.

-Wno-deprecated

Не выдавать предупреждение об использовании устаревших функций. См. Устаревшие функции.

-Wno-deprecated-declarations

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

-Wno-overflow

Не выдавать предупреждение о переполнении в выражениях констант во время компиляции.

-Wno-odr

Выдавать предупреждение о нарушениях правила одной дефиниции во время оптимизации на этапе компоновки. Включено по умолчанию.

-Wopenacc-parallelism

Предупреждать о потенциально неэффективных решениях, связанных с параллелизмом OpenACC.

-Wopenmp-simd

Предупреждать, если модель затрат векторизатора переопределяет директиву OpenMP simd, заданную пользователем. Опция -fsimd-cost-model=unlimited может быть использована для смягчения модели затрат.

-Woverride-init (C and Objective-C only)

Предупреждать, если инициализированное поле без побочных эффектов переопределяется при использовании обозначенных инициализаторов (см. Обозначенные инициализаторы).

Это предупреждение включено в -Wextra. Чтобы получить другие предупреждения -Wextra без этого, используйте -Wextra -Wno-override-init.

-Wno-override-init-side-effects (C and Objective-C only)

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

-Wpacked

Предупреждать, если структуре задан атрибут packed, но атрибут packed не оказывает влияния на расположение или размер структуры. Такие структуры могут быть неправильно выровнены с небольшим выигрышем. Например, в данном коде переменная f.x в struct bar выровнена неправильно, даже если у struct bar нет атрибута packed:

struct foo {
  int x;
  char a, b, c, d;
} __attribute__((packed));
struct bar {
  char z;
  struct foo f;
};

-Wnopacked-bitfield-compat

Серии GCC 4.1, 4.2 и 4.3 игнорируют атрибут packed для полей-битов типа char. Это было исправлено в GCC 4.4, но изменение может привести к различиям в расположении структуры. GCC информирует вас, когда смещение такого поля изменилось в GCC 4.4. Например, теперь между полем a и b в этой структуре нет 4-битного заполнения:

struct foo
{
  char a:4;
  char b:8;
} __attribute__ ((packed));

Это предупреждение включено по умолчанию. Используйте -Wno-packed-bitfield-compat для отключения этого предупреждения.

-Wpacked-not-aligned (C, C++, Objective-C and Objective-C++ only)

Предупреждать, если поле структуры с явно указанным выравниванием в структуре или объединении packed имеет неправильное выравнивание. Например, будет выдано предупреждение для struct S, как, warning: alignment 1 of 'struct S' is less than 8, в данном коде:

struct __attribute__ ((aligned (8))) S8 { char a[8]; };
struct __attribute__ ((packed)) S {
  struct S8 s8;
};

Это предупреждение включено с -Wall.

-Wpadded

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

-Wredundant-decls

Предупреждать, если что-либо объявлено более одного раза в одном области видимости, даже в тех случаях, когда многократное объявление допустимо и ничего не меняет.

-Wrestrict

Предупреждать, когда объект, на который ссылается параметр, квалифицированный как restrict, (или, в C++, параметр, квалифицированный как __restrict) дублируется другим аргументом, или когда копии между такими объектами перекрываются. Например, вызов функции strcpy ниже пытается обрезать строку, заменяя ее начальные символы последними четырьмя. Однако, поскольку вызов записывает завершающий NUL в a[4], копии перекрываются, и вызов диагностируется.

void foo (void)
{
  char a[] = "abcd1234";
  strcpy (a, a + 4);
  …
}

Опция -Wrestrict обнаруживает некоторые случаи простого перекрытия даже без оптимизации, но работает лучше при -O2 и выше. Она включена в -Wall.

-Wnested-externs (C and Objective-C only)

Предупреждать, если встречается объявление extern внутри функции.

-Winline

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

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

-Winterference-size

Предупреждать о использовании C++17 std::hardware_destructive_interference_size без указания его значения с --param destructive-interference-size. Также предупреждать о сомнительных значениях для этой опции.

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

struct independent_fields {
  alignas(std::hardware_destructive_interference_size)
    std::atomic<int> one;
  alignas(std::hardware_destructive_interference_size)
    std::atomic<int> two;
};

Здесь ‘one’ и ‘two’ должны быть достаточно далеко, чтобы сохранения в один не требовали доступа к другому для перезагрузки строки кэша.

По умолчанию, --param destructive-interference-size и --param constructive-interference-size устанавливаются на основе текущей опции -mtune, обычно на размер строки кэша L1 для конкретного целевого процессора, иногда на диапазон при настройке для общего целевого процессора. Поэтому все единицы трансляции, которые зависят от совместимости ABI для использования этих переменных, должны быть скомпилированы с той же -mtune (или -mcpu).

Если совместимость ABI важна, например, если использование находится в заголовочном файле для библиотеки, вы, вероятно, не должны использовать переменные размера аппаратного конфликта вообще. В качестве альтернативы, вы можете принудительно установить конкретное значение с --param.

Если вы уверены, что ваше использование переменной не влияет на ABI за пределами одной сборки вашего проекта, вы можете отключить предупреждение с -Wno-interference-size.

-Wint-in-bool-context

Предупреждать о подозрительном использовании целочисленных значений там, где ожидаются булевые значения, таких как условные выражения (?:) использующие целочисленные константы, не являющиеся булевыми, в булевом контексте, как if (a <= b ? 2 : 3). Или сдвиг влево целых со знаком в булевом контексте, как for (a = 0; 1 << a; a++);. Аналогично для всех видов умножений независимо от типа данных. Это предупреждение включено с -Wall.

-Wno-int-to-pointer-cast

Подавить предупреждения от преобразований к типу указателя целого числа другого размера. В C++, преобразование к типу указателя меньшего размера является ошибкой. Wint-to-pointer-cast включено по умолчанию.

-Wno-pointer-to-int-cast (C and Objective-C only)

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

-Winvalid-pch

Предупреждать, если предварительно скомпилированный заголовок (см. Использование предварительно скомпилированных заголовков) найден в пути поиска, но не может быть использован.

-Winvalid-utf8

Предупреждать, если найден недопустимый символ UTF-8. Это предупреждение включено по умолчанию для C++23, если используется -finput-charset=UTF-8, и превращается в ошибку с -pedantic-errors.

-Wno-unicode

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

-Wlong-long

Предупреждать, если используется тип long long. Это включено либо с -Wpedantic, либо с -Wtraditional в режимах ISO C90 и C++98. Чтобы отключить предупреждения, используйте -Wno-long-long.

-Wvariadic-macros

Предупреждать, если макросы с переменным количеством аргументов используются в режиме ISO C90 или если альтернативная синтаксическая конструкция GNU используется в режиме ISO C99. Это включено либо с -Wpedantic, либо с -Wtraditional. Чтобы отключить предупреждения, используйте -Wno-variadic-macros.

-Wno-varargs

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

-Wvector-operation-performance

Предупреждать, если векторная операция не реализована с помощью возможностей SIMD архитектуры. В основном полезно для настройки производительности. Векторная операция может быть реализована piecewise, что означает, что скалярная операция выполняется над каждым элементом вектора; in parallel, что означает, что векторная операция реализована с использованием скаляров более широкого типа, что обычно более эффективно с точки зрения производительности; и as a single scalar, что означает, что вектор помещается в скалярный тип.

-Wvla

Предупреждать, если в коде используется массив переменной длины. -Wno-vla предотвращает предупреждение -Wpedantic для массивов переменной длины.

-Wvla-larger-than=byte-size

Если эта опция используется, компилятор предупреждает о объявлениях массивов переменной длины, размер которых либо неограничен, либо ограничен аргументом, который позволяет размер массива превысить byte-size байт. Это аналогично тому, как работает -Walloca-larger-than=byte-size, но с массивами переменной длины.

Обратите внимание, что GCC может оптимизировать небольшие массивы переменной длины с известным значением в обычные массивы, поэтому это предупреждение может не срабатывать для таких массивов.

-Wvla-larger-than=‘PTRDIFF_MAX’ включено по умолчанию, но обычно эффективно только при активном -ftree-vrp (по умолчанию для -O2 и выше).

См. также -Walloca-larger-than=byte-size.

-Wno-vla-larger-than

Отключить предупреждения -Wvla-larger-than=. Опция эквивалентна -Wvla-larger-than=‘SIZE_MAX’ или больше.

-Wvla-parameter

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

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

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

void f (int n, int[n]);
// warning: argument 2 previously declared as a VLA
void f (int, int[]);

void g (int n)
{
    if (n > 4)
      return;
    int a[n];
    // warning: access to a by f may be out of bounds
    f (sizeof a, a);
  …
}

-Wvla-parameter включено в -Wall. Опция -Warray-parameter вызывает предупреждения для аналогичных проблем, связанных с обычными аргументами массивов.

-Wvolatile-register-var

Предупреждать, если переменная регистра объявлена как volatile. Модификатор volatile не препятствует всем оптимизациям, которые могут исключить чтение и/или запись переменных регистра. Это предупреждение включено по умолчанию с -Wall.

-Wxor-used-as-pow (C, C++, Objective-C and Objective-C++ only)

Предупреждать об использовании ^, оператора исключающего ИЛИ, где, по всей видимости, пользователь имел в виду возведение в степень. В частности, предупреждение возникает, когда левая часть — десятичная константа 2 или 10, а правая часть также является десятичной константой.

В C и C++ ^ означает операцию исключающего ИЛИ, в то время как в некоторых других языках (например, TeX и некоторых версиях BASIC) она означает возведение в степень.

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

-Wdisabled-optimization

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

-Wpointer-sign (C and Objective-C only)

Предупреждать о передаче или присваивании аргумента указателя с разной знаконостью. Эта опция поддерживается только для C и Objective-C. Она подразумевается -Wall и -Wpedantic, которые можно отключить с помощью -Wno-pointer-sign.

-Wstack-protector

Эта опция активна только при включённой -fstack-protector. Она предупреждает о функциях, которые не защищены от переполнения стека.

-Woverlength-strings

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

Предел применяется после конкатенации строковых констант и не учитывает завершающий нуль. В C90 предел составлял 509 символов; в C99 он был увеличен до 4095. C++98 не определяет нормативный минимальный максимальный предел, поэтому мы не диагностируем строки чрезмерной длины в C++.

Эта опция подразумевается -Wpedantic и может быть отключена с помощью -Wno-overlength-strings.

-Wunsuffixed-float-constants (C and Objective-C only)

Выдавать предупреждение для любой плавающей константы, у которой нет суффикса. При совместном использовании с -Wsystem-headers это предупреждение выдаётся для таких констант в заголовочных файлах системы. Это может быть полезно при подготовке кода для использования с FLOAT_CONST_DECIMAL64 pragma из расширения десятичной плавающей точки для C99.

-Wno-lto-type-mismatch

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

-Wno-designated-init (C and Objective-C only)

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

© Free Software Foundation
Licensed under the GNU Free Documentation License, Version 1.3.
https://gcc.gnu.org/onlinedocs/gcc-13.3.0/gcc/Warning-Options.html