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

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

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

-fsyntax-only

Проверить код на синтаксические ошибки, но не выполнять никаких дальнейших действий.

-fmax-errors=n

Ограничивает максимальное количество сообщений об ошибках числом n, после достижения которого GCC аварийно завершает работу вместо попыток продолжить обработку исходного кода. Если n равно 0 (по умолчанию), ограничение на количество выводимых сообщений об ошибках отсутствует. Если также указан параметр -Wfatal-errors, то -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», например, -Wunused-variable для запроса предупреждений об объявлениях переменных, которые нигде не используются. У каждого из этих конкретных параметров предупреждений также есть отрицательная форма, начинающаяся с «-Wno-», для отключения предупреждений; например, -Wno-unused-variable. В этом руководстве приводится только одна из двух форм — та, которая не является по умолчанию включённой. Другие параметры, специфичные для конкретных языков, см. в разделах Параметры управления диалектом C++ и Параметры управления диалектами Objective-C и Objective-C++. Дополнительные предупреждения можно получить, включив статический анализатор; см. Параметры управления статическим анализом.

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

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

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

-Wpedantic

-pedantic

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

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

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

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

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

-pedantic-errors

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

Если требуется, чтобы обязательные диагностики, по умолчанию являющиеся предупреждениями, стали ошибками, но при этом вы не хотите включать диагностики -Wpedantic, можно указать -pedantic-errors -Wno-pedantic (или -pedantic-errors -Wno-error=pedantic, чтобы включить их, но только в виде предупреждений).

Некоторые обязательные диагностики по умолчанию являются ошибками, но их уровень можно понизить до предупреждений с помощью -fpermissive или их индивидуального параметра предупреждения, например, -Wno-error=narrowing.

Некоторые диагностики для конструкций, не соответствующих ISO, управляются специальными параметрами предупреждений, отличными от -Wpedantic, но также превращаются в ошибки с помощью -pedantic-errors. Например:

-Wattributes (for standard attributes)
-Wchanges-meaning (C++)
-Wcomma-subscript (C++23 or later)
-Wdeclaration-after-statement (C90 or earlier)
-Welaborated-enum-base (C++11 or later)
-Wimplicit-int (C99 or later)
-Wimplicit-function-declaration (C99 or later)
-Wincompatible-pointer-types
-Wint-conversion
-Wlong-long (C90 or earlier)
-Wmain
-Wnarrowing (C++11 or later)
-Wpointer-arith
-Wpointer-sign
-Wincompatible-pointer-types
-Wregister (C++17 or later)
-Wvla (C90 or earlier)
-Wwrite-strings (C++11 or later)

-fpermissive

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

-Wdeclaration-missing-parameter-type (C and Objective-C only)
-Wimplicit-function-declaration (C and Objective-C only)
-Wimplicit-int (C and Objective-C only)
-Wincompatible-pointer-types (C and Objective-C only)
-Wint-conversion (C and Objective-C only)
-Wnarrowing (C++ and Objective-C++ only)
-Wreturn-mismatch (C and Objective-C only)
-Wtemplate-body (C++ and Objective-C++ only)

Параметр -fpermissive включен по умолчанию для устаревших режимов языка C (-std=c89, -std=gnu89, -std=c90, -std=gnu90).

-Wall

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

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

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

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

-Wextra

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

-Wabsolute-value (only for C/ObjC)
-Walloc-size
-Wcalloc-transposed-args
-Wcast-function-type
-Wclobbered
-Wdangling-reference (C++ only)
-Wdeprecated-copy (C++ and Objective-C++ only)
-Wempty-body
-Wenum-conversion (only for C/ObjC)
-Wexpansion-to-defined
-Wignored-qualifiers  (only for C/C++)
-Wimplicit-fallthrough=3
-Wmaybe-uninitialized
-Wmissing-field-initializers
-Wmissing-parameter-name (C/ObjC only)
-Wmissing-parameter-type (C/ObjC only)
-Wold-style-declaration (C/ObjC only)
-Woverride-init (C/ObjC only)
-Wredundant-move (C++ and Objective-C++ only)
-Wshift-negative-value (in C++11 to C++17 and in C99 and newer)
-Wsign-compare (C++ and Objective-C++ only)
-Wsized-deallocation (C++ and Objective-C++ only)
-Wstring-compare
-Wtype-limits
-Wuninitialized
-Wunterminated-string-initialization
-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 для конкретной целевой платформы. Предупреждения последнего типа также отдельно управляются параметром -Wpsabi, который подразумевается параметром -Wabi.

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

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

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

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

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

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

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

