3.2 Опции, управляющие видом вывода ¶

Компиляция может включать до четырёх этапов: предварительная обработка, собственно компиляция, сборка и компоновка, всегда в указанном порядке. GCC способен выполнять предварительную обработку и компиляцию нескольких файлов, либо в несколько файлов-входных данных для ассемблера, либо в один; затем каждый файл-входной данных для ассемблера генерирует файл-объект, и компоновка объединяет все файлы-объекты (те, что были скомпилированы недавно, и те, что указаны в качестве входных данных) в исполняемый файл.

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

file.c

Исходный код на C, требующий предварительной обработки.

file.i

Исходный код на C, который не должен подвергаться предварительной обработке.

file.ii

Исходный код на C++, который не должен подвергаться предварительной обработке.

file.m

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

file.mi

Исходный код на Objective-C, который не должен подвергаться предварительной обработке.

file.mm

file.M

Исходный код на Objective-C++, Обратите внимание, что для работы программы Objective-C++ необходимо связать библиотеку libobjc. Обратите внимание, что «.M» относится к заглавной букве М.

file.mii

Исходный код на Objective-C++, который не должен подвергаться предварительной обработке.

file.h

Файл заголовка на C, C++, Objective-C или Objective-C++, который преобразуется в предварительно скомпилированный заголовок (по умолчанию), или файл заголовка на C или C++, который преобразуется в спецификацию Ada (с помощью переключателя -fdump-ada-spec).

file.cc

file.cp

file.cxx

file.cpp

file.CPP

file.c++

file.C

Исходный код на C++, требующий предварительной обработки. Обратите внимание, что в «.cxx» последние две буквы должны быть буквально «x». Аналогично, «.C» относится к заглавной букве C.

file.mm

file.M

Исходный код на Objective-C++, требующий предварительной обработки.

file.mii

Исходный код на Objective-C++, который не должен подвергаться предварительной обработке.

file.hh

file.H

file.hp

file.hxx

file.hpp

file.HPP

file.h++

file.tcc

Файл заголовка на C++, который преобразуется в предварительно скомпилированный заголовок или спецификацию Ada.

file.f

file.for

file.ftn

Исходный код Fortran с фиксированной формой, который не должен подвергаться предварительной обработке.

file.F

file.FOR

file.fpp

file.FPP

file.FTN

Исходный код Fortran с фиксированной формой, который должен подвергаться предварительной обработке (с традиционным препроцессором).

file.f90

file.f95

file.f03

file.f08

Исходный код Fortran с свободной формой, который не должен подвергаться предварительной обработке.

file.F90

file.F95

file.F03

file.F08

Исходный код Fortran с свободной формой, который должен подвергаться предварительной обработке (с традиционным препроцессором).

file.go

Исходный код на Go.

file.brig

Файлы BRIG (двоичное представление HSAIL).

file.d

Исходный код на D.

file.di

Файл интерфейса D.

file.dd

Документационный код D (Ddoc).

file.ads

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

file.adb

Файл исходного кода Ada, содержащий тело единицы библиотеки (тело подпрограммы или пакета). Такие файлы также называются телами.

file.s

Ассемблерный код.

file.S

file.sx

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

other

Файл-объект, который сразу передается в компоновку. Любой файл без распознанного расширения обрабатывается таким образом.

Вы можете явно указать язык с помощью опции -x:

-x language

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

c  c-header  cpp-output
c++  c++-header  c++-system-header c++-user-header c++-cpp-output
objective-c  objective-c-header  objective-c-cpp-output
objective-c++ objective-c++-header objective-c++-cpp-output
assembler  assembler-with-cpp
ada
d
f77  f77-cpp-input f95  f95-cpp-input
go
brig

-x none

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

Если вы хотите выполнить только некоторые этапы компиляции, вы можете использовать -x (или расширения имен файлов) для указания, где gcc начинается, и одну из опций -c, -S или -E, чтобы указать, где gcc завершается. Обратите внимание, что некоторые комбинации (например, «-x cpp-output -E») указывают gcc на то, чтобы ничего не делать.

-c

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

По умолчанию имя объектного файла для исходного файла формируется заменой суффикса ‘.c’, ‘.i’, ‘.s’ и т. п. на ‘.o’.

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

-S

Останавливается после этапа собственно компиляции, не выполняя сборку. Вывод — в виде файла кода ассемблера для каждого файла ввода, не являющегося файлом ассемблера.

По умолчанию имя файла ассемблера для исходного файла формируется заменой суффикса ‘.c’, ‘.i’ и т. п. на ‘.s’.

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

