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

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

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

-fsyntax-only

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

-fmax-errors=n

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

-w

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

-Werror

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

-Werror=

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

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

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

-Wfatal-errors

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

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

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

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

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

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

-Wpedantic

-pedantic

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

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

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

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

Если стандарт, указанный с помощью -std, представляет собой расширенный диалект C от GNU, такой как «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.

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

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

-Wall

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

-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
-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-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
-Wunused-parameter (only with -Wunused or -Wall)
-Wunused-but-set-parameter (only with -Wunused or -Wall)

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

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

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

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

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

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

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

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

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

• Шаблон с нетиповым параметром-ссылкой неправильно был искажён:

  extern int N;
  template <int &> struct S {};
  void n (S<N>) {2}

  Это было исправлено в -fabi-version=3.

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

  Искажение было изменено в -fabi-version=4.

• __attribute ((const)) и noreturn были искажены как квалификаторы типа, и decltype обычного объявления было убрано.

  Эти проблемы с искажением были исправлены в -fabi-version=5.

• Объявленные перечислители передаются в качестве аргументов вариационной функции, подобно необъявленным перечислителям, вызывая va_arg жаловаться. На большинстве платформ это фактически не влияет на ABI передачи аргументов, так как нет способа передать аргумент меньше, чем int.

  Также ABI изменил искажение пакетов аргументов шаблонов, const_cast, static_cast, префиксную инкрементацию/декрементацию и функцию области класса, используемую в качестве параметра шаблона.

  Эти проблемы были исправлены в -fabi-version=6.

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

  Эти проблемы были исправлены в -fabi-version=7.

• При искажении типа функции с квалификаторами типа функции неквалифицированный тип функции неправильно обрабатывался как кандидат для подстановки.

  Это было исправлено в -fabi-version=8, значение по умолчанию для GCC 5.1.

• decltype(nullptr) неправильно имел выравнивание 1, что приводило к невыровненным доступам. Обратите внимание, что это не повлияло на ABI функции с параметром nullptr_t, так как параметры имеют минимальное выравнивание.

  Это было исправлено в -fabi-version=9, значение по умолчанию для GCC 5.2.

• Платформозависимые атрибуты, которые влияют на идентичность типа, такие как правила вызова ia32 для типа функции (stdcall, regparm и т.д.), не влияли на искажённое имя, что приводило к конфликтам имён при использовании указателей на функции в качестве параметров шаблона.

  Это было исправлено в -fabi-version=10, значение по умолчанию для GCC 6.1.

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

• Для SysV/x86-64 союзы с long double членами передаются в памяти, как указано в psABI. До GCC 4.4 этого не было. Например:

  union U {
    long double ld;
    int i;
  };

  union U теперь всегда передается в памяти.

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

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

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

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

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

-Wchar-subscripts

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

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

-Wno-coverage-mismatch

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

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

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

-Wno-coverage-too-many-conditions

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

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

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

-Wformat=1

-Wformat

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

-Wformat=2

Включить -Wformat плюс дополнительные проверки формата. В настоящее время эквивалентно -Wformat -Wformat-nonliteral -Wformat-security -Wformat-y2k.

-Wno-format-contains-nul

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

-Wno-format-extra-args

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

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

-Wformat-overflow

-Wformat-overflow=level

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

-Wformat-overflow

-Wformat-overflow=1

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

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

-Wformat-overflow=2

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

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

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

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

-Wno-format-zero-length

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

-Wformat-nonliteral

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

-Wformat-security

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

-Wformat-signedness

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

-Wformat-truncation

-Wformat-truncation=level

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

-Wformat-truncation

-Wformat-truncation=1

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

-Wformat-truncation=2

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

-Wformat-y2k

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

-Wnonnull

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

-Wnonnull включена в -Wall и -Wformat. Она может быть отключена с помощью параметра -Wno-nonnull.

-Wnonnull-compare

Предупреждать при сравнении аргумента, помеченного атрибутом функции nonnull с нулем внутри функции.

-Wnonnull-compare включена в -Wall. Она может быть отключена с помощью параметра -Wno-nonnull-compare.

-Wnull-dereference

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

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

Предупреждение, если компилятор не исключает копирование из локальной переменной в возвращаемое значение функции в контексте, где это разрешено [class.copy.elision]. Это исключение известно как оптимизация имени возвращаемого значения. Например, в примере ниже компилятор не может исключить копии из 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

Предупреждение, когда ветка switch переходит к следующей. Например:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-Wmain

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

Это предупреждение повышается до ошибки с помощью -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

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

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

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

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

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

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

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

-Wmissing-braces

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

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

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

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

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