Эти проблемы были исправлены в -fabi-version=6.
Лямбда-выражения в области видимости аргументов по умолчанию декорировались некорректно, а также в ABI изменилось декорирование nullptr_t.
Эти проблемы были исправлены в -fabi-version=7.
При декорировании типа функции с cv-квалификаторами функции неквалифицированный тип функции ошибочно рассматривался в качестве кандидата на подстановку.
Это было исправлено в -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.

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

-Wpsabi включает предупреждения об изменениях в ABI для конкретных процессоров, таких как изменения требований к выравниванию или способов передачи аргументов функций. На нескольких целевых платформах, включая AArch64, ARM, x86, MIPS, RS6000/PowerPC и S/390, эти детали менялись между различными версиями GCC и/или различными версиями стандартов языков C или C++ таким образом, что это влияло на бинарную совместимость скомпилированного кода. С помощью -Wpsabi GCC может обнаруживать потенциально несовместимые случаи использования и предупреждать о них.

-Wpsabi включен по умолчанию, а также подразумевается параметром -Wabi.

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

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

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

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

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

-Wchar-subscripts

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

-Wno-coverage-mismatch

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

-Wno-coverage-too-many-conditions

Предупреждать, если используется -fcondition-coverage, выражение содержит слишком много термов, и GCC прекращает вычисление покрытия. Вычисление покрытия прекращается, если в условии больше термов, чем бит в gcov_type_unsigned. Это предупреждение включено по умолчанию.

-Wno-coverage-too-many-paths

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

-Wno-coverage-invalid-line-number

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

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

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

Подавлять предупреждения, генерируемые директивами #warning.

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

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

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

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

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

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

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

-Wformat

-Wformat=n

Проверять вызовы printf, scanf и т.д., чтобы убедиться, что переданные аргументы имеют типы, соответствующие заданной строке формата, а преобразования, указанные в строке формата, имеют смысл. Сюда входят стандартные функции и другие функции, заданные атрибутами формата (см. Declaring Attributes of Functions), из семейств 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). См. Options Controlling C Dialect.

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

-Wno-musttail-local-addr

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

-Wmaybe-musttail-local-addr

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

int foo (int *);

int
bar (int *x)
{
  if (x[0] == 1)
    {
      int a = 42;
      foo (&a);
      /* Without the musttail attribute this call would not
         be tail called, because address of the a variable escapes
         and the second foo call could dereference it.  With the attribute
         the local variables are assumed to go out of scope immediately
         before the tail call instruction and the compiler warns about
         this.  */
      [[gnu::musttail]] return foo (nullptr);
    }
  else
    {
      {
        int a = 42;
        foo (&a);
      }
      /* The a variable isn't already in scope, so even when it
         escaped, even without musttail attribute it would be
         undefined behavior to dereference it and the compiler could
         turn this into a tail call.  No warning is diagnosed here.  */
      [[gnu::musttail]] return foo (nullptr);
    }
}

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

-Wnrvo (C++ and Objective-C++ only)

Предупреждать, если компилятор не исключает копирование из локальной переменной в возвращаемое значение функции в контексте, где это разрешено [class.copy.elision]. Это исключение копирования широко известно как Named Return Value Optimization (оптимизация именованного возвращаемого значения). Например, в приведенном ниже примере компилятор не может исключить копирование одновременно из v1 и v2, поэтому он не исключает ни одно из них.

std::vector<int> f()
{
  std::vector<int> v1, v2;
  // ...
  if (cond) return v1;
  else return v2; // warning: not eliding copy
}

-Winfinite-recursion

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

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

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

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

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

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

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

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

Этот параметр управляет предупреждениями, когда в объявлении не указан тип. Это предупреждение включено по умолчанию как ошибка в C99 и более поздних диалектах C, а также с помощью -Wall. Ошибку можно понизить до предупреждения с помощью -fpermissive (вместе с некоторыми другими ошибками) или только для этой ошибки с помощью -Wno-error=implicit-int.