-E

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

Файлы ввода, не требующие предварительной обработки, игнорируются.

-o file ¶

Размещает основной вывод в файл file. Это относится к любому типу вывода: исполняемому файлу, объектному файлу, файлу ассемблера или предварительно обработанному C-коду.

Если -o не указан, по умолчанию исполняемый файл размещается в a.out, объектный файл для source.suffix — в source.o, файл ассемблера — в source.s, предварительно скомпилированный заголовочный файл — в source.suffix.gch, а весь предварительно обработанный C-исходный код — в стандартный вывод.

Хотя -o назначает только основной вывод, он также влияет на именование вспомогательных и выходных файлов. См. примеры ниже. Если не переопределено, вспомогательные и выходные файлы размещаются в той же директории, что и основной вывод. Во вспомогательных файлах суффикс входного файла заменяется на суффикс типа вспомогательного выходного файла; в выходных файлах суффикс выходного файла добавляется к суффиксу входного файла. В командах компиляции имя базы как вспомогательных, так и выходных файлов соответствует имени основного вывода; в командах компиляции и линковки имя основного выходного файла, минус суффикс исполняемого файла, объединяется с именем входного файла. Если обе имеют одинаковую базовую часть, игнорируя суффикс, результатом объединения будет эта базовая часть; в противном случае они конкатенируются, разделенные дефисом.

gcc -c foo.c ...

будет использовать foo.o в качестве основного вывода и разместит вспомогательные и выходные файлы рядом с ним, например, вспомогательный файл foo.dwo для -gsplit-dwarf и выходной файл foo.c.???r.final для -fdump-rtl-final.

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

gcc -c foo.c -o dir/foobar.o ...

будет называть вспомогательные выходы dir/foobar.* и выходные выходы dir/foobar.c.*.

Для вывода линковщика вспомогательные и выходные выходы будут иметь префикс:

gcc foo.c bar.c -o dir/foobar ...

обычно будет называть вспомогательные выходы dir/foobar-foo.* и dir/foobar-bar.*, а выходные выходы dir/foobar-foo.c.* и dir/foobar-bar.c.*.

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

gcc foo.c -o dir/foo ...

в этом случае вспомогательные выходы называются dir/foo.*, а выходные — dir/foo.c.*.

Расположение и имена вспомогательных и выходных файлов можно настроить с помощью опций -dumpbase, -dumpbase-ext, -dumpdir, -save-temps=cwd и -save-temps=obj.

-dumpbase dumpbase

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

gcc -save-temps -S foo.c

сохраняет (уже не временный) предварительно обработанный файл в foo.i, а затем компилирует в (подразумеваемый) выходной файл foo.s, тогда как:

gcc -save-temps -dumpbase save-foo -c foo.c

предварительно обрабатывает в save-foo.i, компилирует в save-foo.s (теперь промежуточный, следовательно, вспомогательный вывод), а затем собирает в (подразумеваемый) выходной файл foo.o.

Без этой опции файлы дампов и вспомогательные файлы получают свои имена из входного файла или из файла вывода (не связанного с линковкой), если он указан явно: файлы дампов (например, те, которые запрашиваются опциями -fdump-*) с суффиксом имени входного файла, и вспомогательные файлы (те, которые запрашиваются другими опциями, не связанными с дампом, например, -save-temps, -gsplit-dwarf, -fcallgraph-info) без него.

Аналогичное различие суффиксов для файлов дампов и вспомогательных файлов может быть достигнуто для явно заданного -dumpbase basename.suf путём задания -dumpbase-ext .suf.

Если dumpbase явно указан с каким-либо компонентом каталога, любое указание dumppfx (например, -dumpdir или -save-temps=*) игнорируется, и вместо добавления к нему dumpbase полностью его переопределяет:

gcc foo.c -c -o dir/foo.o -dumpbase alt/foo \
  -dumpdir pfx- -save-temps=cwd ...

создаёт вспомогательные и выходные файлы с именем alt/foo.*, игнорируя dir/ в -o, префикс ./, подразумеваемый -save-temps=cwd, и pfx- в -dumpdir.

Когда -dumpbase указан в команде, компилирующей несколько входных файлов, или компилирующей и затем выполняющей линковку, он может быть объединён с dumppfx, как указано в -dumpdir. Затем каждый входной файл компилируется с использованием объединённого dumppfx, и значения по умолчанию для dumpbase и auxdropsuf вычисляются для каждого входного файла:

