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

file.fi

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

file.F

file.FOR

file.fpp

file.FPP

file.FTN

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

file.f90

file.f95

file.f03

file.f08

file.fii

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

file.F90

file.F95

file.F03

file.F08

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

file.cob

file.COB

file.cbl

file.CBL

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

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  objc-cpp-output
objective-c++  objective-c++-header  objective-c++-cpp-output
objc++-cpp-output
assembler  assembler-with-cpp
ada  adascil  adawhy
cobol
d
f77  f77-cpp-input  f95  f95-cpp-input
go
modula-2  modula-2-cpp-output
rust
lto

Обратите внимание: параметр -x не задаёт определённый стандарт языка. Например, для некоторых старых исходных кодов вместе с -x f77 может потребоваться указать -std=legacy.

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

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 — заданные явно или полученные из имени результата компоновки, но не из входных файлов — передаются в lto-wrapper в качестве параметра -dumpdir с завершающей точкой вместо добавленного компилятором дефиса, если он был, даже в случаях, когда такое объединение иначе не использовалось бы. Поскольку эта программа участвует в компоновке, обычно она не получает параметры -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=.

Если перед параметром --help= в командной строке указан параметр -Q, выводимый параметром --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 Assembler работает с каналами без проблем.

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