Это предупреждение повышается до ошибки с помощью -pedantic-errors.

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

Этот параметр управляет предупреждениями, когда функция используется до её объявления. Это предупреждение включено по умолчанию как ошибка в C99 и более поздних диалектах C, а также с помощью -Wall. Ошибку можно понизить до предупреждения с помощью -fpermissive (вместе с некоторыми другими ошибками) или только для этой ошибки с помощью -Wno-error=implicit-function-declaration.

Это предупреждение повышается до ошибки с помощью -pedantic-errors.

-Wimplicit (C and Objective-C only)

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

-Whardened

Предупреждать, если -fhardened не включил параметр из своего набора (о котором см. -fhardened). Например, одновременное использование -fhardened и -fstack-protector в командной строке приводит к выдаче предупреждения -Whardened, поскольку -fstack-protector-strong не будет включен с помощью -fhardened.

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

-Wimplicit-fallthrough

-Wimplicit-fallthrough эквивалентно -Wimplicit-fallthrough=3, а -Wno-implicit-fallthrough эквивалентно -Wimplicit-fallthrough=0.

-Wimplicit-fallthrough=n

Предупреждать о проваливании (fallthrough) ветви switch. Например:

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

Это предупреждение не выдается, если последний оператор ветви case не может провалиться, например, при наличии оператора 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 и C23 предусмотрен стандартный способ подавления предупреждения -Wimplicit-fallthrough с помощью [[fallthrough]]; вместо атрибута GNU. В C++11 или C++14 пользователи могут использовать [[gnu::fallthrough]];, являющийся расширением GNU. Вместо этих атрибутов также можно добавить комментарий о проваливании, чтобы заглушить предупреждение. Всё тело комментария в стиле C или C++ должно соответствовать указанным ниже регулярным выражениям. Аргумент параметра n указывает, какие типы комментариев принимаются:

-Wimplicit-fallthrough=0 полностью отключает предупреждение.
-Wimplicit-fallthrough=1 сопоставляется с регулярным выражением .*; любой комментарий используется как комментарий о проваливании.
-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 не распознаёт никакие комментарии как комментарии о проваливании, предупреждение отключают только атрибуты.

После комментария (и возможных пробельных символов и других комментариев) должны следовать ключевые слова 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 должна быть функцией с внешним связыванием (external linkage), возвращающей int и принимающей ноль, два или три аргумента соответствующих типов. Это предупреждение включено по умолчанию в C++ и включается параметрами -Wall или -Wpedantic.

Это предупреждение повышается до ошибки с помощью -pedantic-errors.

-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

Предупреждать, если в объявлении функции отсутствует один или несколько атрибутов, с которыми объявлена связанная функция, и отсутствие которых может отрицательно повлиять на корректность или эффективность генерируемого кода. Например, предупреждение выдается для объявлений псевдонимов (aliases), которые используют атрибуты для задания менее строгих требований, чем у их целей. Обычно это представляет собой потенциальную возможность оптимизации. Напротив, параметр -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 подавляют это предупреждение. (см. Declaring Attributes of Functions).

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

-Wmissing-attributes включается с помощью -Wall.

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

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

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

-Wmissing-braces

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

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

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

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

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

-Wno-missing-profile

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

-Wmismatched-dealloc

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

void mydealloc (void*);

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

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

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

Параметр -Wmismatched-dealloc включен в -Wall.

-Wmultistatement-macros

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

Например:

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

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

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

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

-Wparentheses

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

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

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

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

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

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

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

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

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

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

-Wsequence-point

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

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

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

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

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

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

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

-Wno-return-local-addr

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

-Wreturn-mismatch

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

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

Это предупреждение специфично для C и включено по умолчанию. В C99 и более поздних диалектах языка оно трактуется как ошибка. Его можно понизить до предупреждения с помощью -fpermissive (вместе с другими предупреждениями) или только для этого предупреждения с помощью -Wno-error=return-mismatch.

-Wreturn-type

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

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

-Wswitch

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

-Wswitch-default

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

-Wswitch-enum

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

-Wno-switch-bool

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

-Wtrivial-auto-var-init

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

-Wunused-but-set-parameter

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

Для подавления этого предупреждения используйте атрибут unused (см. Specifying Attributes of Variables).

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