gcc foo.c bar.c -c -dumpbase main ...

создаёт foo.o и bar.o в качестве основных выходов и избегает перезаписи вспомогательных и выходных файлов, используя dumpbase в качестве префикса, создавая вспомогательные и выходные файлы с именами main-foo.* и main-bar.*.

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

gcc -c foo.c -o dir/foobar.o -dumpbase '' ...

будет называть вспомогательные выходы dir/foo.* и выходные выходы dir/foo.c.*. Обратите внимание, как их имена баз взяты из имени входного файла, но каталог всё же по умолчанию совпадает с каталогом вывода.

Пустая строка dumpbase не предотвращает использование имени базы вывода для выходов во время линковки:

gcc foo.c bar.c -o dir/foobar -dumpbase '' -flto ...

Компиляция исходных файлов будет называть вспомогательные выходы dir/foo.* и dir/bar.*, а выходные выходы — dir/foo.c.* и dir/bar.c.*. LTO-перекомпиляция во время линковки будет использовать dir/foobar. в качестве префикса для файлов дампов и вспомогательных файлов.

-dumpbase-ext auxdropsuf

При формировании имени вспомогательного (но не выходного) файла, удалить завершающий auxdropsuf из dumpbase перед добавлением каких-либо суффиксов. Если не указано, эта опция по умолчанию устанавливается в суффикс по умолчанию dumpbase, т. е. в суффикс входного файла, когда -dumpbase не присутствует в командной строке, или dumpbase объединён с dumppfx.

gcc foo.c -c -o dir/foo.o -dumpbase x-foo.c -dumpbase-ext .c ...

создаёт dir/foo.o в качестве основного вывода и генерирует вспомогательные выходы в dir/x-foo.*, используя местоположение основного вывода и удаляя суффикс .c из dumpbase. Выходные файлы дампов сохраняют суффикс: dir/x-foo.c.*.

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

gcc foo.c bar.c -o main.out -dumpbase-ext .out ...

создаёт main.out в качестве основного вывода и избегает перезаписи вспомогательных и выходных файлов, используя имя исполняемого файла минус auxdropsuf в качестве префикса, создавая вспомогательные выходы с именами main-foo.* и main-bar.*, а выходные выходы — с именами main-foo.c.* и main-bar.c.*.

-dumpdir dumppfx

При формировании имени вспомогательного или выходного файла дампов используйте dumppfx в качестве префикса:

gcc -dumpdir pfx- -c foo.c ...

создаёт foo.o в качестве основного вывода и вспомогательные выводы с именами pfx-foo.*, комбинируя заданный dumppfx с параметром по умолчанию dumpbase, полученным из имени основного файла, в свою очередь полученного из имени входного файла. Вывод дампов также использует суффикс имени входного файла: pfx-foo.c.*.

Если dumppfx используется как имя каталога, оно должно заканчиваться разделителем каталога:

gcc -dumpdir dir/ -c foo.c -o obj/bar.o ...

создаёт obj/bar.o в качестве основного вывода и вспомогательные выводы с именами dir/bar.*, комбинируя заданный dumppfx с параметром по умолчанию dumpbase, полученным из имени основного файла. Вывод дампов также использует суффикс имени входного файла: dir/bar.c.*.

По умолчанию он устанавливается в местоположение выходного файла, если выходной файл не является специальным файлом, таким как /dev/null. Параметры -save-temps=cwd и -save-temps=obj переопределяют этот параметр по умолчанию, точно так же, как и явный параметр -dumpdir. В случае указания нескольких таких параметров, действует последний:

gcc -dumpdir pfx- -c foo.c -save-temps=obj ...

выводит foo.o со вспомогательными выводами с именем foo.*, так как -save-temps=* переопределяет dumppfx, заданный более ранним параметром -dumpdir. Не имеет значения, что =obj является параметром по умолчанию для -save-temps, или что каталог вывода неявно является текущим каталогом. Вывод дампов имеет имя foo.c.*.

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

gcc foo.c bar.c -c -dumpdir dir/pfx- -dumpbase main ...

выводит вспомогательные дампы в dir/pfx-main-foo.* и dir/pfx-main-bar.*, добавляя dumpbase- к dumppfx. Вывод дампов сохраняет суффикс имени входного файла: dir/pfx-main-foo.c.* и dir/pfx-main-bar.c.* соответственно. Сравните с компиляцией с единственным входным файлом:

gcc foo.c -c -dumpdir dir/pfx- -dumpbase main ...

