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

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

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

-fsyntax-only

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

-fmax-errors=n

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

-w

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

-Werror

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

-Werror=

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

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

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

-Wfatal-errors

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

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

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

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

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

-Wpedantic

-pedantic

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

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

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

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

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

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

-pedantic-errors

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

-Wall

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

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

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

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

-Wextra

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

-Wclobbered  
-Wcast-function-type  
-Wempty-body  
-Wignored-qualifiers 
-Wimplicit-fallthrough=3 
-Wmissing-field-initializers  
-Wmissing-parameter-type (C only)  
-Wold-style-declaration (C only)  
-Woverride-init  
-Wsign-compare (C only) 
-Wtype-limits  
-Wuninitialized  
-Wshift-negative-value (in C++03 and in C99 and newer)  
-Wunused-parameter (only with -Wunused or -Wall) 
-Wunused-but-set-parameter (only with -Wunused or -Wall)

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

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

-Wchar-subscripts

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

-Wchkp

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

-Wno-coverage-mismatch

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

-Wno-cpp

(Только C, Objective-C, C++, Objective-C++ и Fortran)

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

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

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

-Wno-format-contains-nul

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

-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 равны нулю, завершающий символ NULL ('\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=2

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

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

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

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

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

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

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

-Wimplicit-int (C and Objective-C only)

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

-Wimplicit-function-declaration (C and Objective-C only)

Выдает предупреждение всякий раз, когда функция используется до её объявления. В режиме C99 (-std=c99 или -std=gnu99) это предупреждение включено по умолчанию, а с помощью -pedantic-errors оно преобразуется в ошибку. Это предупреждение также включено с помощью -Wall.

-Wimplicit (C and Objective-C only)

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

-Wimplicit-fallthrough

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

-Wimplicit-fallthrough=n

Предупреждает, когда в операторе switch case происходит пропуск. Например:

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

Поскольку в некоторых случаях пропуск case в операторе 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.

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

Управление тем, выводится ли предупреждение, сгенерированное атрибутом warn_if_not_aligned. По умолчанию оно включено. Используйте -Wno-if-not-aligned для его отключения.

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

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

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

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

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

-Wmain

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

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

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

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

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

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

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

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

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

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

-Wmissing-attributes

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

-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 заключён. Это предупреждение включено с помощью -Wall в C.

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

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

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

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

-Wmultistatement-macros

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

Например:

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

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

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

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

-Wparentheses

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

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

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

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

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

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

-Wsequence-point

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

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

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

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

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

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

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

-Wno-return-local-addr

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

-Wreturn-type

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

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

Для C++, функция без типа возврата всегда генерирует сообщение об ошибке, даже когда указан -Wno-return-type. Исключениями являются main и функции, определённые в системных заголовках.

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

-Wshift-count-negative

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

-Wshift-count-overflow

Выводить предупреждение, если сдвиг по счету >= ширины типа. Это предупреждение включено по умолчанию.

-Wshift-negative-value

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

-Wshift-overflow

-Wshift-overflow=n

Предупреждать об переполнениях левого сдвига. Это предупреждение включено по умолчанию в режимах C99 и C++11 (и новее).

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

-Wswitch

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

-Wswitch-default

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

-Wswitch-enum

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

-Wswitch-bool

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

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

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

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

-Wunused-but-set-parameter

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

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

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

-Wunused-but-set-variable

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

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

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

-Wunused-function

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

-Wunused-label

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

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

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

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

-Wunused-parameter

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

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

-Wno-unused-result

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

-Wunused-variable

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

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

-Wunused-const-variable

-Wunused-const-variable=n

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

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

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

-Wunused-value

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

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

-Wunused

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

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

-Wuninitialized

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

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

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

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

-Winvalid-memory-model

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

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

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

-Wmaybe-uninitialized

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

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

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

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

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

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

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

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

-Wunknown-pragmas

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

-Wno-pragmas

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

-Wstrict-aliasing

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

-Wstrict-aliasing=n

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

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

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

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

-Wstrict-overflow

-Wstrict-overflow=n

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

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

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

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

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

Опция -Wstringop-truncation включена с -Wall.

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

-Wsuggest-attribute=pure

-Wsuggest-attribute=const

-Wsuggest-attribute=noreturn

-Wsuggest-attribute=malloc

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

-Wsuggest-attribute=format

-Wmissing-format-attribute

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

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

-Wsuggest-attribute=cold

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

-Wsuggest-final-types

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

-Wsuggest-final-methods

Предупреждение о виртуальных методах, где качество кода улучшилось бы, если бы метод был объявлен с модификатором C++11 final, или, если возможно, его тип был объявлен в анонимном пространстве имён или с модификатором final. Это предупреждение более эффективно с оптимизацией на этапе компоновки, где информация о графе иерархии классов более полна. Рекомендуется сначала рассмотреть предложения опции -Wsuggest-final-types, а затем перестроить с новыми аннотациями.

-Wsuggest-override

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

-Walloc-zero

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

-Walloc-size-larger-than=n

Предупреждение о вызовах функций, помеченных атрибутом alloc_size, которые пытаются выделить объекты, размер которых больше заданного числа байт, или где результат вычисления размера в целочисленном типе с бесконечной точностью превысит SIZE_MAX / 2. Аргумент опции n может заканчиваться одним из стандартных суффиксов, обозначающих кратные байтам, таких как kB и KiB для килобайта и кибибайта соответственно, MB и MiB для мегабайта и мебибайта и так далее. -Walloc-size-larger-than=PTRDIFF_MAX включена по умолчанию. Предупреждения, контролируемые этой опцией, могут быть отключены, задав n равным SIZE_MAX или больше. См. Атрибуты функций.

-Walloca

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

-Walloca-larger-than=n

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

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

См. также -Wvla-larger-than=n.

-Warray-bounds

-Warray-bounds=n

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

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

-Wattribute-alias

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

-Wbool-compare

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

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

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

-Wbool-operation

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

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

-Wduplicated-branches

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

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

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

int i = x ? *p : *p;

-Wduplicated-cond

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

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

-Wframe-address

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-Wshadow

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

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

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

-Wshadow=global

Значение по умолчанию для -Wshadow. Предупреждает о любом (глобальном) затенении.

-Wshadow=local

Предупреждать, когда локальная переменная затеняет другую локальную переменную или параметр. Это предупреждение включено -Wshadow=global.

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

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

-Wlarger-than=len

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

-Wframe-larger-than=len

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

-Wno-free-nonheap-object

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

-Wstack-usage=len

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

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

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

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

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

-Waligned-new

Предупреждать об выражении new-типа, требующего большего выравнивания, чем alignof(std::max_align_t), но использующем функцию выделения памяти без явного параметра выравнивания. Этот параметр включен -Wall.

Обычно это предупреждает только о глобальных функциях выделения, но -Waligned-new=all также предупреждает о функциях выделения памяти члена класса.

-Wplacement-new

-Wplacement-new=n

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

char buf [64];
new (buf) int[64];

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

-Wplacement-new=1

Это уровень предупреждений по умолчанию для -Wplacement-new. На этом уровне предупреждение не выдается для некоторых строго неопределенных конструкций, которые GCC разрешает как расширения для совместимости со старым кодом. Например, следующее new выражение не диагностируется на этом уровне, даже несмотря на то, что оно имеет неопределенное поведение в соответствии со стандартом C++, потому что оно записывает за пределы одноэлементного массива.

struct S { int n, a[1]; };
S *s = (S *)malloc (sizeof *s + 31 * sizeof s->a[0]);
new (s->a)int [32]();

-Wplacement-new=2

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

struct S { int n, a[]; };
S *s = (S *)malloc (sizeof *s + 32 * sizeof s->a[0]);
new (s->a)int [32]();

-Wpointer-arith

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

-Wpointer-compare

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

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

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

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

-Wtype-limits

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

-Wcomment

-Wcomments

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

-Wtrigraphs

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

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

-Wundef

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

-Wexpansion-to-defined

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

-Wunused-macros

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

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

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

#if defined the_macro_causing_the_warning
#endif

-Wno-endif-labels

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

#if FOO
…
#else FOO
…
#endif FOO

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

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

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

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

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

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

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

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

-Wcast-qual

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

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

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

-Wcast-align

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

-Wcast-align=strict

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

-Wcast-function-type

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

-Wwrite-strings

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

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

-Wcatch-value

-Wcatch-value=n (C++ and Objective-C++ only)

Предупреждать о обработчиках catch, которые не обрабатывают через ссылку. С -Wcatch-value=1 (или -Wcatch-value для краткости) предупреждать о полиморфных типах класса, которые пойманы по значению. С -Wcatch-value=2 предупреждать обо всех типах класса, которые пойманы по значению. С -Wcatch-value=3 предупреждать обо всех типах, которые не пойманы по ссылке. -Wcatch-value включено в -Wall.

-Wclobbered

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

-Wconditionally-supported (C++ and Objective-C++ only)

Предупреждать о конструкциях с условной поддержкой (C++11 [intro.defs]).

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

-Wno-conversion-null (C++ and Objective-C++ only)

Не предупреждать о преобразованиях между NULL и типами, не являющимися указателями. -Wconversion-null включено по умолчанию.

-Wzero-as-null-pointer-constant (C++ and Objective-C++ only)

Предупреждать, когда литерал ‘0’ используется как константа нулевого указателя. Это может быть полезно для облегчения перехода к nullptr в C++11.

-Wsubobject-linkage (C++ and Objective-C++ only)

Предупреждать, если тип класса имеет базовый класс или поле, тип которого использует анонимный пространство имён или зависит от типа без связи. Если тип A зависит от типа B без связи или с внутренней связью, определение его в нескольких единицах трансляции будет нарушением ODR, потому что значение B будет разным в каждой единице трансляции. Если тип A встречается только в одной единице трансляции, лучший способ отключить предупреждение — дать ему внутреннюю связь, поместив его также в анонимное пространство имён. Компилятор не выводит это предупреждение для типов, определённых в основном файле .C, так как они вряд ли будут иметь несколько определений. -Wsubobject-linkage включено по умолчанию.

-Wdangling-else

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

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

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

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

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

-Wdate-time

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

-Wdelete-incomplete (C++ and Objective-C++ only)

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

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

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

-Wempty-body

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

-Wenum-compare

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

-Wextra-semi (C++, Objective-C++ only)

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

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

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

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

-Wsign-compare

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

-Wsign-conversion

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

-Wfloat-conversion

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

-Wno-scalar-storage-order

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

-Wsized-deallocation (C++ and Objective-C++ only)

Предупреждать об определении функции безразмерного выделения памяти

void operator delete (void *) noexcept;
void operator delete[] (void *) noexcept;

без определения соответствующей функции размеченного выделения памяти

void operator delete (void *, std::size_t) noexcept;
void operator delete[] (void *, std::size_t) noexcept;

или наоборот. Включено флагом -Wextra вместе с -fsized-deallocation.

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

-Wsizeof-array-argument

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

-Wmemset-elt-size

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

-Wmemset-transposed-args

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

-Waddress

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

-Wlogical-op

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

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

-Wlogical-not-parentheses

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

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

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

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

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

-Waggregate-return

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

-Wno-aggressive-loop-optimizations

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

-Wno-attributes

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

-Wno-builtin-declaration-mismatch

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

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

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

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

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

void foo(bar) { }

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

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

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

-Wmissing-declarations

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

-Wmissing-field-initializers

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

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

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

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

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

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

Также в C++ этот параметр не предупреждает об инициализаторе { }, например:

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

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

-Wno-multichar

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

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

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

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

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

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

Некоторые символы в ISO 10646 имеют разное значение, но выглядят одинаково в некоторых шрифтах или методах отображения, особенно после применения форматирования. Например, \u207F, «СВЕРХУ НАДПИСЬ ЛАТИНСКАЯ МАЛЕНЬКАЯ БУКВА N», отображается так же, как обычная n, которая помещена в верхний индекс. ISO 10646 определяет схему нормализации NFKC для преобразования всех этих в стандартную форму, и GCC предупреждает, если ваш код не в NFKC, если вы используете -Wnormalized=nfkc. Это предупреждение аналогично предупреждению о каждом идентификаторе, который содержит букву O, потому что она может быть перепутана с цифрой 0, поэтому оно не является по умолчанию, но может быть полезно в качестве локальной соглашения о кодировании, если среда программирования не может быть исправлена для отображения этих символов чётко.

-Wno-deprecated

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

-Wno-deprecated-declarations

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

-Wno-overflow

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

-Wno-odr

Выводить предупреждение о нарушениях правила одной дефиниции во время оптимизации на этапе компоновки. Требуется включение -flto-odr-type-merging. Включено по умолчанию.

-Wopenmp-simd

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

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

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

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

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

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

-Wpacked

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

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

-Wpacked-bitfield-compat

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

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

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

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

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

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

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

-Wpadded

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

-Wredundant-decls

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

-Wno-restrict

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

-Wno-inherited-variadic-ctor

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

-Winline

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

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

-Wno-invalid-offsetof (C++ and Objective-C++ only)

Подавить предупреждения от применения макроса offsetof к типу, не являющемуся POD. Согласно стандарту ISO C++ 2014, применение offsetof к типу без стандартной компоновки является неопределённым. Однако в существующих реализациях C++ offsetof обычно даёт осмысленные результаты. Этот флаг предназначен для пользователей, которые знают, что они пишут непереносимый код, и которые намеренно решили проигнорировать предупреждение об этом.

Ограничения на offsetof могут быть ослаблены в будущих версиях стандарта C++.

-Wint-in-bool-context

END_OF_DOCUMENT_MARKER

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

-Wno-int-to-pointer-cast

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

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

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

-Winvalid-pch

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

-Wlong-long

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

-Wvariadic-macros

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

-Wvarargs

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

-Wvector-operation-performance

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

-Wno-virtual-move-assign

Отключить предупреждения об наследовании от виртуального базового класса с нетривиальным оператором перемещения C++11. Это опасно, потому что если виртуальный базовый класс достижим по нескольким путям, он перемещается несколько раз, что может означать, что оба объекта окажутся в состоянии «перемещенного из». Если оператор перемещения написан для того, чтобы избежать перемещения из перемещенного объекта, это предупреждение можно отключить.

-Wvla

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

-Wvla-larger-than=n

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

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

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

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

-Wvolatile-register-var

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

-Wdisabled-optimization

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

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

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

-Wstack-protector

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

-Woverlength-strings

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

Предел применяется после конкатенации строковых констант и не учитывает завершающий символ NULL. В 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-designated-init (C and Objective-C only)

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

-Whsa

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

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

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