Далее: Параметры, управляющие статическим анализом, Предыдущее: Параметры для управления форматированием диагностических сообщений, Вверх: Параметры командной строки GCC [Оглавление][Индекс]

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 более эффективен с оптимизацией на этапе компоновки, а -Wmaybe-uninitialized вообще не предупреждает, если оптимизация не включена.

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

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

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

Если стандарт, указанный с помощью -std, представляет собой расширенный диалект C GNU, такой как ‘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)  
-Wbool-compare  
-Wbool-operation  
-Wc++11-compat  -Wc++14-compat  
-Wcatch-value (C++ and Objective-C++ only)  
-Wchar-subscripts  
-Wcomment  
-Wduplicate-decl-specifier (C and Objective-C only) 
-Wenum-compare (in C/ObjC; this is on by default in C++) 
-Wenum-conversion in C/ObjC; 
-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++) 
-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  
-Wreorder   
-Wrestrict   
-Wreturn-type  
-Wsequence-point  
-Wsign-compare (only in C++)  
-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  
-Wvolatile-register-var  
-Wzero-length-bounds

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

-Wextra

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

-Wclobbered  
-Wcast-function-type  
-Wdeprecated-copy (C++ only) 
-Wempty-body  
-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. Это включает код, который может быть несовместим с нейтральной по поставщику ABI для C++, а также с 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.
Лямбда-функции в области аргумента по умолчанию были неправильно закодированы, и ABI изменила кодирование nullptr_t.
Эти проблемы были исправлены в -fabi-version=7.
При кодировании типа функции с квалификаторами типа функции неквалифицированный тип функции неправильно рассматривался как кандидат на подстановку.
Это было исправлено в -fabi-version=8, по умолчанию для GCC 5.1.
decltype(nullptr) неправильно имел выравнивание 1, что приводило к невыровненному доступу. Обратите внимание, что это не повлияло на ABI функции с параметром nullptr_t, так как у параметров есть минимальное выравнивание.
Это было исправлено в -fabi-version=9, по умолчанию для GCC 5.2.
Принадлежащие платформе атрибуты, влияющие на идентичность типа, такие как архитектура вызовов IA-32 для типа функции (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 теперь всегда передаётся в памяти.

-Wchar-subscripts

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

-Wno-coverage-mismatch

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

-Wno-cpp

(Только для C, Objective-C, C++, Objective-C++ и Fortran) Отключить сообщения предупреждений, выпущенные директивами #warning.

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

Выводить предупреждение, когда значение типа float неявно преобразуется в double. ЦП с 32-битным блоком обработки чисел с плавающей точкой «single-precision» реализуют 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, с null внутри функции.

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

-Wnull-dereference

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

-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 происходит «провал» (fallthrough) между случаями. Например:

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:
    …
  }

Поскольку в некоторых случаях «провал» (fallthrough) в операторе 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 and Objective-C++ only)

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

-Wno-missing-profile

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

-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.

-Wsequence-point

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

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

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

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

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

Стандарт сформулирован запутанно, поэтому существует некоторая дискуссия по поводу точного значения правил точек последовательности в тонких случаях. Ссылки на обсуждения этой проблемы, включая предлагаемые формальные определения, можно найти на странице GCC readings, по адресу http://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++2A (и новее) предупреждение не выдаётся, так как сдвиги влево со знаком всегда имеют переполнение.
-Wshift-overflow=2: Этот уровень предупреждений также предупреждает о сдвиге влево 1 в разряд знака, если не активен режим C++14 (или новее).

-Wswitch

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

-Wswitch-default

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

-Wswitch-enum

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

-Wno-switch-bool

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

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

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

-Wno-switch-outside-range

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

-Wno-switch-unreachable

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

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

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

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.

-Wunused-but-set-parameter

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

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

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

-Wunused-but-set-variable

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

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

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

-Wunused-function

Предупреждать при объявлении статической функции, но без определения, или при использовании не-встраиваемой статической функции без использования. Это предупреждение включено параметром -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

Предупреждать при использовании константной статической переменной без использования (кроме объявления). -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 член появляется в классе без конструкторов.

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

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

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

-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

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

Эти предупреждения возможны только при оптимизирующей компиляции, так как в противном случае 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 все равно нарушает код, так как у него очень мало ложных отрицаний. Однако у него много ложных срабатываний. Предупреждает для всех преобразований указателей между, возможно, несовместимыми типами, даже если они никогда не разыменовываются. Выполняется только на этапе анализа.

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

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

-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.

-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-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 выдает предупреждения, если не может доказать, что использование безопасно. См. Общие атрибуты переменных.

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

-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

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

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

-Wattribute-alias=n

-Wno-attribute-alias

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

-Wattribute-alias=1

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

-Wattribute-alias=2

На этом уровне -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.

-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;

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

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 некоторые директивы препроцессора не существовали. Традиционные препроцессоры считали строку директивой только если ‘#’ появлялся в столбце 1 строки. Поэтому -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 появляются в вашем коде при использовании макросов совместимости традиционного 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, но не если она затеняет struct/class/enum. Если это предупреждение включено, оно также включает в себя все случаи локального затенения. Это означает, что -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.

-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’ или больше.

-Wno-free-nonheap-object

Не выдавать предупреждение при попытке освободить объект, который не был выделен в куче.

-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.

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

-Wtype-limits

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

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

Выдавать предупреждение об обращениях к стандартным функциям, вычисляющим абсолютное значение аргумента, когда доступна более подходящая стандартная функция. Например, вызов abs(3.14) вызывает предупреждение, потому что для вычисления абсолютного значения двойного аргумента следует использовать функцию 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, операторе Alignof, ключевом слове _Generic и так далее. Этот параметр независим от режима стандартов. Предупреждения отключены в выражении, следующем за __extension__.

-Wc11-c2x-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.

-Wcast-qual

Выдавать предупреждение всякий раз, когда указатель приводится так, чтобы удалить квалификатор типа из целевого типа. Например, выдавать предупреждение, если 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.

-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.

-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, Objective-C only)

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

-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-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

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

-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-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)

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

void foo(bar) { }

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

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

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

-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-multichar

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

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

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

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

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

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

Некоторые символы в ISO 10646 имеют разные значения, но выглядят одинаково в некоторых шрифтах или методах отображения, особенно после применения форматирования. Например, \u207F, «СВЕРХУ УКАЗАТЕЛЬНЫЙ ЛАТИНСКИЙ МАЛЫЙ БУКВА 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

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

-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. Например, больше нет 4-битного заполнения между полем a и b в этой структуре:

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, не может быть оптимизирована как inline. Даже с этим параметром компилятор не выводит предупреждения об ошибках оптимизации inline функций, объявленных в системных заголовках.

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

-Wint-in-bool-context

Выводить предупреждение при подозрительном использовании целочисленных значений вместо логических значений, например, в условных выражениях (?:) с небулевыми целочисленными константами в булевом контексте, например, 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

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

-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’ или больше.

-Wvolatile-register-var

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

-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. Современные компиляторы, как правило, допускают строковые константы намного большей длины, чем минимальный предел стандарта, но очень переносимые программы должны избегать использования более длинных строк.

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

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

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

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

-Wno-lto-type-mismatch

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

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

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

-Wno-hsa

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

Далее: Параметры, контролирующие статический анализ, Предыдущее: Параметры для управления форматированием сообщений об ошибках, Вернуться к: Командные параметры GCC [Содержание][Индекс]

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