которое, применяя -dumpbase к одному исходному файлу, не вычисляет и не добавляет отдельный dumpbase для каждого входного файла. Его вспомогательный и дамповый вывод попадает в dir/pfx-main.*.

При компиляции и последующей линковке из нескольких входных файлов, заданный по умолчанию или явно указанный dumppfx также подвергается преобразованию dumpbase выше (например, компиляция foo.c и bar.c выше, но без -c). Если ни -dumpdir, ни -dumpbase не указаны, имя базового выходного файла линковщика, минус auxdropsuf, если указан, или суффикс исполняемого файла в противном случае, плюс дефис добавляются к dumppfx по умолчанию вместо этого. Однако обратите внимание, что в отличие от предыдущих случаев линковки:

gcc foo.c bar.c -dumpdir dir/pfx- -o main ...

не добавляет имя выходного файла main к dumppfx, потому что -dumpdir явно указан. Цель состоит в том, чтобы явно заданный dumppfx мог содержать указанное имя выходного файла в качестве части префикса, если это необходимо; только явно указанный -dumpbase будет объединён с ним, чтобы избежать простого отбрасывания значимого параметра.

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

gcc foo.c -dumpdir alt/pfx- -o dir/main.exe -save-temps=cwd ...

Вспомогательные выходы называются foo.*, а дамповые выходы foo.c.* в текущем рабочем каталоге, как в конечном счёте запрошено -save-temps=cwd.

Подводя итог для интуитивного, хотя и немного неточного, потока данных: имя основного выходного файла разбивается на часть каталога и часть базового имени; dumppfx устанавливается на первую часть, за исключением случаев переопределения -dumpdir или -save-temps=*, а dumpbase устанавливается на вторую часть, за исключением случаев переопределения -dumpbase. Если есть несколько входных файлов или линковка, этот dumpbase может быть объединён с dumppfx и взят из каждого входного файла. Имена вспомогательных выходных файлов для каждого входного файла формируются путём объединения dumppfx, dumpbase минус суффикс и суффикс вспомогательного выходного файла; имена выходных файлов дампов отличаются только тем, что суффикс из dumpbase сохраняется.

В случае вспомогательных и дамповых выходов, созданных во время повторной компиляции LTO, комбинация dumppfx и dumpbase, как заданная или полученная из имени выходного файла линковщика, но не из входных файлов, даже в тех случаях, когда эта комбинация не используется как таковая, передаётся с последующей точкой, заменяющей добавленный компилятором дефис, если он есть, в качестве параметра -dumpdir к lto-wrapper; поскольку он участвует в линковке, эта программа обычно не получает -dumpbase и -dumpbase-ext, и игнорирует их.

При запуске подкомпиляторов, lto-wrapper добавляет имена этапов LTO к полученному dumppfx, гарантирует, что он содержит компонент каталога, так что он переопределяет любой -dumpdir, и передаёт его как -dumpbase подкомпиляторам.

-v

Вывести (в стандартный поток ошибок) команды, выполненные для запуска этапов компиляции. Также вывести номер версии программы-драйвера компилятора и препроцессора, а также компилятора.

-###

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

--help

Вывести (в стандартный поток вывода) описание командных параметров, понимаемых gcc. Если также указан параметр -v, то --help также передаётся различным процессам, вызываемым gcc, чтобы они могли отобразить принимаемые ими командные параметры. Если также указан параметр -Wextra (перед параметром --help), то отображаются и командные параметры, для которых нет связанной с ними документации.

--target-help

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

--help={class|[^]qualifier}[,…]

Вывести (в стандартный вывод) описание командно-строчных опций, понятных компилятору, подходящих для всех указанных классов и квалификаторов. Поддерживаемые классы:

‘optimizers’

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

‘warnings’

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

‘target’

Отобразить опции, специфичные для целевой платформы. В отличие от опции --target-help, опции, специфичные для линковщика и ассемблера, не отображаются. Это потому, что эти инструменты в настоящее время не поддерживают расширенный синтаксис --help=.

‘params’

Отобразить значения, распознаваемые опцией --param.

language

Отобразить опции, поддерживаемые для language, где language — имя одного из языков, поддерживаемых в этой версии GCC. Если опция поддерживается всеми языками, необходимо выбрать класс ‘common’.

‘common’

Отобразить опции, общие для всех языков.

Поддерживаемые квалификаторы:

‘undocumented’

Отобразить только те опции, которые не задокументированы.

‘joined’

Отобразить опции, принимающие аргумент, который следует после знака равенства в одном непрерывном фрагменте текста, например: ‘--help=target’.