-Wno-missing-profile

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

-Wmismatched-dealloc

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

void mydealloc (void*);

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

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

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

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

-Wmultistatement-macros

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

Например:

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

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

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

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

-Wparentheses

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

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

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

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

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

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

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

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

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

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

-Wsequence-point

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

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

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

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

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

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

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

-Wno-return-local-addr

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

-Wreturn-mismatch

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

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

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

-Wreturn-type

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

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

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

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

-Wno-shift-count-negative

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

-Wno-shift-count-overflow

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

-Wshift-negative-value

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

-Wno-shift-overflow

-Wshift-overflow=n

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

-Wshift-overflow=1

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

-Wshift-overflow=2

Этот уровень предупреждений также предупреждает о сдвиге влево 1 в бит знака, если не активен режим C++14 (или новее).

-Wswitch

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

-Wswitch-default

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

-Wswitch-enum

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

-Wno-switch-bool

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

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

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

-Wno-switch-outside-range

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

-Wno-switch-unreachable

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

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

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

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

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

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

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

-Wtrivial-auto-var-init

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

-Wunused-but-set-parameter

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

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

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

-Wunused-but-set-variable

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

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

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

-Wunused-function

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

-Wunused-label

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

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

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

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

-Wunused-parameter

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

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

-Wno-unused-result

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

-Wunused-variable

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

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

-Wunused-const-variable

-Wunused-const-variable=n

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

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

-Wunused-const-variable=1

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

-Wunused-const-variable=1 включен с помощью -Wunused-variable или -Wunused для C, но не для C++. В C это объявляет хранение переменной, но в C++ это не ошибка, так как константные переменные выполняют роль #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 в попытке определить, привело ли это к перемещению объекта в другой адрес. Они диагностируются на отдельном уровне, чтобы помочь постепенно перевести legacy-код на безопасные альтернативы. Например, тест на равенство в функции ниже диагностируется на этом уровне:

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

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

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

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

-Wmaybe-uninitialized

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

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

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

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

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

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

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

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

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

-Wunknown-pragmas

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

-Wno-pragmas

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

-Wno-prio-ctor-dtor

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

-Wstrict-aliasing

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

-Wstrict-aliasing=n

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

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

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

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

-Wstrict-overflow

-Wstrict-overflow=n

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

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

-Wstrict-overflow=1

Предупреждать о случаях, которые являются одновременно сомнительными и легко устранимыми. Например, компилятор упрощает x + 1 > x до 1. Этот уровень -Wstrict-overflow включен -Wall; более высокие уровни не включены и должны быть запрошены явно.

-Wstrict-overflow=2

Также предупреждать об других случаях, когда сравнение упрощается до константы. Например: abs (x) >= 0. Это может быть упрощено только при неопределенном переполнении со знаком, потому что abs (INT_MIN) переполняется до INT_MIN, что меньше нуля. -Wstrict-overflow (без уровня) эквивалентно -Wstrict-overflow=2.

-Wstrict-overflow=3

Также предупреждать об других случаях, когда сравнение упрощается. Например: x + 1 > 1 упрощается до x > 0.

-Wstrict-overflow=4

Также предупреждать об других упрощениях, не охваченных вышеприведенными случаями. Например: (x * 10) / 5 упрощается до x * 2.

-Wstrict-overflow=5

Также предупреждать о случаях, когда компилятор уменьшает значение константы, участвующей в сравнении. Например: x + 2 > y упрощается до x + 1 >= y. Это сообщается только на самом высоком уровне предупреждений, потому что это упрощение применяется ко многим сравнениям, поэтому этот уровень предупреждений дает очень большое количество ложноположительных результатов.

-Wstring-compare

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

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

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

-Wno-stringop-overflow

-Wstringop-overflow

-Wstringop-overflow=type

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

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

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

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

-Wstringop-overflow

-Wstringop-overflow=1

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

-Wstringop-overflow=2

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

-Wstringop-overflow=3

Параметр -Wstringop-overflow=3 использует проверку размера объекта типа 2 для определения размеров целевых объектов. В этом режиме параметр предупреждает о переполнении самого маленького объекта или элемента данных. Это самый жесткий режим параметра, который может привести к предупреждениям для безопасного кода.

-Wstringop-overflow=4

Параметр -Wstringop-overflow=4 использует проверку размера объекта типа 3 для определения размеров целевых объектов. В этом режиме параметр предупреждает о переполнении любых элементов данных, и когда назначение является одним из нескольких объектов, он использует размер самого большого из них, чтобы решить, выдавать ли предупреждение. Аналогично параметру -Wstringop-overflow=3, этот режим параметра может привести к предупреждениям для безобидного кода.

