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

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

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

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

-pedantic-errors

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

-Wall

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

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

-Waddress   
-Warray-bounds=1 (only with -O2)  
-Warray-parameter=2 (C and Objective-C only) 
-Wbool-compare  
-Wbool-operation  
-Wc++11-compat  -Wc++14-compat  
-Wcatch-value (C++ and Objective-C++ only)  
-Wchar-subscripts  
-Wcomment  
-Wduplicate-decl-specifier (C and Objective-C only) 
-Wenum-compare (in C/ObjC; this is on by default in C++) 
-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  
-Wrange-loop-construct (only for C++)  
-Wreorder   
-Wrestrict   
-Wreturn-type  
-Wsequence-point  
-Wsign-compare (only in C++)  
-Wsizeof-array-div 
-Wsizeof-pointer-div 
-Wsizeof-pointer-memaccess 
-Wstrict-aliasing  
-Wstrict-overflow=1  
-Wswitch  
-Wtautological-compare  
-Wtrigraphs  
-Wuninitialized  
-Wunknown-pragmas  
-Wunused-function  
-Wunused-label     
-Wunused-value     
-Wunused-variable  
-Wvla-parameter (C and Objective-C only) 
-Wvolatile-register-var  
-Wzero-length-bounds

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

-Wextra

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

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

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

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

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

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

Поскольку G++ теперь по умолчанию обновляет ABI с каждой основной версией, обычно -Wabi предупреждает только об ошибках совместимости ABI C++ при добавлении проверки позднее в серии выпусков для проблемы 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) включают:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-Wmain

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

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

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

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

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

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

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

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

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

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

-Wmissing-attributes

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

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

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

-Wmissing-attributes включен с -Wall.

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

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

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

-Wmissing-braces

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

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

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

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

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

-Wno-missing-profile

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

-Wno-mismatched-dealloc

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

void mydealloc (void*);

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

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

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

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

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

-Wswitch

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

-Wswitch-default

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

-Wswitch-enum

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

-Wno-switch-bool

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

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

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

-Wno-switch-outside-range

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

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

-Wunused-label

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

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

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

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

-Wunused-parameter

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

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

-Wno-unused-result

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

-Wunused-variable

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

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

-Wunused-const-variable

-Wunused-const-variable=n

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

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

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

-Wunused-value

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

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

-Wunused

Все вышеперечисленные опции -Wunused объединены.

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

-Wuninitialized

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

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

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

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

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

-Wno-invalid-memory-model

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

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

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

-Wmaybe-uninitialized

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

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

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

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

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

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

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

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

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

-Wunknown-pragmas

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

-Wno-pragmas

Не выдавать предупреждений о неправильном использовании пragma, таких как неверные параметры, недопустимый синтаксис или конфликты между пragma. См. также -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.

-Wno-stringop-overflow

-Wstringop-overflow

-Wstringop-overflow=type

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

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

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

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

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

-Wno-stringop-overread

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

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

-Wno-stringop-truncation

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

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

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

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

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

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

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

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

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

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

-Warray-parameter

-Warray-parameter=n

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

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

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

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

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

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

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

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

-Wattribute-alias=n

-Wno-attribute-alias

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

-Wattribute-alias=1

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

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

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

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

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

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

-Wshadow

Предупреждать всякий раз, когда локальная переменная или объявление типа затеняет другую переменную, параметр, тип, член класса (в C++) или экземпляра переменной (в Objective-C) или встроенную функцию. Обратите внимание, что в C++, компилятор предупреждает, если локальная переменная затеняет явное typedef, но не если она затеняет 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.

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

-Wno-larger-than

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

-Wframe-larger-than=byte-size

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

-Wno-frame-larger-than

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

-Wno-free-nonheap-object

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

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

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

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

-Wtsan

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

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

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

-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

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

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

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

#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 C11, но присутствующих в ISO C2X. Например, предупреждать об опускании строки в _Static_assert, об использовании синтаксиса «[[]]» для атрибутов, об использовании десятичных типов с плавающей точкой и т. д. Этот параметр независим от режима стандартов. Предупреждения отключены в выражении, следующему за __extension__.

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

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

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

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

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

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

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

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

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

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

-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), когда 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

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

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

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

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

-Wsign-compare

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

-Wsign-conversion

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

-Wfloat-conversion

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

-Wno-scalar-storage-order

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

-Wsizeof-array-div

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

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

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

-Wsizeof-pointer-div

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

-Wsizeof-pointer-memaccess

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

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

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

-Wno-sizeof-array-argument

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

-Wmemset-elt-size

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

-Wmemset-transposed-args

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

-Waddress

Выводить предупреждение о подозрительных использованиях адресов памяти. Это включает в себя использование адреса функции в условном выражении, таком как void func(void); if (func), и сравнения с адресом памяти строковой литералы, например, if (x == "abc"). Такие использования обычно указывают на ошибку программиста: адрес функции всегда оценивается как истина, поэтому их использование в условном выражении обычно означает, что программист забыл скобки в вызове функции; а сравнения со строковыми литералами приводят к неопределённому поведению и не являются переносимыми на C, поэтому они обычно указывают на то, что программист намеревался использовать strcmp. Это предупреждение включено с помощью -Wall.

-Wno-address-of-packed-member

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

-Wlogical-op

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

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

-Wlogical-not-parentheses

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

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

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

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

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

-Waggregate-return

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

-Wno-aggressive-loop-optimizations

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

-Wno-attributes

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

-Wno-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++, поскольку все объявления функций предоставляют прототипы, а несоответствующее объявление объявляет перегрузку, а не конфликтует с более ранним объявлением. Используйте -Wmissing-declarations для обнаружения отсутствующих объявлений в C++.

-Wmissing-declarations

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

-Wmissing-field-initializers

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

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

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

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

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

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

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

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

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

-Wno-multichar

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

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

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

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

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

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

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

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

-Wint-in-bool-context

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

-Wno-int-to-pointer-cast

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

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

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

-Winvalid-pch

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

-Wlong-long

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

-Wvariadic-macros

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

-Wno-varargs

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

-Wvector-operation-performance

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

-Wvla

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

-Wvla-larger-than=byte-size

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

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

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

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

-Wno-vla-larger-than

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

-Wvla-parameter

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

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

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

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

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

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

-Wvolatile-register-var

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

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

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

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

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

-Wno-lto-type-mismatch

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

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

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

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

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