-Wunused-but-set-variable

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

Для подавления этого предупреждения используйте атрибут unused (см. Specifying Attributes of Variables).

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

-Wunused-function

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

-Wunused-label

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

Для подавления этого предупреждения используйте атрибут unused (см. Specifying Attributes of Variables).

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

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

-Wunused-parameter

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

Для подавления этого предупреждения используйте атрибут unused (см. Specifying Attributes of Variables).

-Wno-unused-result

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

-Wunused-variable

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

Для подавления этого предупреждения используйте атрибут unused (см. Specifying Attributes of Variables).

-Wunused-const-variable

-Wunused-const-variable=n

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

Для подавления этого предупреждения используйте атрибут unused (см. Specifying Attributes of Variables).

-Wunused-const-variable=1

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

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

-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 и/или -Wunused-but-set-parameter.

Параметр -Wunused включает только -Wunused-const-variable=1, а не -Wunused-const-variable, и только для языка C, но не C++.

-Wuse-after-free (C, Objective-C, C++ and Objective-C++ only)

-Wuse-after-free=n

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

-Wuse-after-free=1

На уровне 1 предупреждение пытается диагностировать только безусловные использования указателей, сделанных неопределёнными вызовом деаллокации или успешным вызовом realloc, независимо от того, привёл ли вызов к фактическому перераспределению памяти. Сюда входят повторные вызовы free, а также использование в арифметических выражениях и операциях сравнения. Несмотря на то, что это приводит к неопределённому поведению, использование неопределённых указателей в выражениях проверки на равенство (или неравенство) на этом уровне не диагностируется.

-Wuse-after-free=2

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

struct A { int refcount; void *data; };

void release (struct A *p)
{
  int refcount = --p->refcount;
  free (p);
  if (refcount == 0)
    free (p->data);   // warning: p may be used after free
}

-Wuse-after-free=3

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

void adjust_pointers (int**, int);

void grow (int **p, int n)
{
  int **q = (int**)realloc (p, n *= 2);
  if (q == p)
    return;
  adjust_pointers ((int**)q, n);
}

Чтобы избежать предупреждения на этом уровне, сохраняйте смещения в выделенной памяти вместо указателей. Такой подход устраняет необходимость корректировать сохранённые указатели после перераспределения памяти.

Параметр -Wuse-after-free=2 включён в -Wall.

-Wuseless-cast (C, Objective-C, C++ and Objective-C++ only)

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

struct S { };
void g (S&&);
void f (S&& arg)
{
  g (S(arg)); // make arg prvalue so that it can bind to S&&
}

-Wuninitialized

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

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

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

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

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

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

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

-Wno-invalid-memory-model

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

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 этого не знает. Чтобы подавить предупреждение, необходимо добавить ветку default с assert(0) или аналогичным кодом.

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

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

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

-Wunknown-pragmas

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

-Wno-pragmas

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

-Wno-pragma-once-outside-header

Не предупреждать, когда #pragma once используется в файле, который не является заголовочным (например, в главном файле с кодом).

-Wno-prio-ctor-dtor

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

-Wstrict-aliasing

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

-Wstrict-aliasing=n

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

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

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

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

-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, переполняющих целевой буфер. Необязательный аргумент на единицу больше типа проверки размера объекта (Object Size Checking), используемого для определения размера целевого объекта. См. Object Size Checking. Аргумент имеет смысл только для строковых функций, работающих с массивами символов; функции работы с сырой памятью, такие как memcpy, всегда используют нулевой тип проверки размера объектов.

Параметр также предупреждает о вызовах, указывающих размер, превышающий максимально возможный объект или самое большее SIZE_MAX / 2 байт.

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

Например, параметр выдаёт предупреждение для вызова 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
}

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

void f (int[static 4]);

void g (void)
{
  int *p = (int *) malloc (1 * sizeof(int));
  f (p);   // warning here
}

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

