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» относится к букве 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.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

-x none

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

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

-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, -fprofile-prefix-map и -fcanon-prefix-map.

-fcanon-prefix-map

Для опций -f*-prefix-map обычно сравнение префикса old с именем файла, на который обычно ссылаются в результате компиляции, выполняется с помощью текстового сравнения префиксов или игнорирования регистра для регистронезависимых файловых систем и рассмотрения косых и обратных косых черт как равных в файловых системах на основе DOS. Опция -fcanon-prefix-map приводит к тому, что такие сравнения выполняются на канонизированных путях old и ссылающегося на него имени файла.

-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; любые такие параметры будут обработаны рекурсивно.