‘separate’

Отобразить опции, принимающие аргумент, который появляется как отдельное слово после исходной опции, например: ‘-o output-file’.

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

--help=target,undocumented

Значение квалификатора может быть инвертировано путём добавления перед ним символа ‘^’, например, чтобы отобразить все бинарные опции предупреждений (т.е. опции, которые либо включены, либо выключены, и не принимающие аргументы), имеющие описание, используйте:

--help=warnings,^joined,^undocumented

Аргумент для --help= не должен состоять только из инвертированных квалификаторов.

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

--help=target,optimizers

Опция --help= может быть указана в командной строке несколько раз. Каждый последующий раз отображаются опции нужного класса, пропускаются уже отображенные. Если опция --help также указана где-либо в командной строке, она имеет приоритет над любой опцией --help=.

Если опция -Q появляется в командной строке перед опцией --help=, то описательный текст, отображаемый опцией --help=, изменяется. Вместо описания отображаемых опций даётся указание о том, включена ли опция, выключена или установлена в определённое значение (в предположении, что компилятор знает это в момент использования опции --help=).

Вот усечённый пример из порта ARM gcc:

% gcc -Q -mabi=2 --help=target -c
The following options are target specific:
-mabi=                                2
-mabort-on-noreturn                   [disabled]
-mapcs                                [disabled]

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

-Q -O2 --help=optimizers

В качестве альтернативы можно обнаружить, какие бинарные оптимизации включены при -O3, используя:

gcc -c -Q -O3 --help=optimizers > /tmp/O3-opts
gcc -c -Q -O2 --help=optimizers > /tmp/O2-opts
diff /tmp/O2-opts /tmp/O3-opts | grep enabled

--version

Отобразить номер версии и авторские права вызванного GCC.

-pass-exit-codes

Обычно программа gcc завершается с кодом 1, если какая-либо фаза компилятора возвращает код, отличный от успешного. Если вы указываете -pass-exit-codes, программа gcc вместо этого возвращает наибольшее числовое значение ошибки, созданной любой фазой, возвращающей индикацию ошибки. Передние части C, C++ и Fortran возвращают 4, если возникла внутренняя ошибка компилятора.

-pipe

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

-specs=file

Обработать file после того, как компилятор прочитает стандартный файл specs, для переопределения значений по умолчанию, которые использует программа-драйвер gcc, при определении переключателей, которые нужно передать cc1, cc1plus, as, ld и т.д. В командной строке можно указать более одного -specs=file, и они обрабатываются в порядке следования слева направо. Подробную информацию о формате file см. в разделе Указание подпроцессов и переключателей, передаваемых им.

-wrapper

Вызвать все подкоманды под оболочкой программы. Имя программы-оболочки и её параметры передаются как список, разделённый запятыми.

gcc -c t.c -wrapper gdb,--args

Это вызывает все подпрограммы gcc под ‘gdb --args’, таким образом, вызов cc1 — это ‘gdb --args cc1 …’.

-ffile-prefix-map=old=new

При компиляции файлов, расположенных в каталоге old, записывать любые ссылки на них в результате компиляции как если бы эти файлы находились в каталоге new вместо этого. Указание этой опции эквивалентно указанию всех отдельных опций -f*-prefix-map. Это можно использовать для создания воспроизводимых сборок, не зависящих от расположения. См. также -fmacro-prefix-map и -fdebug-prefix-map.

-fplugin=name.so

Загрузить код плагина из файла name.so, предполагая, что это разделяемая библиотека, которую следует открыть с помощью dlopen компилятором. Базовое имя файла разделяемой библиотеки используется для идентификации плагина для целей обработки аргументов (см. -fplugin-arg-name-key=value ниже). Каждый плагин должен определить функции обратного вызова, указанные в API плагинов.

-fplugin-arg-name-key=value

Определить аргумент, называемый key, со значением value для плагина, называемого name.

-fdump-ada-spec[-slim]

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

-fada-spec-parent=unit

В сочетании с -fdump-ada-spec[-slim] выше, генерировать спецификации Ada как дочерние модули родительского модуля unit.

-fdump-go-spec=file

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

@file

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

Опции в file разделены пробелами. Пробел может быть включён в опцию, если вся опция заключена в одинарные или двойные кавычки. Любой символ (включая обратную косую черту) может быть включен, если символ, который нужно включить, предваряется обратной косой чертой. Файл file может сам содержать дополнительные опции @file; все такие опции будут обрабатываться рекурсивно.