-Wstringop-overflow
-Wstringop-overflow=1: Параметр -Wstringop-overflow=1 использует нулевой тип проверки размера объектов для определения размеров целевых объектов. При этой настройке параметр не предупреждает о записи за пределы подобъектов более крупных объектов, к которым осуществляется доступ по указателям, если размер наибольшего окружающего объекта неизвестен. Когда целевым может быть один из нескольких объектов, предполагается, что это наибольший из них. В системах Linux при включённой оптимизации с этой настройкой параметр выдаёт предупреждения для того же кода, что и при определении макроса _FORTIFY_SOURCE с ненулевым значением.
-Wstringop-overflow=2: Параметр -Wstringop-overflow=2 использует первый тип проверки размера объектов для определения размеров целевых объектов. При этой настройке параметр предупреждает о переполнениях при записи в члены наибольших полных объектов, точный размер которых известен. Однако он не предупреждает об избыточной записи в те же члены неизвестных объектов, на которые ссылаются указатели, поскольку они могут указывать на массивы с неизвестным количеством элементов. Это настройка параметра по умолчанию.
-Wstringop-overflow=3: Параметр -Wstringop-overflow=3 использует второй тип проверки размера объектов для определения размеров целевых объектов. При этой настройке параметр предупреждает о переполнении наименьшего объекта или поля данных. Это наиболее строгое значение параметра, которое может приводить к предупреждениям для безопасного кода.
-Wstringop-overflow=4: Параметр -Wstringop-overflow=4 использует третий тип проверки размера объектов для определения размеров целевых объектов. При этой настройке параметр предупреждает о переполнении любых полей данных, а если целевой объект может быть одним из нескольких, то для принятия решения о выдаче предупреждения используется размер наибольшего из них. Аналогично -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 выдаёт предупреждения, если не может доказать безопасность использования. См. Common Variable Attributes.

-Wstrict-flex-arrays (C and C++ only)

Предупреждать о некорректном использовании гибких членов-массивов (flexible array members) в соответствии с уровнем (level) атрибута strict_flex_array (level), прикреплённого к завершающему полю-массиву структуры (если он указан), либо в соответствии со значением level параметра -fstrict-flex-arrays=level. См. Common Variable Attributes для получения дополнительной информации об атрибуте и Options Controlling C Dialect для получения информации о параметре. Параметр -Wstrict-flex-arrays действует только тогда, когда level больше 0.

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

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

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

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

-Wsuggest-attribute=attribute-name

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

-Wsuggest-attribute=pure

-Wsuggest-attribute=const

-Wsuggest-attribute=noreturn

-Wmissing-noreturn

-Wsuggest-attribute=malloc

-Wsuggest-attribute=returns_nonnull

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

-Wsuggest-attribute=format

-Wmissing-format-attribute

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

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

-Wsuggest-attribute=cold

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

-Walloc-size

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

-Walloc-zero

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

-Wcalloc-transposed-args

Предупреждать о вызовах функций выделения памяти с двумя аргументами, помеченных атрибутом alloc_size, в которых оператор sizeof используется в качестве первого аргумента размера и не используется во втором аргументе размера. Это предупреждение стиля кодирования. В документации к calloc указано, что первый аргумент — это количество элементов в массиве, а второй аргумент — размер каждого элемента, поэтому calloc (n, sizeof (int)) предпочтительнее calloc (sizeof (int), n). Если использование sizeof в первом аргументе, а не во втором, сделано намеренно, предупреждение можно подавить с помощью calloc (sizeof (struct S) + 0, n) или calloc (1 * sizeof (struct S), 4) либо используя sizeof также и во втором аргументе.

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

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

-Wno-alloc-size-larger-than

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

-Walloca

Этот параметр предупреждает обо всех случаях использования alloca в исходном коде.

-Walloca-larger-than=byte-size

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

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

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

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

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

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

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

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

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

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

Этот параметр также предупреждает, когда alloca используется в цикле.

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

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

-Wno-alloca-larger-than

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

-Warith-conversion

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

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

-Warray-bounds

-Warray-bounds=n

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

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

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

когда level<=1, поведение по умолчанию не меняется.

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

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

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

-Wunterminated-string-initialization (C and Objective-C only)

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

char arr[3] = "foo"; /* Warning.  */
char arr2[3] __attribute__((nonstring)) = "bar"; /* No warning.  */

Это предупреждение включается параметром -Wextra. Если включен -Wc++-compat, предупреждение имеет несколько иную формулировку и выдается даже тогда, когда инициализируемое объявление имеет предупреждение nonstring, поскольку в C++ такие инициализации являются ошибкой.

