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, но не все — только те, для которых стандарт 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  
-Wpessimizing-move (only for C++)  
-Wpointer-sign  
-Wreorder   
-Wrestrict   
-Wreturn-type  
-Wsequence-point  
-Wsign-compare (only in C++)  
-Wsizeof-pointer-div 
-Wsizeof-pointer-memaccess 
-Wstrict-aliasing  
-Wstrict-overflow=1  
-Wswitch  
-Wtautological-compare  
-Wtrigraphs  
-Wuninitialized  
-Wunknown-pragmas  
-Wunused-function  
-Wunused-label     
-Wunused-value     
-Wunused-variable  
-Wvolatile-register-var

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

-Wextra

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

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

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

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

-Wchar-subscripts

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

-Wno-coverage-mismatch

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

-Wno-cpp

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

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

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

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

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

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

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

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

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

-Wformat

-Wformat=n

Проверьте вызовы printf и scanf, и т. д., чтобы убедиться, что предоставленные аргументы имеют типы, соответствующие заданной строке формата, и что преобразования, указанные в строке формата, имеют смысл. Это включает стандартные функции и другие, определённые атрибутами формата (см. Атрибуты функций), в семействах printf, scanf, strftime и strfmon (расширение X/Open, отсутствующее в стандартном C) (или других семействах, специфичных для целевой платформы). Какие функции проверяются без указания атрибутов формата, зависит от выбранной версии стандарта, и такие проверки функций без указанного атрибута отключаются параметрами -ffreestanding или -fno-builtin.

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

-Wformat=1

-Wformat

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

-Wno-format-contains-nul

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

-Wno-format-extra-args

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

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

-Wformat-overflow

-Wformat-overflow=level

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

-Wformat-overflow

-Wformat-overflow=1

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

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

-Wformat-overflow=2

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

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

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

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

-Wno-format-zero-length

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

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

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

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

-Wnonnull-compare

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

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

-Wnull-dereference

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-Wmissing-braces

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

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

-Wmissing-profile

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

-Wmultistatement-macros

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

Например:

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

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

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

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

-Wparentheses

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

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

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

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

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

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

-Wsequence-point

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

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

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

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

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

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

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

-Wno-return-local-addr

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

-Wreturn-type

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

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

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

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

-Wshift-count-negative

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

-Wshift-count-overflow

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

-Wshift-negative-value

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

-Wshift-overflow

-Wshift-overflow=n

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

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

-Wswitch

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

-Wswitch-default

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

-Wswitch-enum

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

-Wswitch-bool

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

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

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

-Wswitch-unreachable

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

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

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

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

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

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

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

-Wunused-but-set-parameter

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

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

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

-Wunused-but-set-variable

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

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

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

-Wunused-function

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

-Wunused-label

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

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

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

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

-Wunused-parameter

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

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

-Wno-unused-result

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

-Wunused-variable

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

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

-Wunused-const-variable

-Wunused-const-variable=n

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

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

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

-Wunused-value

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

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

-Wunused

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

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

-Wuninitialized

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

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

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

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

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

-Winvalid-memory-model

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

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

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

-Wmaybe-uninitialized

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

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

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

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

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

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

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

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

-Wunknown-pragmas

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

-Wno-pragmas

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

-Wno-prio-ctor-dtor

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

-Wstrict-aliasing

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

-Wstrict-aliasing=n

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

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

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

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

-Wstrict-overflow

-Wstrict-overflow=n

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

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

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

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

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

-Wsuggest-attribute=pure

-Wsuggest-attribute=const

-Wsuggest-attribute=noreturn

-Wmissing-noreturn

-Wsuggest-attribute=malloc

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

-Wsuggest-attribute=format

-Wmissing-format-attribute

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

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

-Wsuggest-attribute=cold

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

-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=byte-size

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

-Wno-alloc-size-larger-than

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

-Walloca

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

-Walloca-larger-than=byte-size

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

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

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

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

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

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

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

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

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

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

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

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

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

-Wno-alloca-larger-than

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

-Warray-bounds

-Warray-bounds=n

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

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

-Wattribute-alias=n

-Wno-attribute-alias

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

-Wattribute-alias=1

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

-Wattribute-alias=2

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

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

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

-Wbool-compare

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

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

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

-Wbool-operation

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

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

-Wno-larger-than

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

-Wframe-larger-than=byte-size

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

-Wno-frame-larger-than

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

-Wno-free-nonheap-object

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

-Wstack-usage=byte-size

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

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

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

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

-Wno-stack-usage

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

-Wunsafe-loop-optimizations

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

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

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

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

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

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

-Wcomment

-Wcomments

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

-Wtrigraphs

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

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

-Wundef

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

-Wexpansion-to-defined

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

-Wunused-macros

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

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

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

#if defined the_macro_causing_the_warning
#endif

-Wno-endif-labels

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

#if FOO
…
#else FOO
…
#endif FOO

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-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"). Такие использования обычно указывают на ошибку программиста: адрес функции всегда оценивается как истина, поэтому их использование в условном выражении обычно означает, что программист забыл скобки в вызове функции; и сравнения со строковыми литералами приводят к неопределённому поведению и не являются переносимыми в C, поэтому они обычно указывают, что программист намеревался использовать strcmp. Это предупреждение включено опцией -Wall.

-Waddress-of-packed-member

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

-Wlogical-op

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

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

-Wlogical-not-parentheses

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

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

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

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

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

-Waggregate-return

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

-Wno-aggressive-loop-optimizations

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

-Wno-attributes

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

-Wno-builtin-declaration-mismatch

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

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

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

-Wno-builtin-macro-redefined

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

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

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

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

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

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

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

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

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

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 подавляет предупреждение для этих символов. Надеются, что будущие версии соответствующих стандартов исправят это, поэтому этот параметр не является по умолчанию.

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

-Wno-attribute-warning

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

-Wno-deprecated

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

-Wno-deprecated-declarations

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

-Wno-overflow

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

-Wno-odr

Предупреждать о нарушениях правила одной дефиниции (One Definition Rule) во время оптимизации линковки. Требует включения -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, но этот атрибут не влияет на расположение или размер структуры. Такие структуры могут быть неправильно выровнены без существенной пользы. Например, в этом коде переменная 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

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

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

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

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

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

-Wno-vla-larger-than

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

-Wvolatile-register-var

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

-Wdisabled-optimization

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

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

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

-Wstack-protector

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

-Woverlength-strings

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

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

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

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

Выводит предупреждение для любой константы с плавающей точкой, которая не имеет суффикса. При использовании вместе с -Wsystem-headers он предупреждает о таких константах в системных заголовочных файлах. Это может быть полезно при подготовке кода для использования с FLOAT_CONST_DECIMAL64 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-9.5.0/gcc/Warning-Options.html