-Wno-stringop-overread

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

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

-Wno-stringop-truncation

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

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

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

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

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

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

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

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

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

Предупреждать о неправильных использованиях гибких элементов массива в соответствии с уровнем атрибута strict_flex_array (level) , прикрепленного к последнему полю массива структуры, если он доступен, в противном случае в соответствии с уровнем параметра -fstrict-flex-arrays=level. См. Общие атрибуты переменных для получения дополнительной информации об атрибуте и Параметры, определяющие диалект C для получения дополнительной информации о параметре. -Wstrict-flex-arrays эффективен только при уровне больше 0.

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

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

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

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

-Wsuggest-attribute=[pure|const|noreturn|format|cold|malloc]returns_nonnull|

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

-Wsuggest-attribute=pure

-Wsuggest-attribute=const

-Wsuggest-attribute=noreturn

-Wmissing-noreturn

-Wsuggest-attribute=malloc

-Wsuggest-attribute=returns_nonnull

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

-Wno-alloc-size-larger-than

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

-Walloca

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

-Walloca-larger-than=byte-size

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

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

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

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

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

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

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

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

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

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

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

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

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

-Wno-alloca-larger-than

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

-Warith-conversion

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

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

-Warray-bounds

-Warray-bounds=n

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

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

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

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

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

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

-Warray-bounds=1

Это уровень предупреждений по умолчанию для -Warray-bounds и включен параметром -Wall; более высокие уровни не включены и должны быть запрошены явно.

-Warray-bounds=2

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

-Warray-compare

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

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

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

-Warray-parameter

-Warray-parameter=n

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

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

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

-Wattribute-alias=n

-Wno-attribute-alias

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

-Wattribute-alias=1

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

-Wattribute-alias=2

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

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

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

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

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

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

По умолчанию это предупреждение не предупреждает об 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.

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

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

-Wzero-length-bounds

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

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

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

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

Опция -Wzero-length-bounds включена в -Warray-bounds.

-Wno-div-by-zero

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

-Wsystem-headers

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

-Wtautological-compare

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

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

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

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

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

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

-Wtrampolines

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

-Wfloat-equal

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

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

-Wtraditional (C and Objective-C only)

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

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

Это предупреждение повышается до ошибки параметром -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

Предупреждать, если использование стека функцией может превысить размер_в_байтах. Вычисления, выполняемые для определения использования стека, являются консервативными. Любое выделенное место в памяти с помощью 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’ включено по умолчанию. Предупреждения, контролируемые параметром, можно отключить, указав размер_в_байтах ‘SIZE_MAX’ или больше, или с помощью -Wno-stack-usage.

-Wno-stack-usage

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

-Wunsafe-loop-optimizations

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

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

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

-Wpointer-arith

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

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

-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: Предупреждение: опция командной строки '-fno-rtti' допустима для C++/D/ObjC++ но не для 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++ ссылок) на объекты с автоматической областью памяти после окончания их жизненного цикла. Это относится к локальным переменным, объявленным во вложенных блоках, составным литералам и другим безымянным временным объектам. Кроме того, выдавать предупреждение о сохранении адреса таких объектов в ссылающихся указателях. Предупреждение включено на всех уровнях оптимизации, но может давать разные результаты с оптимизацией по сравнению с без оптимизации.

-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

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

-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

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

-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

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

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

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

-Wno-builtin-macro-redefined

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

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

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

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

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

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

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

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

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

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

-Wmissing-field-initializers

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

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

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

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 в качестве простого требования C++20:

bool satisfied = requires { C<T> };

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

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

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

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

-Wno-missing-template-keyword

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

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

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

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

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

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

-Wno-multichar

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

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

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

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

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

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

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

-Wno-attribute-warning

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

-Wno-deprecated

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

-Wno-deprecated-declarations

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

-Wno-overflow

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

-Wno-odr

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

-Wopenacc-parallelism

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

-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-битного заполнителя между полем 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)

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

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

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

-Wpadded

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

-Wredundant-decls

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

-Wrestrict

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

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

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

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

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

-Winline

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

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

-Winterference-size

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

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

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

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

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

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

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

-Wint-in-bool-context

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

-Wno-int-to-pointer-cast

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

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

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

-Winvalid-pch

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

-Winvalid-utf8

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

-Wno-unicode

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

-Wlong-long

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

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

-Wvariadic-macros

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

-Wno-varargs

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

-Wvector-operation-performance

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

-Wvla

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

Это предупреждение повышается до ошибки с помощью -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

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

-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 pragma из расширения десятичных чисел с плавающей точкой для C99.

-Wno-lto-type-mismatch

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

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

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