-Warray-compare

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

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

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

-Warray-parameter

-Warray-parameter=n

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

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

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

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

void g (void)
{
  int *p = (int *)malloc (1 * sizeof (int));
  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 вызывает предупреждения о похожих несоответствиях, связанных с аргументами-массивами переменной длины (VLA).

Краткая форма параметра -Warray-parameter эквивалентна -Warray-parameter=2. Отрицательная форма -Wno-array-parameter эквивалентна -Warray-parameter=0.

-Wattribute-alias=n

-Wno-attribute-alias

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

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

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

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

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

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

-Wbool-compare

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

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

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

-Wbool-operation

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

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

-Wduplicated-branches

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

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

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

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

По умолчанию в C99 и более поздних диалектах C GCC рассматривает эту проблему как ошибку. Эту ошибку можно понизить до предупреждения с помощью -fpermissive (наряду с некоторыми другими ошибками) или только для этой ошибки с помощью -Wno-error=incompatible-pointer-types.

Это предупреждение повышается до ошибки с помощью -pedantic-errors.

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

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

Это предупреждение повышается до ошибки с помощью -pedantic-errors.

-Wzero-as-null-pointer-constant

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

-Wzero-length-bounds

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

Например, первые две операции сохранения в функции 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 совместно с этим параметром не предупреждает о неизвестных директивах pragma в системных заголовках — для этого также должен использоваться параметр -Wunknown-pragmas.

-Wtautological-compare

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

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

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

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

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

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

-Wtrailing-whitespace

-Wtrailing-whitespace=kind

Предупреждать о висячих пробельных символах в конце строк, в том числе внутри комментариев, но исключая пробелы в конце строк внутри «сырых» строковых литералов. -Wtrailing-whitespace эквивалентен -Wtrailing-whitespace=blanks и предупреждает только о висячих пробелах и символах горизонтальной табуляции. -Wtrailing-whitespace=any предупреждает о них или о висячих символах перевода страницы или вертикальной табуляции. -Wno-trailing-whitespace или -Wtrailing-whitespace=none отключает предупреждение, что является поведением по умолчанию. Это предупреждение о стиле кодирования.

-Wleading-whitespace=kind

Предупреждать о проблемах со стилем в начальных пробельных символах строки, но не о величине отступа. В некоторых проектах используется стиль кодирования, при котором для отступов применяются только пробелы, в других — только табуляции, в третьих — ноль или более табуляций (для величин, кратных -ftabstop=n), за которыми следует ноль или менее n пробелов. Предупреждение не выдается для строк, содержащих исключительно пробельные символы (хотя может быть выдано предупреждение -Wtrailing-whitespace=), и предупреждения не выдаются внутри необработанных строковых литералов. Предупреждения также выдаются для начальных пробельных символов внутри многострочных комментариев. -Wleading-whitespace=spaces предупреждает о начальных пробельных символах, отличных от пробелов, для проектов, где отступы должны формироваться только пробелами. -Wleading-whitespace=tabs предупреждает о начальных пробельных символах, отличных от горизонтальных табуляций, для проектов, где отступы должны формироваться только горизонтальными табуляциями. -Wleading-whitespace=blanks предупреждает о начальных пробельных символах, отличных от пробелов и горизонтальных табуляций, или о наличии табуляции после пробела в начальных пробельных символах, либо о n или более идущих подряд пробелах в начале строки (где n — аргумент -ftabstop=n, по умолчанию 8). -Wleading-whitespace=none отключает предупреждение, что является поведением по умолчанию. Это предупреждение о стиле кодирования.

-Wtrampolines

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

-Wfloat-equal

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

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

-Wtraditional (C and Objective-C only)

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

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

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

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

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

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

Это предупреждение повышается до ошибки с помощью -pedantic-errors.

-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’ или большему значению.

-Wfree-nonheap-object

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

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

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

-Wstack-usage=byte-size

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

Сообщение согласуется с выводом опции -fstack-usage.

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

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

-Wno-stack-usage

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

-Wunsafe-loop-optimizations

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

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

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

-Wpointer-arith

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

Это предупреждение преобразуется в ошибку при использовании -pedantic-errors.

-Wno-pointer-compare

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

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

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

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

-Wno-tsan

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

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

-Wtype-limits

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

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

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

-Wcomment

-Wcomments

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

-Wtrigraphs

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

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

-Wundef

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

-Wexpansion-to-defined

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

-Wunused-macros

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

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

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

#if defined the_macro_causing_the_warning
#endif

-Wno-endif-labels

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

#if FOO
…
#else FOO
…
#endif FOO

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

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

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

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

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

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

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

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

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

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

При компиляции не в режиме C23 эти предупреждения преобразуются в ошибки с помощью -pedantic-errors.

-Wc23-c2y-compat (C and Objective-C only)

Предупреждать о возможностях, отсутствующих в ISO C23, но присутствующих в ISO C2Y. Например, предупреждать о выборе в _Generic с именем типа вместо выражения. Эта опция не зависит от режима стандарта. Предупреждения отключаются в выражении, следующем за __extension__.

При компиляции не в режиме C2Y эти предупреждения преобразуются в ошибки с помощью -pedantic-errors.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-Wcast-user-defined

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

struct A { operator const int&(); } a;
auto r = (int&)a; // warning

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

-Wwrite-strings

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

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

Это предупреждение преобразуется в ошибку при использовании -pedantic-errors в режиме C++11 или новее.

-Wclobbered

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

-Wno-complain-wrong-lang

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

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

Драйвер g++ вызывает фронтенд C++ для компиляции a.cc и фронтенд Fortran для компиляции b.f90. Последний фронтенд выдаёт диагностическое сообщение ‘f951: Warning: command-line option '-fno-rtti' is valid for C++/D/ObjC++ but not for Fortran’, которое можно отключить с помощью -Wno-complain-wrong-lang.

-Wcompare-distinct-pointer-types (C and Objective-C only)

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

-Wconversion

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

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

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

-Wdangling-else

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

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

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

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

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

-Wdangling-pointer

-Wdangling-pointer=n

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

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

Краткая форма -Wdangling-pointer эквивалентна -Wdangling-pointer=2, тогда как -Wno-dangling-pointer и -Wdangling-pointer=0 одинаково отключают эти предупреждения. -Wdangling-pointer=2 включена в -Wall.

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

char f (char c1, char c2, char c3)
{
  char *p;
  {
    p = (char[]) { c1, c2, c3 };
  }
  // warning: using dangling pointer 'p' to an unnamed temporary
  return *p;
}

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

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

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

extern void frob (const char *);
void h (char *s)
{
  if (!s)
    {
      char a[12] = "tmpname";
      s = a;
    }
  // warning: dangling pointer 's' to 'a' may be used
  frob (s);
}

-Wdate-time

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

-Wempty-body

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

-Wno-endif-labels

Не предупреждать о лишних лексемах после #else и #endif.

-Wenum-compare

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

-Wenum-conversion

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

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

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

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

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

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

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

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

-Wsign-compare

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

-Wsign-conversion

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

-Wflex-array-member-not-at-end (C and C++ only)

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

struct flex  { int length; char data[]; };
struct mid_flex { int m; struct flex flex_data; int n; };

-Wfloat-conversion

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

-Wno-scalar-storage-order

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

-Wsizeof-array-div

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

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

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

-Wsizeof-pointer-div

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

-Wsizeof-pointer-memaccess

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

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

Опция -Wsizeof-pointer-memaccess включается опцией -Wall.

-Wno-sizeof-array-argument

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

-Wmemset-elt-size

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

-Wmemset-transposed-args

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

-Waddress

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

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

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

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

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

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

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

-Wno-address-of-packed-member

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

-Wlogical-op

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

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

-Wlogical-not-parentheses

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

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

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

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

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

-Waggregate-return

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

-Wno-aggressive-loop-optimizations

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

-Wno-attributes

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

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

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

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

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

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

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

-Wno-builtin-declaration-mismatch

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

-Wfree-labels (C and Objective-C only)

Предупреждать, если метка применяется к выражению, не являющемуся оператором (non-statement), или находится в конце составного оператора. Такие метки разрешены в C23 и более поздних диалектах C, а также доступны в качестве расширения GCC во всех остальных диалектах.

Это предупреждение также включается параметром -Wc11-c23-compat. При сборке для версии C до C23 оно превращается в ошибку с помощью -pedantic-errors.

-Wheader-guard

Предупреждать, если корректный препроцессорный страж от повторного включения заголовочного файла содержит директиву #define сразу после директивы #ifndef или #if !defined для стража включения, которая определяет отличный от стража макрос с похожим именем, сам макрос стража повторного включения не определён в соответствующей директиве #ifndef в конце заголовочного файла, а директива #define определяет объектно-подобный макрос с пустым определением. В таком случае это часто опечатка в имени стража — либо в директиве #ifndef или #if !defined, либо в последующей директиве #define. Это предупреждение включается параметром -Wall.

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

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

-Wdeprecated-non-prototype (C and Objective-C only)

Предупреждать, если функция, объявленная с пустым списком параметров ‘()’, вызывается с одним или несколькими аргументами, или если после такого объявления встречается определение функции с одним или несколькими параметрами. Оба случая являются ошибками в C23 и более поздних диалектах C.

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

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

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

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

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

void foo(bar) { }

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

-Wno-declaration-missing-parameter-type (C and Objective-C only)

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

Это предупреждение включено по умолчанию. В C99 и более поздних диалектах C оно считается ошибкой. Ошибку можно понизить до предупреждения с помощью -fpermissive (вместе с некоторыми другими ошибками) или только для этой ошибки с помощью -Wno-error=declaration-missing-parameter-type.

Это предупреждение повышается до ошибки с помощью -pedantic-errors.

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

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

-Wmissing-variable-declarations (C and Objective-C only)

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

-Wmissing-declarations

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

-Wmissing-field-initializers

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

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

В C этот параметр не предупреждает о назначенных инициализаторах (designated initializers), поэтому следующая модификация не вызывает предупреждения:

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

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

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

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

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

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

-Wno-missing-requires

По умолчанию компилятор предупреждает о появлении идентификатора концепта (concept-id) в качестве простого требования (simple-requirement) C++20:

bool satisfied = requires { C<T> };

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

bool satisfied = requires { requires C<T> };

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

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

-Wno-missing-template-keyword

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

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

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

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

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

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

-Wno-multichar

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

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

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

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

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

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

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

-Wno-attribute-warning

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

-Wno-deprecated

Не предупреждать об использовании устаревших (deprecated) возможностей. См. Устаревшие возможности.

В C++ явное указание -Wdeprecated также включает предупреждения о некоторых возможностях, объявленных устаревшими в более поздних стандартах языка, в частности -Wcomma-subscript, -Wvolatile, -Wdeprecated-enum-float-conversion, -Wdeprecated-enum-enum-conversion, -Wdeprecated-literal-operator и -Wdeprecated-variadic-comma-omission.

-Wno-deprecated-declarations

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

-Wno-overflow

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

-Wno-odr

Предупреждать о нарушениях правила одного определения (One Definition Rule) во время оптимизации на этапе компоновки (LTO). Включено по умолчанию.

-Wopenacc-parallelism

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

-Wno-openmp

Предупреждать о подозрительном коде OpenMP.

-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-битового заполнения (padding) между полями 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 / union) имеет нарушенное выравнивание. Например, в этом коде предупреждение будет выдано для 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

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

-Wredundant-decls

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

-Wrestrict

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

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

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

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

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

-Winline

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

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

-Winterference-size

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

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

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

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

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

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

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

-Wint-in-bool-context

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

-Wno-int-to-pointer-cast

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

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

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

-Winvalid-pch

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

-Winvalid-utf8

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

-Wno-unicode

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

-Wlong-long

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

Это предупреждение повышается до ошибки с помощью -pedantic-errors.

-Wvariadic-macros

Предупреждать, если макросы с переменным числом аргументов (variadic 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

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

Это предупреждение повышается до ошибки с помощью -pedantic-errors.

-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

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

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

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

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

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

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

-Wvolatile-register-var

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

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

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

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

Это предупреждение можно отключить путём преобразования одного из операндов в шестнадцатеричный вид, а также компиляцией с параметром -Wno-xor-used-as-pow.

-Wdisabled-optimization

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

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

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

Это предупреждение повышается до ошибки с помощью -pedantic-errors.

-Wstack-protector

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

-Woverlength-strings

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

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

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

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

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

-Wno-lto-type-mismatch

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

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

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

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