3.10 Параметры, управляющие оптимизацией

Эти параметры управляют различными видами оптимизаций.

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

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

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

Не все оптимизации контролируются напрямую флагом. В этом разделе перечислены только оптимизации, для которых есть флаг.

Большинство оптимизаций включаются только в том случае, если уровень -O задан в командной строке. В противном случае они отключены, даже если отдельные флаги оптимизации указаны.

В зависимости от целевой платформы и конфигурации GCC, немного другой набор оптимизаций может быть включен на каждом уровне -O, чем тот, что перечислен здесь. Вы можете вызвать GCC с -Q --help=optimizers, чтобы узнать точный набор оптимизаций, включённых на каждом уровне. См. Общие параметры для примеров.

-O

-O1

Оптимизация. Компиляция с оптимизацией занимает больше времени и больше памяти для большой функции.

С -O компилятор пытается уменьшить размер кода и время выполнения, не выполняя оптимизаций, которые занимают большое время компиляции.

-O включает следующие флаги оптимизации:

-fauto-inc-dec 
-fbranch-count-reg 
-fcombine-stack-adjustments 
-fcompare-elim 
-fcprop-registers 
-fdce 
-fdefer-pop 
-fdelayed-branch 
-fdse 
-fforward-propagate 
-fguess-branch-probability 
-fif-conversion2 
-fif-conversion 
-finline-functions-called-once 
-fipa-pure-const 
-fipa-profile 
-fipa-reference 
-fmerge-constants 
-fmove-loop-invariants 
-fshrink-wrap 
-fsplit-wide-types 
-ftree-bit-ccp 
-ftree-ccp 
-fssa-phiopt 
-ftree-ch 
-ftree-copy-prop 
-ftree-copyrename 
-ftree-dce 
-ftree-dominator-opts 
-ftree-dse 
-ftree-forwprop 
-ftree-fre 
-ftree-phiprop 
-ftree-sink 
-ftree-slsr 
-ftree-sra 
-ftree-pta 
-ftree-ter 
-funit-at-a-time

-O также включает -fomit-frame-pointer на машинах, где это не мешает отладке.

-O2

Ещё более полная оптимизация. GCC выполняет почти все поддерживаемые оптимизации, которые не связаны с балансом между размером и скоростью. По сравнению с -O, этот параметр увеличивает как время компиляции, так и производительность сгенерированного кода.

-O2 включает все флаги оптимизации, указанные в -O. Он также включает следующие флаги оптимизации:

-fthread-jumps 
-falign-functions  -falign-jumps 
-falign-loops  -falign-labels 
-fcaller-saves 
-fcrossjumping 
-fcse-follow-jumps  -fcse-skip-blocks 
-fdelete-null-pointer-checks 
-fdevirtualize -fdevirtualize-speculatively 
-fexpensive-optimizations 
-fgcse  -fgcse-lm  
-fhoist-adjacent-loads 
-finline-small-functions 
-findirect-inlining 
-fipa-cp 
-fipa-cp-alignment 
-fipa-sra 
-fipa-icf 
-fisolate-erroneous-paths-dereference 
-flra-remat 
-foptimize-sibling-calls 
-foptimize-strlen 
-fpartial-inlining 
-fpeephole2 
-freorder-blocks -freorder-blocks-and-partition -freorder-functions 
-frerun-cse-after-loop  
-fsched-interblock  -fsched-spec 
-fschedule-insns  -fschedule-insns2 
-fstrict-aliasing -fstrict-overflow 
-ftree-builtin-call-dce 
-ftree-switch-conversion -ftree-tail-merge 
-ftree-pre 
-ftree-vrp 
-fipa-ra

Обратите внимание на предупреждение под -fgcse о вызове -O2 для программ, использующих вычисленные переходы.

-O3

Ещё более глубокая оптимизация. -O3 включает все оптимизации, указанные в -O2, а также включает -finline-functions, -funswitch-loops, -fpredictive-commoning, -fgcse-after-reload, -ftree-loop-vectorize, -ftree-loop-distribute-patterns, -ftree-slp-vectorize, -fvect-cost-model, -ftree-partial-pre и -fipa-cp-clone.

-O0

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

-Os

Оптимизация по размеру. -Os включает все оптимизации -O2, которые обычно не увеличивают размер кода. Он также выполняет дополнительные оптимизации, предназначенные для уменьшения размера кода.

-Os отключает следующие флаги оптимизации:

-falign-functions  -falign-jumps  -falign-loops 
-falign-labels  -freorder-blocks  -freorder-blocks-and-partition 
-fprefetch-loop-arrays

-Ofast

Игнорирование строгого соответствия стандартам. -Ofast включает все оптимизации -O3. Он также включает оптимизации, которые не являются допустимыми для всех программ, соответствующих стандарту. Он включает -ffast-math и специфичные для Fortran -fno-protect-parens и -fstack-arrays.

-Og

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

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

Параметры вида -fflag задают независимые от машины флаги. Большинство флагов имеют положительную и отрицательную формы; отрицательная форма -ffoo — -fno-foo. В таблице ниже указана только одна из форм — та, которую вы обычно используете. Вы можете определить другую форму, удалив ‘no-’ или добавив её.

Следующие параметры управляют определёнными оптимизациями. Они либо активируются параметрами -O, либо связаны с ними. Вы можете использовать следующие флаги в редких случаях, когда требуется «тонкая настройка» выполняемых оптимизаций.

-fno-defer-pop

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

Отключено на уровнях -O, -O2, -O3, -Os.

-fforward-propagate

Выполнить проход по направлению «вперед» (forward propagation) на RTL. Проход пытается объединить две инструкции и проверяет, можно ли упростить результат. Если включено разворачивание циклов, выполняется два прохода, и второй планируется после разворачивания цикла.

Этот параметр включен по умолчанию на уровнях оптимизации -O, -O2, -O3, -Os.

-ffp-contract=style

-ffp-contract=off отключает сокращение выражений с плавающей точкой. -ffp-contract=fast включает сокращение выражений с плавающей точкой, например, формирование операций умножения-сложения (fused multiply-add), если целевая платформа имеет родную поддержку этих операций. -ffp-contract=on включает сокращение выражений с плавающей точкой, если это разрешено языковым стандартом. В настоящее время это не реализовано и обрабатывается так же, как -ffp-contract=off.

По умолчанию используется -ffp-contract=fast.

-fomit-frame-pointer

Не сохраняйте указатель на кадр (frame pointer) в регистре для функций, которым он не нужен. Это избегает инструкций сохранения, настройки и восстановления указателя на кадр; также это делает дополнительный регистр доступным во многих функциях. Это также делает отладку невозможной на некоторых машинах.

На некоторых машинах, таких как VAX, этот флаг не имеет эффекта, потому что стандартная последовательность вызовов автоматически обрабатывает указатель на кадр и ничего не экономит, делая вид, что он не существует. Макрос описания машины FRAME_POINTER_REQUIRED управляет тем, поддерживает ли целевая машина этот флаг. См. Использование регистров в руководстве по внутренним механизмам GNU Compiler Collection (GCC).

Значение по умолчанию (когда не оптимизируется размер) для 32-битных целей GNU/Linux x86 и 32-битных Darwin x86 составляет -fomit-frame-pointer. Вы можете настроить GCC с параметром конфигурации --enable-frame-pointer, чтобы изменить значение по умолчанию.

Включено на уровнях -O, -O2, -O3, -Os.

-foptimize-sibling-calls

Оптимизировать вызовы «родственных» функций и вызовы по хвосту (tail recursive calls).

Включено на уровнях -O2, -O3, -Os.

-foptimize-strlen

Оптимизировать различные стандартные функции C для работы со строками (например, strlen, strchr или strcpy) и их _FORTIFY_SOURCE аналоги в более быстрые альтернативы.

Включено на уровнях -O2, -O3.

-fno-inline

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

Отдельные функции могут быть исключены из встраивания (inline), пометив их атрибутом noinline.

-finline-small-functions

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

Включено на уровне -O2.

-findirect-inlining

Также встраивать непрямые вызовы, которые оказываются известными на этапе компиляции благодаря предыдущему встраиванию. Этот параметр имеет эффект только в том случае, если само встраивание (inline) включено параметрами -finline-functions или -finline-small-functions.

Включено на уровне -O2.

-finline-functions

Рассмотреть все функции для встраивания (inline), даже если они не объявлены inline. Компилятор эвристически определяет, стоит ли встраивать такие функции.

Если все вызовы данной функции встраиваются, и функция объявлена static, то функция обычно не выводится как код ассемблера сама по себе.

Включено на уровне -O3.

-finline-functions-called-once

Рассмотреть все static функции, вызываемые один раз, для встраивания в вызывающую функцию, даже если они не помечены inline. Если вызов данной функции встраивается, то функция не выводится как код ассемблера сама по себе.

Включено на уровнях -O1, -O2, -O3 и -Os.

-fearly-inlining

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

Включено по умолчанию.

-fipa-sra

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

Включено на уровнях -O2, -O3 и -Os.

-finline-limit=n

По умолчанию GCC ограничивает размер функций, которые могут быть встроены (inline). Этот флаг позволяет грубо контролировать этот лимит. n — размер функций, которые могут быть встроены (inline), в количестве псевдоинструкций.

Встраивание (inline) фактически контролируется рядом параметров, которые можно указать индивидуально с помощью --param name=value. Параметр -finline-limit=n устанавливает некоторые из этих параметров следующим образом:

max-inline-insns-single: устанавливается в n/2.
max-inline-insns-auto: устанавливается в n/2.

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

Примечание: может не быть значения -finline-limit, которое приводит к поведению по умолчанию.

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

-fno-keep-inline-dllexport

Это более подробная версия -fkeep-inline-functions, которая применяется только к функциям, объявленным с использованием атрибута dllexport или declspec (см. Объявление атрибутов функций.)

-fkeep-inline-functions

В C, выведите static функции, объявленные inline, в объектный файл, даже если функция была встроена (inline) во все её вызывающие функции. Этот переключатель не влияет на функции, использующие расширение extern inline в GNU C90. В C++, выведите все inline-функции в объектный файл.

-fkeep-static-consts

Вывести переменные, объявленные static const, когда оптимизация не включена, даже если переменные не ссылаются.

GCC по умолчанию включает этот параметр. Если вы хотите заставить компилятор проверить, ссылается ли переменная, независимо от того, включена ли оптимизация, используйте параметр -fno-keep-static-consts.

-fmerge-constants

Попытаться объединить одинаковые константы (строковые константы и константы с плавающей точкой) в разных единицах компиляции.

Этот параметр используется по умолчанию для оптимизированной компиляции, если ассемблер и компоновщик её поддерживают. Используйте -fno-merge-constants, чтобы запретить это поведение.

Включено на уровнях -O, -O2, -O3, -Os.

-fmerge-all-constants

Попытаться объединить одинаковые константы и одинаковые переменные.

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

-fmodulo-sched

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

-fmodulo-sched-allow-regmoves

Выполнить более агрессивное планирование с помощью SMS с разрешенными перемещениями регистров. Установив этот флаг, некоторые реберные антизависимости удаляются, что приводит к генерации перемещений регистров на основе анализа области жизни. Этот параметр эффективен только при включенном -fmodulo-sched.

-fno-branch-count-reg

Не использовать инструкции «уменьшение и переход» (decrement and branch) в регистре счётчика, а вместо этого генерировать последовательность инструкций, которая уменьшает регистр, сравнивает его с нулём, а затем выполняет переход в зависимости от результата. Этот параметр имеет смысл только на архитектурах, которые поддерживают такие инструкции, включая x86, PowerPC, IA-64 и S/390.

Включено по умолчанию при -O1 и выше.

Значение по умолчанию — -fbranch-count-reg.

-fno-function-cse

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

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

Значение по умолчанию — -ffunction-cse

-fno-zero-initialized-in-bss

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

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

Значение по умолчанию — -fzero-initialized-in-bss.

-fthread-jumps

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

Включено на уровнях -O2, -O3, -Os.

-fsplit-wide-types

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

Включено на уровнях -O, -O2, -O3, -Os.

-fcse-follow-jumps

При устранении общих подвыражений (CSE) просматривать инструкции перехода, когда цель перехода не достигается ни другим путём. Например, когда CSE сталкивается с инструкцией if с else фрагментом, CSE следует за переходом, когда проверяемое условие ложно.

Включено на уровнях -O2, -O3, -Os.

-fcse-skip-blocks

Это похоже на -fcse-follow-jumps, но заставляет CSE следовать переходам, которые условно пропускают блоки. Когда CSE сталкивается с простой инструкцией if без else фрагмента, -fcse-skip-blocks заставляет CSE следовать переходу вокруг тела if.

Включено на уровнях -O2, -O3, -Os.

-frerun-cse-after-loop

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

Включено на уровнях -O2, -O3, -Os.

-fgcse

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

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

Включено на уровнях -O2, -O3, -Os.

-fgcse-lm

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

Включено по умолчанию, когда включено -fgcse.

-fgcse-sm

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

Не включено на любом уровне оптимизации.

-fgcse-las

Когда -fgcse-las включено, глобальный проход устранения общих подвыражений устраняет избыточные загрузки, которые следуют за сохранениями в то же место памяти (как частичные, так и полные избытки).

Не включено на любом уровне оптимизации.

-fgcse-after-reload

Когда -fgcse-after-reload включено, после загрузки выполняется проход устранения избыточных загрузок. Цель этого прохода — очистка избыточного выталкивания.

-faggressive-loop-optimizations

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

-funsafe-loop-optimizations

Этот параметр сообщает оптимизатору циклов предположить, что индексы циклов не переполняются, и что циклы с нетривиальным условием выхода не являются бесконечными. Это позволяет использовать более широкий спектр оптимизаций циклов, даже если сам оптимизатор циклов не может доказать, что эти предположения верны. Если вы используете -Wunsafe-loop-optimizations, компилятор предупреждает вас, если обнаружит такой цикл.

-fcrossjumping

Выполнить преобразование переходов между ветвями. Это преобразование унифицирует эквивалентный код и экономит размер кода. Полученный код может или не может работать лучше, чем без преобразования переходов между ветвями.

Включено на уровнях -O2, -O3, -Os.

-fauto-inc-dec

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

-fdce

Выполнить устранение мёртвого кода (DCE) на RTL. Включено по умолчанию на уровнях -O и выше.

-fdse

Выполнить устранение мёртвого сохранения (DSE) на RTL. Включено по умолчанию на уровнях -O и выше.

-fif-conversion

Попытка преобразовать условные переходы в безветвящие эквиваленты. Это включает использование условных перемещений, min, max, установки флагов и инструкций abs, а также некоторые уловки, выполнимые стандартной арифметикой. Использование условного выполнения на процессорах, где оно доступно, контролируется -fif-conversion2.

Включено на уровнях -O, -O2, -O3, -Os.

-fif-conversion2

Использовать условное выполнение (если доступно) для преобразования условных переходов в безветвящие эквиваленты.

Включено на уровнях -O, -O2, -O3, -Os.

-fdeclone-ctor-dtor

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

Включено с -Os.

-fdelete-null-pointer-checks

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

Однако обратите внимание, что в некоторых средах это предположение неверно. Используйте -fno-delete-null-pointer-checks, чтобы отключить эту оптимизацию для программ, которые зависят от этого поведения.

Некоторые целевые платформы, особенно встроенные, отключают этот параметр на всех уровнях. В противном случае он включён на всех уровнях: -O0, -O1, -O2, -O3, -Os. Проходы, которые используют эту информацию, включаются независимо на разных уровнях оптимизации.

-fdevirtualize

Попытка преобразовать вызовы виртуальных функций в прямые вызовы. Это делается как внутри процедуры, так и между процедурами в рамках косвенного встраивания (-findirect-inlining) и межпроцедурной константной подстановки (-fipa-cp). Включено на уровнях -O2, -O3, -Os.

-fdevirtualize-speculatively

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

-fdevirtualize-at-ltrans

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

-fexpensive-optimizations

Выполнение ряда второстепенных оптимизаций, которые относительно дороги.

Включено на уровнях -O2, -O3, -Os.

-free

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

Включено для Alpha, AArch64 и x86 на уровнях -O2, -O3, -Os.

-fno-lifetime-dse

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

-flive-range-shrinkage

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

-fira-algorithm=algorithm

Использование указанного алгоритма окраски для интегрированного регистратора. Аргумент algorithm может быть ‘priority’, который указывает алгоритм приоритетной окраски Chow, или ‘CB’, который указывает алгоритм окраски Chaitin-Briggs. Алгоритм окраски Chaitin-Briggs не реализован для всех архитектур, но для тех целей, которые его поддерживают, он является значением по умолчанию, потому что он генерирует лучший код.

-fira-region=region

Используйте указанные регионы для интегрированного распределения регистров. Аргумент region должен быть одним из следующих:

‘all’: Используйте все циклы в качестве регионов распределения регистров. Это может дать лучшие результаты для машин с небольшим и/или нерегулярным набором регистров.
‘mixed’: Используйте все циклы, кроме циклов с малым давлением на регистры, в качестве регионов. Это значение обычно дает лучшие результаты в большинстве случаев и для большинства архитектур и включено по умолчанию при компиляции с оптимизацией по скорости (-O, -O2, …).
‘one’: Используйте все функции как один регион. Это обычно приводит к наименьшему размеру кода и включено по умолчанию для -Os или -O0.

-fira-hoist-pressure

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

Этот параметр включен на уровне -Os для всех целевых платформ.

-fira-loop-pressure

Используйте IRA для оценки давления на регистры в циклах для принятия решений о перемещении инвариантов цикла. Этот параметр обычно приводит к генерации более быстрого и компактного кода на машинах с большой памятью регистров (>= 32 регистра), но может замедлить компилятор.

Этот параметр включен на уровне -O3 для некоторых целевых платформ.

-fno-ira-share-save-slots

-fno-ira-share-spill-slots

-fira-verbose=n

Управление подробностью файла вывода для интегрированного распределения регистров. Значение по умолчанию равно 5. Если значение n больше или равно 10, вывод выводится в stderr в том же формате, что и n минус 10.

-flra-remat

Включить чувствительную к CFG рематериалзацию в LRA. Вместо загрузки значений пролитых псевдопеременных, LRA пытается рематериалзовать (пересчитать) значения, если это выгодно.

Включено на уровнях -O2, -O3, -Os.

-fdelayed-branch

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

Включено на уровнях -O, -O2, -O3, -Os.

-fschedule-insns

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

Включено на уровнях -O2, -O3.

-fschedule-insns2

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

Включено на уровнях -O2, -O3, -Os.

-fno-sched-interblock

Не планировать инструкции между базовыми блоками. Это обычно включено по умолчанию при планировании перед распределением регистров, т.е. с -fschedule-insns или на -O2 или выше.

-fno-sched-spec

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

-fsched-pressure

Включить планирование инструкций, чувствительное к давлению на регистры, перед распределением регистров. Это имеет смысл только при включенном планировании перед распределением регистров, т.е. с -fschedule-insns или на -O2 или выше. Использование этого параметра может улучшить сгенерированный код и уменьшить его размер, предотвращая увеличение давления на регистры выше количества доступных регистров и последующих проливов при распределении регистров.

-fsched-spec-load

Разрешить условное перемещение некоторых инструкций загрузки. Это имеет смысл только при планировании перед распределением регистров, т.е. с -fschedule-insns или на -O2 или выше.

-fsched-spec-load-dangerous

Разрешить условное перемещение большего количества инструкций загрузки. Это имеет смысл только при планировании перед распределением регистров, т.е. с -fschedule-insns или на -O2 или выше.

-fsched-stalled-insns

-fsched-stalled-insns=n

Определение того, сколько инструкций (если есть) могут быть перемещены преждевременно из очереди заблокированных инструкций в список готовых во время второго прохода планирования. -fno-sched-stalled-insns означает, что никакие инструкции не перемещаются преждевременно, -fsched-stalled-insns=0 означает, что нет ограничения на то, сколько ожидающих инструкций можно перемещать преждевременно. -fsched-stalled-insns без значения эквивалентно -fsched-stalled-insns=1.

-fsched-stalled-insns-dep

-fsched-stalled-insns-dep=n

Определение того, сколько групп инструкций (циклов) проверяется на зависимость от приостановленной инструкции, которая является кандидатом на преждевременное удаление из очереди приостановленных инструкций. Это имеет эффект только во время второго прохода планирования и только если используется -fsched-stalled-insns. -fno-sched-stalled-insns-dep эквивалентно -fsched-stalled-insns-dep=0. -fsched-stalled-insns-dep без значения эквивалентно -fsched-stalled-insns-dep=1.

-fsched2-use-superblocks

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

Это имеет смысл только при планировании после распределения регистров, т.е. с -fschedule-insns2 или на -O2 или выше.

-fsched-group-heuristic

Включить эвристику группы в планировщике. Эта эвристика отдает предпочтение инструкции, которая принадлежит к группе планирования. Это включено по умолчанию, когда планирование включено, т.е. с -fschedule-insns или -fschedule-insns2 или на -O2 или выше.

-fsched-critical-path-heuristic

Включить эвристику критической цепи в планировщике. Эта эвристика отдает предпочтение инструкциям на критической цепи. Это включено по умолчанию, когда планирование включено, т.е. с -fschedule-insns или -fschedule-insns2 или на -O2 или выше.

-fsched-spec-insn-heuristic

Включить эвристику спекулятивной инструкции в планировщике. Эта эвристика отдает предпочтение спекулятивным инструкциям с большей слабостью зависимостей. Это включено по умолчанию, когда планирование включено, т.е. с -fschedule-insns или -fschedule-insns2 или на -O2 или выше.

-fsched-rank-heuristic

Включить эвристику ранга в планировщике. Эта эвристика отдает предпочтение инструкции, принадлежащей базовому блоку с большим размером или частотой. Это включено по умолчанию, когда планирование включено, т.е. с -fschedule-insns или -fschedule-insns2 или на -O2 или выше.

-fsched-last-insn-heuristic

Включить эвристику последней инструкции в планировщике. Эта эвристика отдает предпочтение инструкции, которая меньше зависит от последней запланированной инструкции. Это включено по умолчанию, когда планирование включено, т.е. с -fschedule-insns или -fschedule-insns2 или на -O2 или выше.

-fsched-dep-count-heuristic

Включить эвристику счётчика зависимостей в планировщике. Эта эвристика отдает предпочтение инструкции, от которой зависят больше инструкций. Это включено по умолчанию, когда планирование включено, т.е. с -fschedule-insns или -fschedule-insns2 или на -O2 или выше.

-freschedule-modulo-scheduled-loops

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

-fselective-scheduling

Планирование инструкций с использованием алгоритма селективного планирования. Селективное планирование выполняется вместо первого прохода планировщика.

-fselective-scheduling2

Планирование инструкций с использованием алгоритма селективного планирования. Селективное планирование выполняется вместо второго прохода планировщика.

-fsel-sched-pipelining

Включить программную конвейеризацию вложенных циклов во время селективного планирования. Этот параметр не действует, если не включен один из -fselective-scheduling или -fselective-scheduling2.

-fsel-sched-pipelining-outer-loops

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

-fsemantic-interposition

Некоторые форматы объектов, такие как ELF, позволяют динамической библиотеке перехватывать символы. Это означает, что для символов, экспортированных из DSO, компилятор не может выполнять межпроцедурную обработку, встраивание и другие оптимизации в ожидании того, что функция или переменная могут измениться. Хотя эта функция полезна, например, для переписывания функций выделения памяти реализацией отладки, она дорогостоящая с точки зрения качества кода. С -fno-semantic-interposition компилятор предполагает, что если перехват происходит для функций, функция-замена будет иметь точно такие же семантику (и побочные эффекты). Аналогично, если перехват происходит для переменных, конструктор переменной будет таким же. Флаг не имеет эффекта для функций, явно объявленных inline (где никогда не разрешается перехват, меняющий семантику), и для символов, явно объявленных weak.

-fshrink-wrap

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

-fcaller-saves

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

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

Включено на уровнях -O2, -O3, -Os.

-fcombine-stack-adjustments

Отслеживает корректировки стека (вставки и удаления) и обращения к памяти стека, а затем пытается найти способы их объединения.

Включено по умолчанию при -O1 и выше.

-fipa-ra

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

Включено на уровнях -O2, -O3, -Os.

-fconserve-stack

Попытка минимизировать использование стека. Компилятор пытается использовать меньше места в стеке, даже если это замедляет программу. Этот параметр подразумевает установку параметра large-stack-frame в 100 и параметра large-stack-frame-growth в 400.

-ftree-reassoc

Выполнить перегруппировку деревьев. Этот флаг включен по умолчанию при -O и выше.

-ftree-pre

Выполнить частичную элиминацию избыточности (PRE) на деревьях. Этот флаг включён по умолчанию при -O2 и -O3.

-ftree-partial-pre

Сделать частичную элиминацию избыточности (PRE) более агрессивной. Этот флаг включён по умолчанию при -O3.

-ftree-forwprop

Выполнить прямое распространение на деревьях. Этот флаг включён по умолчанию при -O и выше.

-ftree-fre

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

-ftree-phiprop

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

-fhoist-adjacent-loads

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

-ftree-copy-prop

Выполнить копирование копирования на деревьях. Этот этап устраняет нежелательные операции копирования. Этот флаг включён по умолчанию при -O и выше.

-fipa-pure-const

Определяются чистые или постоянные функции. Включено по умолчанию при -O и выше.

-fipa-reference

Определяются статические переменные, которые не выходят за пределы блока компиляции. Включено по умолчанию при -O и выше.

-fipa-pta

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

-fipa-profile

Выполнить распространение профиля междисциплинарно. Функции, вызываемые только из холодных функций, помечаются как холодные. Также определяются функции, выполняемые один раз (например, cold, noreturn, статические конструкторы или деструкторы). Затем холодные функции и части функций, выполняемые один раз, не содержащие циклов, оптимизируются по размеру. Включено по умолчанию при -O и выше.

-fipa-cp

Выполнить междисциплинарное распространение констант. Эта оптимизация анализирует программу, чтобы определить, когда значения, передаваемые функциям, являются константами, а затем оптимизирует соответствующим образом. Эта оптимизация может существенно увеличить производительность, если приложение передаёт константы функциям. Этот флаг включён по умолчанию при -O2, -Os и -O3.

-fipa-cp-clone

Выполнить клонирование функций для повышения эффективности междисциплинарного распространения констант. При включении междисциплинарное распространение констант выполняет клонирование функций, когда внешне видимая функция может быть вызвана с константными аргументами. Поскольку эта оптимизация может создавать несколько копий функций, она может значительно увеличить размер кода (см. --param ipcp-unit-growth=value). Этот флаг включен по умолчанию при -O3.

-fipa-cp-alignment

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

Этот флаг включён по умолчанию при -O2 и -Os. Требуется включить -fipa-cp.

-fipa-icf

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

Тем не менее, поведение аналогично оптимизации Gold Linker ICF. GCC ICF работает на разных уровнях, и поэтому оптимизации не одинаковы — существуют эквивалентности, найденные только GCC, и эквивалентности, найденные только Gold.

Этот флаг включён по умолчанию при -O2 и -Os.

-fisolate-erroneous-paths-dereference

Обнаружить пути, которые вызывают ошибочное или неопределённое поведение из-за разыменования нулевого указателя. Изолировать эти пути от основного потока управления и преобразовать оператор с ошибочным или неопределённым поведением в ловушку. Этот флаг включён по умолчанию при -O2 и выше.

-fisolate-erroneous-paths-attribute

Обнаружить пути, которые вызывают ошибочное или неопределённое поведение из-за использования нулевого значения способом, запрещённым атрибутом returns_nonnull или nonnull. Изолировать эти пути от основного потока управления и преобразовать оператор с ошибочным или неопределённым поведением в ловушку. В настоящее время это не включено, но может быть включено при -O2 в будущем.

-ftree-sink

Выполнить перемещение вперёд хранений на деревьях. Этот флаг включён по умолчанию при -O и выше.

-ftree-bit-ccp

Выполнить распространение разреженных условных битовых констант на деревьях и распространить информацию о выравнивании указателей. Этот этап работает только с локальными скалярными переменными и включён по умолчанию при -O и выше. Требуется включить -ftree-ccp.

-ftree-ccp

Выполнить распространение разреженных условных констант (CCP) на деревьях. Этот этап работает только с локальными скалярными переменными и включён по умолчанию при -O и выше.

-fssa-phiopt

Выполнить сопоставление шаблонов на узлах PHI SSA для оптимизации условного кода. Этот этап включён по умолчанию при -O и выше.

-ftree-switch-conversion

Выполнить преобразование простых инициализаций в switch в инициализации из скалярного массива. Этот флаг включён по умолчанию при -O2 и выше.

-ftree-tail-merge

Поиск идентичных последовательностей кода. При обнаружении заменить одну переходом к другой. Эта оптимизация известна как слияние хвостов или перекрёстный переход. Этот флаг включён по умолчанию при -O2 и выше. Время компиляции на этом этапе может быть ограничено параметрами max-tail-merge-comparisons и max-tail-merge-iterations.

-ftree-dce

Выполнить удаление мёртвого кода (DCE) на деревьях. Этот флаг включён по умолчанию при -O и выше.

-ftree-builtin-call-dce

Выполнить условное удаление мёртвого кода (DCE) для вызовов встроенных функций, которые могут установить errno, но в противном случае не имеют побочных эффектов. Этот флаг включён по умолчанию при -O2 и выше, если также не указан -Os.

-ftree-dominator-opts

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

-ftree-dse

Выполнить элиминацию мёртвых хранений (DSE) на деревьях. Мёртвое хранение — это хранение в местоположении памяти, которое позже перезаписывается другим хранением без промежуточных загрузок. В этом случае более раннее хранение может быть удалено. Этот флаг включен по умолчанию при -O и выше.

-ftree-ch

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

-ftree-loop-optimize

Выполнить оптимизацию циклов на деревьях. Этот флаг включен по умолчанию при -O и выше.

-ftree-loop-linear

Выполнить преобразования перестановки циклов на дереве. То же, что -floop-interchange. Для использования этого преобразования кода GCC необходимо сконфигурировать с --with-isl для включения инфраструктуры преобразования циклов Graphite.

-floop-interchange

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

DO J = 1, M
  DO I = 1, N
    A(J, I) = A(J, I) * C
  ENDDO
ENDDO

преобразование перестановки циклов преобразует цикл так, как будто он был написан:

DO I = 1, N
  DO J = 1, M
    A(J, I) = A(J, I) * C
  ENDDO
ENDDO

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

-floop-strip-mine

Выполнить преобразования расщепления циклов для циклов. Расщепление цикла разделяет цикл на два вложенных цикла. Внешний цикл имеет шаги, равные размеру полосы, а внутренний цикл имеет шаги исходного цикла внутри полосы. Длина полосы может быть изменена с помощью параметра loop-block-tile-size. Например, задан цикл:

DO I = 1, N
  A(I) = A(I) + C
ENDDO

расщепление цикла преобразует цикл так, как будто он был написан:

DO II = 1, N, 51
  DO I = II, min (II + 50, N)
    A(I) = A(I) + C
  ENDDO
ENDDO

Эта оптимизация применима ко всем языкам, поддерживаемым GCC, и не ограничивается Fortran. Чтобы использовать это преобразование кода, GCC необходимо настроить с помощью --with-isl для включения инфраструктуры преобразования циклов Graphite.

-floop-block

Выполнить преобразования разбиения циклов для циклов. Разбиение разбивает каждый цикл в цикловом блоке так, что обращения к памяти элементов циклов помещаются в кэши. Длина полосы может быть изменена с помощью параметра loop-block-tile-size. Например, задан цикл:

DO I = 1, N
  DO J = 1, M
    A(J, I) = B(I) + C(J)
  ENDDO
ENDDO

разбиение цикла преобразует цикл так, как будто он был написан:

DO II = 1, N, 51
  DO JJ = 1, M, 51
    DO I = II, min (II + 50, N)
      DO J = JJ, min (JJ + 50, M)
        A(J, I) = B(I) + C(J)
      ENDDO
    ENDDO
  ENDDO
ENDDO

что может быть полезно, когда M больше, чем кэши, потому что внутренний цикл итерируется по меньшему объёму данных, который может храниться в кэшах. Эта оптимизация применима ко всем языкам, поддерживаемым GCC, и не ограничивается Fortran. Чтобы использовать это преобразование кода, GCC необходимо настроить с помощью --with-isl для включения инфраструктуры преобразования циклов Graphite.

-fgraphite-identity

Включить тождественное преобразование для графита. Для каждого SCoP мы генерируем полигональное представление и преобразуем его обратно в gimple. С помощью -fgraphite-identity мы можем проверить затраты или выгоды преобразования GIMPLE -> GRAPHITE -> GIMPLE. Некоторые минимальные оптимизации также выполняются генератором кода ISL, например, разделение индексов и удаление мёртвого кода в циклах.

-floop-nest-optimize

Включить оптимизатор вложенных циклов на основе ISL. Это универсальный оптимизатор вложенных циклов, основанный на алгоритмах оптимизации Pluto. Он вычисляет структуру циклов, оптимизированную для локальности данных и параллелизма. Этот параметр экспериментальный.

-floop-unroll-and-jam

Включить разворачивание и объединение для оптимизатора вложенных циклов на основе ISL. Коэффициент разворачивания можно изменить, используя параметр loop-unroll-jam-size. Развёртываемая размерность (считая с самой внутренней) может быть изменена с помощью параметра loop-unroll-jam-depth.

-floop-parallelize-all

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

-fcheck-data-deps

Сравнить результаты нескольких анализаторов зависимостей данных. Этот параметр используется для отладки анализаторов зависимостей данных.

-ftree-loop-if-convert

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

-ftree-loop-if-convert-stores

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

for (i = 0; i < N; i++)
  if (cond)
    A[i] = expr;

преобразуется в

for (i = 0; i < N; i++)
  A[i] = cond ? expr : A[i];

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

-ftree-loop-distribution

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

DO I = 1, N
  A(I) = B(I) + C
  D(I) = E(I) * F
ENDDO

преобразуется в

DO I = 1, N
   A(I) = B(I) + C
ENDDO
DO I = 1, N
   D(I) = E(I) * F
ENDDO

-ftree-loop-distribute-patterns

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

Этот этап распределяет циклы инициализации и генерирует вызов memset zero. Например, цикл

DO I = 1, N
  A(I) = 0
  B(I) = A(I) + I
ENDDO

преобразуется в

DO I = 1, N
   A(I) = 0
ENDDO
DO I = 1, N
   B(I) = A(I) + I
ENDDO

и цикл инициализации преобразуется в вызов memset zero.

-ftree-loop-im

Выполнить перемещение инвариантов цикла по дереву. Этот этап перемещает только инварианты, которые трудно обработать на уровне RTL (вызовы функций, операции, которые расширяются до нетривиальных последовательностей инструкций). С -funswitch-loops он также перемещает операнды условий, которые являются инвариантами, из цикла, так что мы можем использовать только тривиальный анализ инвариантности в цикле unswitching. Этап также включает перемещение записей.

-ftree-loop-ivcanon

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

-fivopts

Выполнить оптимизации переменных индукции (упрощение, слияние переменных индукции и устранение переменных индукции) по дереву.

-ftree-parallelize-loops=n

Распараллелить циклы, т.е. разделить их пространство итераций для выполнения в n потоках. Это возможно только для циклов, итерации которых независимы и могут быть произвольно переупорядочены. Оптимизация выгодна только на многопроцессорных машинах, для циклов, которые являются CPU-ёмкими, а не ограниченными, например, пропускной способностью памяти. Этот параметр подразумевает -pthread и, следовательно, поддерживается только на целевых платформах, которые поддерживают -pthread.

-ftree-pta

Выполнить локальный по функциям анализ «указывает на» по дереву. Этот флаг включен по умолчанию в -O и выше.

-ftree-sra

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

-ftree-copyrename

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

-ftree-coalesce-inlined-vars

Указать этапу переименования копий (см. -ftree-copyrename) попытаться объединить также небольшие переменные пользователя, но только если они встроены из других функций. Это более ограниченная форма -ftree-coalesce-vars. Это может навредить информации отладки таких встроенных переменных, но сохраняет переменные встраиваемой функции друг от друга, так что они с большей вероятностью будут содержать ожидаемые значения во время сеанса отладки.

-ftree-coalesce-vars

Указать этапу переименования копий (см. -ftree-copyrename) попытаться также объединить небольшие пользовательские переменные, а не только временные переменные компилятора. Это может серьёзно ограничить возможность отладки оптимизированной программы, скомпилированной с -fno-var-tracking-assignments. В отрицательной форме этот флаг предотвращает слияние SSA пользовательских переменных, включая встроенные. Этот параметр включен по умолчанию.

-ftree-ter

Выполнить замену временных выражений во время фазы SSA->нормальная. Временные переменные с одним использованием/определением заменяются в месте их использования своим определяющим выражением. Это приводит к коду, не являющемуся GIMPLE, но даёт расширителям гораздо более сложные деревья для работы, что приводит к лучшему генерированию RTL. Это включено по умолчанию в -O и выше.

-ftree-slsr

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

-ftree-vectorize

Выполнить векторизацию по дереву. Этот флаг включает -ftree-loop-vectorize и -ftree-slp-vectorize, если они не указаны явно.

-ftree-loop-vectorize

Выполнить векторизацию циклов по дереву. Этот флаг включен по умолчанию в -O3 и при включении -ftree-vectorize.

-ftree-slp-vectorize

Выполнить векторизацию основных блоков по дереву. Этот флаг включен по умолчанию в -O3 и при включении -ftree-vectorize.

-fvect-cost-model=model

Изменить модель затрат, используемую для векторизации. Аргумент model должен быть одним из ‘unlimited’, ‘dynamic’ или ‘cheap’. С моделью ‘unlimited’ предполагается, что векторный путь кода будет выгодным, а с моделью ‘dynamic’ проверка во время выполнения защищает векторный путь кода, чтобы включить его только для тех значений счётчика итераций, которые, вероятно, будут выполняться быстрее, чем при выполнении исходного скалярного цикла. Модель ‘cheap’ отключает векторизацию циклов, где это будет слишком дорогостоящим, например, из-за необходимых проверок во время выполнения на зависимость данных или выравнивание, но в остальном эквивалентна модели ‘dynamic’. Модель затрат по умолчанию зависит от других флагов оптимизации и является либо ‘dynamic’, либо ‘cheap’.

-fsimd-cost-model=model

Изменить модель стоимости, используемую для векторизации циклов, помеченных директивой OpenMP или Cilk Plus simd. Аргумент model должен быть одним из '`unlimited`', '`dynamic`', '`cheap`'. Все значения model имеют такое же значение, как описано в `-fvect-cost-model`, и по умолчанию используется модель стоимости, определённая с помощью `-fvect-cost-model'.

-ftree-vrp

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

-fsplit-ivs-in-unroller

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

Комбинация -fweb и CSE часто достаточна для достижения того же эффекта. Однако это ненадёжно в случаях, когда тело цикла сложнее одного основного блока. Оно также вообще не работает на некоторых архитектурах из-за ограничений прохода CSE.

Эта оптимизация включена по умолчанию.

-fvariable-expansion-in-unroller

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

-fpartial-inlining

Вставить части функций. Этот параметр имеет какой-либо эффект только при включении вставки функций -finline-functions или -finline-small-functions.

Включено на уровне -O2.

-fpredictive-commoning

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

Этот параметр включен на уровне -O3.

-fprefetch-loop-arrays

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

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

Выключен на уровне -Os.

-fno-peephole

-fno-peephole2

Отключить любые машино-специфичные оптимизации просмотров. Разница между -fno-peephole и -fno-peephole2 заключается в способе их реализации в компиляторе; некоторые целевые платформы используют одну, некоторые другую, несколько используют обе.

-fpeephole включено по умолчанию. -fpeephole2 включено на уровнях -O2, -O3, -Os.

-fno-guess-branch-probability

Не использовать эвристические методы для определения вероятностей ветвлений.

GCC использует эвристические методы для определения вероятностей ветвлений, если они не предоставлены данными профилирования (-fprofile-arcs). Эти эвристические методы основаны на графе потока управления. Если некоторые вероятности ветвлений указаны с помощью __builtin_expect, то эвристические методы используются для определения вероятностей ветвлений для остальной части графа потока управления, принимая во внимание __builtin_expect информацию. Взаимодействие между эвристическими методами и __builtin_expect может быть сложным, и в некоторых случаях может быть полезно отключить эвристические методы, чтобы влияние __builtin_expect было легче понять.

По умолчанию -fguess-branch-probability на уровнях -O, -O2, -O3, -Os.

-freorder-blocks

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

Включено на уровнях -O2, -O3.

-freorder-blocks-and-partition

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

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

Включено для x86 на уровнях -O2, -O3.

-freorder-functions

Переупорядочить функции в объектном файле для улучшения локальности кода. Это реализуется путём использования специальных подсекций .text.hot для наиболее часто выполняемых функций и .text.unlikely для редко выполняемых функций. Переупорядочивание выполняется линковщиком, поэтому формат объектных файлов должен поддерживать именованные секции, а линковщик должен размещать их разумным образом.

Также должны быть доступны данные профилирования, чтобы этот параметр был эффективным. Подробности см. в -fprofile-arcs.

Включено на уровнях -O2, -O3, -Os.

-fstrict-aliasing

Разрешить компилятору использовать самые строгие правила алиасинга, применимые к языку, который компилируется. Для C (и C++), это активирует оптимизации, основанные на типе выражений. В частности, предполагается, что объект одного типа никогда не будет находиться по тому же адресу, что и объект другого типа, если типы не почти одинаковы. Например, unsigned int может быть алиасом void*, но не double или int. Тип символьного типа может быть алиасом любого другого типа.

Обратите особое внимание на код такого вида:

union a_union {
  int i;
  double d;
};

int f() {
  union a_union t;
  t.d = 3.0;
  return t.i;
}

Практика чтения из другого члена объединения, кроме того, который был записан последним (называемая «типовой подменой») является распространённой. Даже с -fstrict-aliasing, типовая подмена разрешена, если память обращается через тип объединения. Таким образом, код выше работает как ожидалось. Смотрите Реализация структур, объединений, перечислений и битовых полей. Однако этот код может не работать:

int f() {
  union a_union t;
  int* ip;
  t.d = 3.0;
  ip = &t.i;
  return *ip;
}

Аналогично, доступ путём взятия адреса, преобразования полученного указателя и обращению к результату имеет неопределённое поведение, даже если преобразование использует тип объединения, например:

int f() {
  double d = 3.0;
  return ((union a_union *) &d)->i;
}

Параметр -fstrict-aliasing включен на уровнях -O2, -O3, -Os.

-fstrict-overflow

Разрешить компилятору использовать строгие правила переполнения со знаком, в зависимости от языка, который компилируется. Для C (и C++) это означает, что переполнение при арифметических операциях с числами со знаком является неопределённым, что означает, что компилятор может предположить, что оно не происходит. Это позволяет различные оптимизации. Например, компилятор предполагает, что выражение типа i + 10 > i всегда истинно для signed i. Это предположение верно только в том случае, если переполнение со знаком является неопределённым, поскольку выражение ложно, если i + 10 переполняется при использовании арифметики со знаком дополнительного кода. При применении этого параметра любая попытка определить, переполняется ли операция с числами со знаком, должна быть тщательно разработана, чтобы не использовать переполнение.

Этот параметр также позволяет компилятору использовать строгие семантики указателей: если добавление смещения к указателю на объект не приводит к указателю на тот же объект, то добавление неопределённо. Это позволяет компилятору сделать вывод, что p + u > p всегда истинно для указателя p и целого типа без знака u. Это предположение верно только потому, что переполнение указателей неопределённо, так как выражение ложно, если p + u переполняется с использованием арифметики со знаком дополнительного кода.

См. также параметр -fwrapv. Использование -fwrapv означает, что переполнение целых чисел со знаком полностью определено: оно циклически переполняется. При использовании -fwrapv между -fstrict-overflow и -fno-strict-overflow для целых чисел нет никакой разницы. При использовании -fwrapv определённые типы переполнения разрешены. Например, если компилятор получает переполнение при выполнении арифметических операций с константами, переполненное значение всё ещё может быть использовано с -fwrapv, но не иначе.

Параметр -fstrict-overflow включён на уровнях -O2, -O3, -Os.

-falign-functions

-falign-functions=n

Выравнивать начало функций к ближайшей степени двойки, большей чем n, пропуская до n байтов. Например, -falign-functions=32 выравнивает функции к следующей 32-байтовой границе, но -falign-functions=24 выравнивает к следующей 32-байтовой границе только в том случае, если это можно сделать, пропуская 23 байта или меньше.

-fno-align-functions и -falign-functions=1 эквивалентны и означают, что функции не выравниваются.

Некоторые ассемблеры поддерживают этот флаг только когда n является степенью двойки; в этом случае она округляется вверх.

Если n не указано или равно нулю, используется машино-зависимый по умолчанию.

Включено на уровнях -O2, -O3.

-falign-labels

-falign-labels=n

Выравнивать все целевые адреса ветвлений к границе, кратной степени двойки, пропуская до n байтов, как в -falign-functions. Этот параметр может легко замедлить код, потому что он должен вставить вспомогательные операции на случай, когда целевой адрес ветвления достигается в обычном потоке кода.

-fno-align-labels и -falign-labels=1 эквивалентны и означают, что метки не выравниваются.

Если -falign-loops или -falign-jumps применимы и больше этого значения, то используются их значения.

Если n не указано или равно нулю, используется машино-зависимый по умолчанию, который, скорее всего, будет '1', что означает отсутствие выравнивания.

Включено на уровнях -O2, -O3.

-falign-loops

-falign-loops=n

Выравнивать циклы к границе, кратной степени двойки, пропуская до n байтов, как в -falign-functions. Если циклы выполняются многократно, это компенсирует любые выполнения вспомогательных операций.

-fno-align-loops и -falign-loops=1 эквивалентны и означают, что циклы не выравниваются.

Если n не указано или равно нулю, используется машино-зависимый по умолчанию.

Включено на уровнях -O2, -O3.

-falign-jumps

-falign-jumps=n

Выравнивать цели ветвлений к границе степени двойки для целей ветвления, где к целям можно добраться только перепрыгиванием, пропуская до n байтов, как в -falign-functions. В этом случае не нужно выполнять никаких фиктивных операций.

-fno-align-jumps и -falign-jumps=1 эквивалентны и означают, что циклы не выравниваются.

Если n не указано или равно нулю, используется зависимая от машины по умолчанию.

Включено на уровнях -O2, -O3.

-funit-at-a-time

Этот параметр оставлен для совместимости. -funit-at-a-time не имеет эффекта, в то время как -fno-unit-at-a-time подразумевает -fno-toplevel-reorder и -fno-section-anchors.

Включено по умолчанию.

-fno-toplevel-reorder

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

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

-fweb

Строит веб-сети, как это обычно используется для целей выделения регистров, и присваивает каждой сети отдельный псевдорегистр. Это позволяет проходу выделения регистров работать непосредственно с псевдонимами, а также усиливает несколько других оптимизирующих проходов, таких как CSE, оптимизатор циклов и удалитель тривиального мёртвого кода. Однако это может сделать отладку невозможной, так как переменные больше не остаются в «домашнем регистре».

Включено по умолчанию с -funroll-loops.

-fwhole-program

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

Этот параметр не следует использовать в сочетании с -flto. Вместо этого использование плагина для компоновщика должно обеспечить более безопасную и точную информацию.

-flto[=n]

Этот параметр запускает стандартный оптимизатор, выполняемый на стадии компоновки. При вызове с исходным кодом он генерирует GIMPLE (одну из внутренних представлений GCC) и записывает его в специальные секции ELF в объектный файл. Когда объектные файлы объединяются вместе, все тела функций считываются из этих секций ELF и инициализируются так, как будто они были частью одного блока трансляции.

Для использования оптимизатора на стадии компоновки необходимо указать -flto и параметры оптимизации во время компиляции и окончательной компоновки. Например:

gcc -c -O2 -flto foo.c
gcc -c -O2 -flto bar.c
gcc -o myprog -flto -O2 foo.o bar.o

Первые два вызова GCC сохраняют байт-код представления GIMPLE в специальные секции ELF внутри foo.o и bar.o. Последний вызов считывает байт-код GIMPLE из foo.o и bar.o, объединяет оба файла в единый внутренний образ и компилирует результат обычным образом. Поскольку оба foo.o и bar.o объединяются в один образ, это позволяет всем межпроцедурным анализаторам и оптимизациям в GCC работать с этими двумя файлами, как если бы они были одним. Это означает, например, что инлайнер может встраивать функции из bar.o в функции из foo.o и наоборот.

Другой (более простой) способ включить оптимизацию на стадии компоновки:

gcc -o myprog -flto -O2 foo.c bar.c

Вышеупомянутый код генерирует байт-код для foo.c и bar.c, объединяет их в единое представление GIMPLE и оптимизирует их обычным образом, чтобы получить myprog.

Единственное важное, что следует помнить, это то, что для включения оптимизации на стадии компоновки необходимо использовать драйвер GCC для выполнения шага компоновки. GCC затем автоматически выполняет оптимизацию на стадии компоновки, если какой-либо из участвующих объектов был скомпилирован с опцией -flto в командной строке. В целом, вы должны указать параметры оптимизации, используемые для оптимизации на стадии компоновки, хотя GCC пытается угадать уровень оптимизации, используемый из параметров, используемых на стадии компиляции, если вы не укажете его на стадии компоновки. Вы всегда можете переопределить автоматическое решение использовать оптимизацию на стадии компоновки, передав -fno-lto команде компоновки.

Для эффективной оптимизации всего приложения необходимо сделать определенные предположения. Компилятор должен знать, к каким функциям и переменным могут получить доступ библиотеки и среда выполнения за пределами оптимизированного блока на стадии компоновки. При поддержке компоновщиком плагин компоновщика (см. -fuse-linker-plugin) передает информацию компилятору о используемых и внешне видимых символах. Если плагин компоновщика недоступен, следует использовать -fwhole-program, чтобы позволить компилятору сделать эти предположения, что приводит к более агрессивным решениям оптимизации.

Когда -fuse-linker-plugin не включен, тогда, когда файл компилируется с -flto, сгенерированный объектный файл больше, чем обычный объектный файл, потому что он содержит байт-код GIMPLE и обычный итоговый код (см. -ffat-lto-objects. Это означает, что объектные файлы с информацией LTO могут быть объединены как обычные объектные файлы; если -fno-lto передается компоновщику, никакие межпроцедурные оптимизации не применяются. Обратите внимание, что при включенном -fno-fat-lto-objects этап компиляции проходит быстрее, но вы не можете выполнить обычную компоновку без LTO.

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

gcc -c -O0 -ffat-lto-objects -flto foo.c
gcc -c -O0 -ffat-lto-objects -flto bar.c
gcc -o myprog -O3 foo.o bar.o

Это создает отдельные объектные файлы с не оптимизированным ассемблерным кодом, но результирующий двоичный файл myprog оптимизируется с -O3. Если вместо этого конечный двоичный файл генерируется с -fno-lto, то myprog не оптимизируется.

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

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

Если вы не указываете параметр уровня оптимизации -O на стадии компоновки, то GCC вычисляет его на основе уровней оптимизации, используемых при компиляции объектных файлов. Здесь выигрывает самый высокий уровень оптимизации.

В настоящее время следующие параметры и их настройки берутся из первого объектного файла, который их явно указал: -fPIC, -fpic, -fpie, -fcommon, -fexceptions, -fnon-call-exceptions, -fgnu-tm и все флаги целевой платформы -m.

Некоторые флаги, изменяющие ABI, требуются для соответствия во всех блоках трансляции, и попытка переопределить их на стадии компоновки с противоречивым значением игнорируется. Это включает такие параметры, как -freg-struct-return и -fpcc-struct-return.

Другие параметры, такие как -ffp-contract, -fno-strict-overflow, -fwrapv, -fno-trapv или -fno-strict-aliasing, передаются на стадию компоновки и объединяются консервативно для противоречивых блоков трансляции. В частности, -fno-strict-overflow, -fwrapv и -fno-trapv имеют приоритет, и, например, -ffp-contract=off имеет приоритет над -ffp-contract=fast. Вы можете переопределить их на стадии компоновки.

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

Если LTO сталкивается с объектами с C-связью, объявленными с несовместимыми типами в отдельных блоках трансляции, которые должны быть объединены вместе (неопределенное поведение в соответствии с ISO C99 6.2.7), может быть выдано диагностическое сообщение, которое не приводит к ошибке. Поведение по-прежнему неопределено во время выполнения. Подобные диагностические сообщения могут быть подняты для других языков.

Ещё одной функцией LTO является возможность применения межпроцедурных оптимизаций к файлам, написанным на разных языках:

gcc -c -flto foo.c
g++ -c -flto bar.cc
gfortran -c -flto baz.f90
g++ -o myprog -flto -O3 foo.o bar.o baz.o -lgfortran

Обратите внимание, что окончательная компоновка выполняется с g++ для получения C++ библиотек времени выполнения, и -lgfortran добавляется для получения Fortran библиотек времени выполнения. В целом, при смешивании языков в режиме LTO, вы должны использовать те же параметры команды компоновки, что и при смешивании языков в обычной (без LTO) компиляции.

Если объектные файлы, содержащие байт-код GIMPLE, хранятся в архиве библиотек, скажем, libfoo.a, их можно извлечь и использовать в компоновке LTO, если вы используете компоновщик с поддержкой плагинов. Для создания статических библиотек, подходящих для LTO, используйте gcc-ar и gcc-ranlib вместо ar и ranlib; чтобы показать символы объектных файлов с байт-кодом GIMPLE, используйте gcc-nm. Эти команды требуют, чтобы ar, ranlib и nm были скомпилированы с поддержкой плагинов. На стадии компоновки используйте флаг -fuse-linker-plugin, чтобы убедиться, что библиотека участвует в процессе оптимизации LTO:

gcc -o myprog -O2 -flto -fuse-linker-plugin a.o b.o -lfoo

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

Если вы не используете компоновщик с поддержкой плагинов и/или не включаете плагин компоновщика, то объекты внутри libfoo.a извлекаются и компонуются как обычно, но они не участвуют в процессе оптимизации LTO. Чтобы сделать статическую библиотеку пригодной как для оптимизации LTO, так и для обычной компоновки, скомпилируйте её объектные файлы с -flto -ffat-lto-objects.

Оптимизация на стадии компоновки не требует наличия всего приложения. Если приложение не требует экспорта каких-либо символов, можно объединить -flto и -fwhole-program, чтобы позволить межпроцедурным оптимизаторам использовать более агрессивные предположения, что может привести к улучшению возможностей оптимизации. Использование -fwhole-program не требуется, когда активен плагин компоновщика (см. -fuse-linker-plugin).

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

Оптимизация на стадии компоновки не работает хорошо с генерацией отладочной информации. Объединение -flto с -g в настоящее время находится в экспериментальной стадии и ожидается, что приведет к непредсказуемым результатам.

Если вы укажете необязательный параметр n, оптимизация и генерация кода на стадии компоновки будут выполняться параллельно с использованием n параллельных заданий с использованием установленной программы make. Переменная среды MAKE может быть использована для переопределения используемой программы. Значение по умолчанию для n равно 1.

Вы также можете указать -flto=jobserver, чтобы использовать режим сервера задач GNU make для определения количества параллельных заданий. Это полезно, когда Makefile, вызывающий GCC, уже выполняется параллельно. Для этого нужно добавить ‘+’ к рецепту команды в родительском Makefile. Эта опция, вероятно, будет работать только если MAKE является GNU make.

-flto-partition=alg

Укажите алгоритм разбиения, используемый оптимизатором на стадии компоновки. Значение может быть ‘1to1’ для указания разбиения, отражающего исходные файлы, ‘balanced’ для указания разбиения на части равного размера (по возможности) или ‘max’ для создания нового раздела для каждого символа, где это возможно. Указание ‘none’ как алгоритма полностью отключает разбиение и потоковую передачу. Значение по умолчанию — ‘balanced’. Хотя ‘1to1’ может использоваться как обходной путь для различных проблем с упорядочением кода, разбиение ‘max’ предназначено только для внутренних тестов. Значение ‘one’ указывает, что должно быть использовано ровно одно разбиение, а значение ‘none’ минует разбиение и выполняет оптимизацию на стадии компоновки непосредственно с фазы WPA.

-flto-odr-type-merging

Включить потоковую передачу имен замаскированных типов C++ и их объединение на стадии компоновки. Это увеличивает размер объектных файлов LTO, но включает диагностику нарушений правила одной дефиниции.

-flto-compression-level=n

Этот параметр задаёт уровень сжатия, используемый для промежуточного языка, записанного в объектные файлы LTO, и имеет смысл только в сочетании с режимом LTO (-flto). Допустимые значения — от 0 (без сжатия) до 9 (максимальное сжатие). Значения вне этого диапазона прижимаются к 0 или 9. Если параметр не задан, используется значение по умолчанию «balanced» для сжатия.

-flto-report

Выводит отчёт с внутренними подробностями работы оптимизатора временной связи. Содержание отчёта варьируется в зависимости от версии. Он предназначен для разработчиков GCC при обработке объектных файлов в режиме LTO (через -flto).

Отключён по умолчанию.

-flto-report-wpa

Аналогично -flto-report, но выводит информацию только для фазы WPA оптимизации Link Time.

-fuse-linker-plugin

Включает использование плагина компоновщика во время оптимизации на этапе связывания. Этот параметр зависит от поддержки плагинов в компоновщике, которая доступна в gold или в GNU ld 2.21 или более поздних версиях.

Этот параметр включает извлечение объектных файлов с байткодом GIMPLE из библиотек. Это улучшает качество оптимизации, предоставляя больше кода для оптимизатора на этапе связывания. Данная информация указывает, какие символы могут быть обращены к внешним источникам (объектами, не использующими LTO, или во время динамической компоновки). Результат улучшения качества кода в бинарных файлах (и динамических библиотеках, использующих скрытую видимость) аналогичен -fwhole-program. См. -flto для описания эффекта этого флага и способа его использования.

Этот параметр включён по умолчанию, когда в GCC включена поддержка LTO и GCC сконфигурирован для использования компоновщика, поддерживающего плагины (GNU ld 2.21 или более поздние версии или gold).

-ffat-lto-objects

Объектные файлы Fat LTO содержат как промежуточный язык, так и объектный код. Это делает их пригодными для компоновки LTO и обычной компоновки. Этот параметр эффективен только при компиляции с -flto и игнорируется во время компоновки.

-fno-fat-lto-objects улучшает время компиляции по сравнению с обычным LTO, но требует, чтобы весь инструментарий знал о LTO. Он требует компоновщика с поддержкой плагинов для базовых функций. Кроме того, nm, ar и ranlib должны поддерживать плагины компоновщика, чтобы позволить полноценную среду сборки (способную создавать статические библиотеки и т.д.). GCC предоставляет gcc-ar, gcc-nm, gcc-ranlib обёртки для передачи правильных параметров этим инструментам. С нежирными LTO makefiles нужно изменять, чтобы использовать их.

По умолчанию используется -fno-fat-lto-objects на целевых платформах с поддержкой плагинов компоновщика.

-fcompare-elim

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

Эта фаза применима только к определённым целевым платформам, которые не могут явно представить операцию сравнения до завершения распределения регистров.

Включено на уровнях -O, -O2, -O3, -Os.

-fcprop-registers

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

Включено на уровнях -O, -O2, -O3, -Os.

-fprofile-correction

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

-fprofile-dir=path

Установите каталог для поиска файлов данных профиля в path. Этот параметр затрагивает только данные профиля, созданные -fprofile-generate, -ftest-coverage, -fprofile-arcs и используемые -fprofile-use и -fbranch-probabilities и его связанными параметрами. Можно использовать абсолютные и относительные пути. По умолчанию GCC использует текущий каталог как path, поэтому файл данных профиля появляется в том же каталоге, что и объектный файл.

-fprofile-generate

-fprofile-generate=path

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

Включены следующие параметры: -fprofile-arcs, -fprofile-values, -fvpt.

Если указан path, GCC ищет файлы данных обратной связи профиля в path. См. -fprofile-dir.

-fprofile-use

-fprofile-use=path

Включить оптимизации, направленные на обратную связь профиля, и следующие оптимизации, которые обычно эффективны только при наличии обратной связи профиля: -fbranch-probabilities, -fvpt, -funroll-loops, -fpeel-loops, -ftracer, -ftree-vectorize и ftree-loop-distribute-patterns.

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

Если указан path, GCC ищет файлы данных обратной связи профиля в path. См. -fprofile-dir.

-fauto-profile

-fauto-profile=path

Включает оптимизации, направленные на обратную связь профиля, основанные на выборке, и следующие оптимизации, которые обычно эффективны только при наличии обратной связи профиля: -fbranch-probabilities, -fvpt, -funroll-loops, -fpeel-loops, -ftracer, -ftree-vectorize, -finline-functions, -fipa-cp, -fipa-cp-clone, -fpredictive-commoning, -funswitch-loops, -fgcse-after-reload и -ftree-loop-distribute-patterns.

path — имя файла, содержащего информацию о профиле AutoFDO. Если не указано, по умолчанию используется fbdata.afdo в текущем каталоге.

Для создания файла данных профиля AutoFDO необходимо запустить вашу программу с помощью утилиты perf на поддерживаемой системе GNU/Linux. Дополнительную информацию можно найти на странице https://perf.wiki.kernel.org/.

Например:

perf record -e br_inst_retired:near_taken -b -o perf.data \
    -- your_program

Затем используйте инструмент create_gcov для преобразования сырых данных профиля в формат, который может быть использован GCC. Вам также необходимо предоставить неснятый двоичный файл вашей программы этому инструменту. Дополнительную информацию можно найти на странице https://github.com/google/autofdo.

Например:

create_gcov --binary=your_program.unstripped --profile=perf.data \
    --gcov=profile.afdo

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

-ffloat-store

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

Этот параметр предотвращает нежелательное избыточное повышение точности на машинах, таких как 68000, где плавающие регистры (68881) сохраняют больше точности, чем предполагается у double. Аналогично для архитектуры x86. Для большинства программ избыточная точность полезна, но некоторые программы полагаются на точное определение IEEE плавающей запятой. Используйте -ffloat-store для таких программ после их модификации для сохранения всех соответствующих промежуточных вычислений в переменные.

-fexcess-precision=style

Этот параметр позволяет дополнительно контролировать избыточную точность на машинах, где регистры с плавающей запятой имеют большую точность, чем IEEE float и double типы, и процессор не поддерживает операции округления до этих типов. По умолчанию активен -fexcess-precision=fast; это означает, что операции выполняются с точностью регистров, и невозможно предсказать, когда происходит округление до типов, указанных в исходном коде. При компиляции C, если указан -fexcess-precision=standard, то избыточная точность следует правилам, указанным в ISO C99; в частности, как преобразования типов, так и присваивания вызывают округление значений до их семантических типов (в то время как -ffloat-store влияет только на присваивания). Этот параметр по умолчанию включён для C, если используется параметр строгой совместимости, такой как -std=c99.

-fexcess-precision=standard не реализован для языков, отличных от C, и не имеет эффекта, если указаны -funsafe-math-optimizations или -ffast-math. На x86 он также не имеет эффекта, если указаны -mfpmath=sse или -mfpmath=sse+387; в первом случае применяются семантика IEEE без избыточной точности, а во втором — округление непредсказуемо.

-ffast-math

Устанавливает параметры -fno-math-errno, -funsafe-math-optimizations, -ffinite-math-only, -fno-rounding-math, -fno-signaling-nans и -fcx-limited-range.

Этот параметр вызывает определение препроцессора-макроса __FAST_MATH__.

Этот параметр не включается никакими параметрами -O, кроме -Ofast, так как это может привести к неправильному результату для программ, которые зависят от точного выполнения IEEE или ISO правил/спецификаций для математических функций. Однако, он может привести к более быстрому коду для программ, которым не требуются гарантии этих спецификаций.

-fno-math-errno

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

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

По умолчанию установлен -fmath-errno.

В системах Darwin математическая библиотека никогда не устанавливает errno. Следовательно, нет причин для компилятора рассматривать такую возможность, и -fno-math-errno является значением по умолчанию.

-funsafe-math-optimizations

Разрешает оптимизации для арифметики с плавающей запятой, которые (a) предполагают, что аргументы и результаты действительны и (b) могут нарушать стандарты IEEE или ANSI. При использовании во время компоновки он может включать библиотеки или файлы инициализации, которые изменяют стандартное значение слова управления FPU или другие подобные оптимизации.

По умолчанию установлен -fno-unsafe-math-optimizations.

-fassociative-math

Разрешает перегруппировку операндов в последовательности операций с плавающей запятой. Это нарушает стандарт языка ISO C и C++, возможно, изменяя результат вычисления. ПРИМЕЧАНИЕ: переупорядочение может изменить знак нуля, а также игнорировать NaNs и подавить или создать переполнение или подпоток (и поэтому не может быть использовано в коде, который полагается на поведение округления, как (x + 2**52) - 2**52). Также может переупорядочить сравнения с плавающей запятой и, следовательно, не может использоваться, когда требуются упорядоченные сравнения. Этот параметр требует, чтобы оба -fno-signed-zeros и -fno-trapping-math были активны. Кроме того, он не имеет большого смысла с -frounding-math. Для Fortran параметр автоматически включается, когда оба -fno-signed-zeros и -fno-trapping-math активны.

По умолчанию установлен -fno-associative-math.

-freciprocal-math

Разрешает использовать обратную величину значения вместо деления на значение, если это позволяет оптимизации. Например, x / y можно заменить на x * (1/y), что полезно, если (1/y) подлежит устранению общих подвыражений. Обратите внимание, что это приводит к потере точности и увеличению количества операций с плавающей точкой над значением.

По умолчанию установлен -fno-reciprocal-math.

-ffinite-math-only

Разрешает оптимизации для арифметики с плавающей запятой, предполагая, что аргументы и результаты не являются NaN или +-бесконечность.

По умолчанию установлен -fno-finite-math-only.

-fno-signed-zeros

Разрешает оптимизации для арифметики с плавающей запятой, игнорируя знак нуля. Арифметика IEEE определяет поведение различных значений +0,0 и -0,0, что затем запрещает упрощение выражений, таких как x+0,0 или 0,0*x (даже с -ffinite-math-only). Этот параметр подразумевает, что знак нулевого результата не имеет значения.

По умолчанию установлен -fsigned-zeros.

-fno-trapping-math

Компилирует код, предполагая, что операции с плавающей запятой не могут генерировать видимые пользователю ловушки. Эти ловушки включают деление на ноль, переполнение, подпоток, неточные результаты и недопустимые операции. Этот параметр требует, чтобы -fno-signaling-nans был активен. Установка этого параметра может позволить получить более быстрый код, если вы полагаетесь на «бесперебойную» арифметику IEEE, например.

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

По умолчанию установлен -ftrapping-math.

-frounding-math

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

По умолчанию установлен -fno-rounding-math.

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

-fsignaling-nans

Компилирует код, предполагая, что IEEE сигнализирующие NaNs могут генерировать видимые пользователю ловушки во время операций с плавающей запятой. Установка этого параметра отключает оптимизации, которые могут изменить количество исключений, видимых с сигнализирующими NaNs. Этот параметр подразумевает -ftrapping-math.

Этот параметр вызывает определение препроцессора-макроса __SUPPORT_SNAN__.

По умолчанию установлен -fno-signaling-nans.

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

-fsingle-precision-constant

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

-fcx-limited-range

При включении этот параметр указывает, что шаг сокращения диапазона не нужен при выполнении комплексного деления. Также нет проверки, является ли результат комплексного умножения или деления NaN + I*NaN, с попыткой исправить ситуацию в этом случае. По умолчанию установлен -fno-cx-limited-range, но включается параметром -ffast-math.

Этот параметр управляет значением по умолчанию ISO C99 CX_LIMITED_RANGE директивы препроцессора. Тем не менее, параметр применим ко всем языкам.

-fcx-fortran-rules

Комплексное умножение и деление следуют правилам Fortran. Сокращение диапазона выполняется как часть комплексного деления, но нет проверки, является ли результат комплексного умножения или деления NaN + I*NaN, с попыткой исправить ситуацию в этом случае.

По умолчанию установлен -fno-cx-fortran-rules.

Следующие параметры управляют оптимизациями, которые могут улучшить производительность, но не включены никакими параметрами -O. Этот раздел включает экспериментальные параметры, которые могут привести к некорректному коду.

-fbranch-probabilities

После выполнения программы, скомпилированной с -fprofile-arcs (см. Параметры для отладки вашей программы или gcc), её можно скомпилировать повторно с использованием -fbranch-probabilities, чтобы улучшить оптимизации, основанные на количестве проходов через каждую ветвь. Когда программа, скомпилированная с -fprofile-arcs, завершается, она сохраняет счетчики выполнения дуг в файл под названием имя_исходного_файла.gcda для каждого исходного файла. Информация в этом файле сильно зависит от структуры сгенерированного кода, поэтому для обеих компиляций необходимо использовать один и тот же исходный код и те же параметры оптимизации.

С -fbranch-probabilities, GCC помещает заметку ‘REG_BR_PROB’ на каждую инструкцию ‘JUMP_INSN’ и ‘CALL_INSN’. Это может быть использовано для улучшения оптимизации. В настоящее время это используется только в одном месте: в reorg.c, вместо того, чтобы угадывать, какой путь ветвления наиболее вероятен, значения ‘REG_BR_PROB’ используются для точного определения того, какой путь используется чаще.

-fprofile-values

В сочетании с -fprofile-arcs добавляет код для сбора данных о значениях выражений в программе.

С -fbranch-probabilities считывает собранные данные о профилировании значений выражений для использования в оптимизациях.

Включается с помощью -fprofile-generate и -fprofile-use.

-fprofile-reorder-functions

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

Включается с помощью -fprofile-use.

-fvpt

В сочетании с -fprofile-arcs, этот параметр инструктирует компилятор добавить код для сбора информации о значениях выражений.

С -fbranch-probabilities, он считывает собранные данные и фактически выполняет оптимизации, основанные на них. В настоящее время оптимизации включают специализацию операций деления с использованием знаний о значении знаменателя.

-frename-registers

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

Включается по умолчанию с -funroll-loops и -fpeel-loops.

-fschedule-fusion

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

Включается на уровнях -O2, -O3, -Os.

-ftracer

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

Включается с помощью -fprofile-use.

-funroll-loops

Развернуть циклы, число итераций которых может быть определено во время компиляции или при входе в цикл. -funroll-loops подразумевает -frerun-cse-after-loop, -fweb и -frename-registers. Также включает полное срезание циклов (т.е. полное удаление циклов с небольшим постоянным числом итераций). Этот параметр увеличивает размер кода и может или не может ускорить его выполнение.

Включается с помощью -fprofile-use.

-funroll-all-loops

Развернуть все циклы, даже если количество итераций неизвестно при входе в цикл. Это обычно замедляет выполнение программы. -funroll-all-loops подразумевает те же параметры, что и -funroll-loops.

-fpeel-loops

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

Включается с помощью -fprofile-use.

-fmove-loop-invariants

Включает проход по перемещению инвариантов цикла в оптимизаторе циклов RTL. Включается на уровне -O1

-funswitch-loops

Перемещает ветви с условиями, инвариантными относительно цикла, из цикла с дубликатами цикла на обеих ветвях (изменёнными в соответствии с результатом условия).

-ffunction-sections

-fdata-sections

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

Используйте эти параметры на системах, где компоновщик может выполнять оптимизации для улучшения локализации ссылок в адресном пространстве инструкций. Большинство систем, использующих формат ELF и процессоры SPARC, работающие под Solaris 2, имеют компоновщики с такими оптимизациями. У AIX могут быть подобные оптимизации в будущем.

Используйте эти параметры только тогда, когда от этого есть значительная выгода. При указании этих параметров, ассемблер и компоновщик создают более крупные файлы объектов и исполняемых файлов и работают медленнее. Вы не можете использовать gprof на всех системах, если указали этот параметр, и у вас могут возникнуть проблемы с отладкой, если вы указали и этот параметр, и -g.

-fbranch-target-load-optimize

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

-fbranch-target-load-optimize2

Выполнить оптимизацию загрузки регистра целевой ветви после потоковой передачи пролога/эпилога.

-fbtr-bb-exclusive

При выполнении оптимизации загрузки регистра целевой ветви не используйте повторно регистры целевой ветви внутри любого базового блока.

-fstack-protector

Выводит дополнительный код для проверки переполнения буфера, например, атак типа "stack smashing". Это делается путем добавления защитной переменной к функциям с уязвимыми объектами. Это включает функции, которые вызывают alloca, и функции с буферами больше 8 байт. Защитные переменные инициализируются при входе в функцию и затем проверяются при выходе из функции. Если проверка защитной переменной завершается неудачно, выводится сообщение об ошибке, и программа завершается.

-fstack-protector-all

Как -fstack-protector, за исключением того, что все функции защищены.

-fstack-protector-strong

Как -fstack-protector, но включает дополнительные функции для защиты — те, которые имеют локальные определения массивов или имеют ссылки на локальные адреса фрейма.

-fstack-protector-explicit

Как -fstack-protector, но защищает только те функции, которые имеют атрибут stack_protect.

-fstdarg-opt

Оптимизировать пролог функций с переменным числом аргументов с учетом использования этих аргументов.

-fsection-anchors

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

Например, реализация следующей функции foo:

static int a, b, c;
int foo (void) { return a + b + c; }

обычно вычисляет адреса всех трех переменных, но если вы скомпилируете её с -fsection-anchors, она обращается к переменным из общей точки якорной ссылки вместо этого. Эффект подобен следующему псевдокоду (который не является допустимым C):

int foo (void)
{
  register int *xr = &x;
  return xr[&a - &x] + xr[&b - &x] + xr[&c - &x];
}

Не все целевые платформы поддерживают этот параметр.

--param name=value

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

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

В каждом случае значение является целым числом. Допустимые варианты имя определяются внутренней частью компилятора.

predictable-branch-outcome

Если вероятность выполнения ветви ниже этого порога (в процентах), то она считается хорошо предсказуемой. Значение по умолчанию — 10.

max-crossjump-edges

Максимальное количество входящих ребер, подлежащих рассмотрению для переходов по пересечению. Алгоритм, используемый -fcrossjumping, имеет сложность O(N^2) относительно количества ребер, входящих в каждый блок. Увеличение значений означает более агрессивную оптимизацию, что увеличивает время компиляции, но, вероятно, незначительно улучшает размер исполняемого файла.

min-crossjump-insns

Минимальное количество инструкций, которое должно совпадать в конце двух блоков перед выполнением перехода по пересечению. Это значение игнорируется в случае, когда все инструкции в блоке, из которого выполняется переход по пересечению, совпадают. Значение по умолчанию — 5.

max-grow-copy-bb-insns

Максимальный коэффициент увеличения размера кода при копировании основных блоков вместо использования перехода. Увеличение относительное к инструкции перехода. Значение по умолчанию — 8.

max-goto-duplication-insns

Максимальное количество инструкций, которые могут быть продублированы в блок, выполняющий переход на вычисленный goto. Чтобы избежать поведения O(N^2) в ряде проходов, GCC факторизует вычисленные goto на ранней стадии процесса компиляции и дефакторизует их как можно позже. Только вычисленные переходы в конце основных блоков с не более чем max-goto-duplication-insns инструкций дефакторизуются. Значение по умолчанию — 8.

max-delay-slot-insn-search

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

max-delay-slot-live-search

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

max-gcse-memory

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

max-gcse-insertion-ratio

Если отношение вставки выражений к удалениям для любого выражения больше этого значения, то RTL PRE вставляет или удаляет выражение, оставляя частично избыточные вычисления в потоке инструкций. Значение по умолчанию — 20.

max-pending-list-length

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

max-modulo-backtrack-attempts

Максимальное количество попыток отката, которые должен совершить планировщик при модульном планировании цикла. Большие значения могут экспоненциально увеличить время компиляции.

max-inline-insns-single

Несколько параметров управляют встроенным в GCC деревом инлайнинга. Это число задаёт максимальное количество инструкций (подсчитываемых в внутренней представлении GCC) в одной функции, которые рассматриваются деревом инлайнинга для встраивания. Это относится только к функциям, объявленным inline, и методам, реализованным в объявлении класса (C++). Значение по умолчанию — 400.

max-inline-insns-auto

При использовании -finline-functions (включено в -O3), большое количество функций, которые в противном случае не рассматривались бы для встраивания компилятором, исследуется. Для этих функций может быть применено другое (более жёсткое) ограничение по сравнению с объявленными inline функциями. Значение по умолчанию — 40.

inline-min-speedup

Если оценочное улучшение производительности времени выполнения вызывающей + вызываемой функции превышает этот порог (в процентах), функция может быть встроенной независимо от ограничения на --param max-inline-insns-single и --param max-inline-insns-auto.

large-function-insns

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

large-function-growth

Указывает максимальный рост большой функции, вызванный встраиванием, в процентах. Значение по умолчанию — 100, что ограничивает рост большой функции до 2,0 раз от первоначального размера.

large-unit-insns

Предел, определяющий большой трансляционный блок. Рост, вызванный встраиванием блоков, размер которых больше этого предела, ограничен параметром --param inline-unit-growth. Для небольших блоков это может быть слишком жёстким ограничением. Например, рассмотрите блок, состоящий из функции A, которая встраивается, и функции B, которая просто трижды вызывает функцию A. Если B мала по сравнению с A, рост блока составляет 300%, и тем не менее такое встраивание вполне разумно. Однако для очень больших блоков, состоящих из небольших встраиваемых функций, требуется общий предел роста блока, чтобы избежать экспоненциального взрыва размера кода. Таким образом, для меньших блоков размер увеличивается до --param large-unit-insns перед применением --param inline-unit-growth. Значение по умолчанию — 10000.

inline-unit-growth

Указывает максимальный общий рост трансляционного блока, вызванный встраиванием. Значение по умолчанию — 20, что ограничивает рост блока до 1,2 раза от первоначального размера. Холодные функции (отмеченные как холодные с помощью атрибута или обратной связью по профилю) не учитываются в размере блока.

ipcp-unit-growth

Указывает максимальный общий рост трансляционного блока, вызванный межпроцедурной константной простановкой. Значение по умолчанию — 10, что ограничивает рост блока до 1,1 раза от первоначального размера.

large-stack-frame

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

large-stack-frame-growth

Указывает максимальный рост больших стековых фреймов, вызванный встраиванием, в процентах. Значение по умолчанию — 1000, что ограничивает рост больших стековых фреймов до 11 раз от первоначального размера.

max-inline-insns-recursive

max-inline-insns-recursive-auto

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

--param max-inline-insns-recursive применяется к функциям, объявленным inline. Для функций, не объявленных inline, рекурсивное встраивание происходит только при включённом -finline-functions (включено в -O3); вместо этого применяется --param max-inline-insns-recursive-auto. Значение по умолчанию — 450.

max-inline-recursive-depth

max-inline-recursive-depth-auto

Указывает максимальную глубину рекурсии, используемую для рекурсивного встраивания.

--param max-inline-recursive-depth применяется к функциям, объявленным inline. Для функций, не объявленных inline, рекурсивное встраивание происходит только при включённом -finline-functions (включено в -O3); вместо этого применяется --param max-inline-recursive-depth-auto. Значение по умолчанию — 8.

min-inline-recursive-probability

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

При наличии обратной связи по профилю (см. -fprofile-generate) фактическая глубина рекурсии может быть предсказана по вероятности, что функция рекурсирует через заданное выражение вызова. Этот параметр ограничивает встраивание только выражениями вызова, вероятность которых превышает заданный порог (в процентах). Значение по умолчанию — 10.

early-inlining-insns

Указывает рост, который может быть достигнут ранним инлайнером. По сути, это увеличивает количество инлайнинга для кода с большой штрафом за абстракцию. Значение по умолчанию — 14.

max-early-inliner-iterations

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

comdat-sharing-probability

Вероятность (в процентах) того, что функция C++ inline с видимость comdat будет совмещаться в нескольких трансляционных блоках. Значение по умолчанию — 20.

profile-func-internal-id

Параметр для управления использованием внутреннего идентификатора функции в поиске по базе данных профиля. Если значение равно 0, компилятор использует идентификатор, основанный на имени ассемблера функции и имени файла, что делает старые данные профиля более устойчивыми к изменениям исходного кода, таким как перестановка функций и т. д. Значение по умолчанию — 0.

min-vect-loop-bound

Минимальное количество итераций, при котором циклы не векторизуются при использовании -ftree-vectorize. Число итераций после векторизации должно быть больше значения, указанного этим параметром, чтобы разрешить векторизацию. Значение по умолчанию — 0.

gcse-cost-distance-ratio

Коэффициент масштабирования при расчёте максимального расстояния, на которое выражение может быть перенесено оптимизациями GCSE. В настоящее время это поддерживается только в проходе перемещения кода. Чем больше отношение, тем более агрессивным является перемещение кода для простых выражений, т. е. выражений, стоимость которых меньше gcse-unrestricted-cost. Установка значения 0 отключает перемещение простых выражений. Значение по умолчанию — 10.

gcse-unrestricted-cost

Стоимость, приблизительно измеренная как стоимость одной типичной машинной инструкции, при которой оптимизации GCSE не ограничивают расстояние, на которое может перемещаться выражение. В настоящее время это поддерживается только в проходе перемещения кода. Чем меньше стоимость, тем более агрессивным является перемещение кода. Установка значения 0 разрешает всем выражениям перемещаться на неограниченные расстояния. Значение по умолчанию — 3.

max-hoist-depth

Глубина поиска в дереве доминантов для выражений для перемещения. Это используется для предотвращения квадратичного поведения в алгоритме перемещения. Значение 0 не ограничивает поиск, но может замедлить компиляцию огромных функций. Значение по умолчанию — 30.

max-tail-merge-comparisons

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

max-tail-merge-iterations

Максимальное количество итераций прохода по функции. Это используется для ограничения времени компиляции при слиянии хвостов дерева. Значение по умолчанию — 2.

max-unrolled-insns

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

max-average-unrolled-insns

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

max-unroll-times

Максимальное количество развёртываний одного цикла.

max-peeled-insns

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

max-peel-times

Максимальное число развёртываний одного цикла.

max-peel-branches

Максимальное число ветвлений на горячем пути через развернутую последовательность.

max-completely-peeled-insns

Максимальное число инструкций полностью развернутого цикла.

max-completely-peel-times

Максимальное число итераций цикла, пригодного для полного развёртывания.

max-completely-peel-loop-nest-depth

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

max-unswitch-insns

Максимальное число инструкций непереключенного цикла.

max-unswitch-level

Максимальное число непереключенных ветвлений в одном цикле.

iv-consider-all-candidates-bound

Минимальная стоимость дорогостоящего выражения в оптимизации перемещения инвариантов цикла.

iv-max-considered-uses

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

iv-always-prune-cand-set-bound

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

scev-max-expr-size

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

scev-max-expr-complexity

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

omega-max-vars

Максимальное количество переменных в системе ограничений Омега. Значение по умолчанию — 128.

omega-max-geqs

Максимальное количество неравенств в системе ограничений Омега. Значение по умолчанию — 256.

omega-max-eqs

Максимальное количество равенств в системе ограничений Омега. Значение по умолчанию — 128.

omega-max-wild-cards

Максимальное количество диких переменных, которые может вставить решатель Омега. Значение по умолчанию — 18.

omega-hash-table-size

Размер хеш-таблицы в решателе Омега. Значение по умолчанию — 550.

omega-max-keys

Максимальное число ключей, используемых решателем Омега. Значение по умолчанию — 500.

omega-eliminate-redundant-constraints

При значении 1 используются дорогостоящие методы для исключения всех избыточных ограничений. Значение по умолчанию — 0.

vect-max-version-for-alignment-checks

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

vect-max-version-for-alias-checks

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

vect-max-peeling-for-alignment

Максимальное число развёртываний циклов для повышения выравнивания доступа для векторизации. Значение -1 означает «без ограничения».

max-iterations-to-track

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

hot-bb-frequency-fraction

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

max-predicted-iterations

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

builtin-expect-probability

Управляйте вероятностью того, что выражение имеет заданное значение. Этот параметр принимает процент (т. е. 0...100) в качестве входных данных. Вероятность по умолчанию 90 получена эмпирически.

align-threshold

Выберите долю максимальной частоты выполнения блока в функции для выравнивания блока.

align-loop-iterations

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

tracer-dynamic-coverage

tracer-dynamic-coverage-feedback

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

Параметр tracer-dynamic-coverage-feedback используется только в том случае, если доступна обратная связь от профиля. Реальные профили (в отличие от статически оцененных) гораздо менее сбалансированы, что позволяет использовать более высокое значение порога.

tracer-max-code-growth

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

tracer-min-branch-ratio

Остановка обратного роста, когда обратная вероятность лучшего ребра меньше этого порога (в процентах).

tracer-min-branch-ratio

tracer-min-branch-ratio-feedback

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

Аналогично tracer-dynamic-coverage, присутствуют два значения, одно для компиляции с обратной связью профиля, а другое — без неё. Значение для компиляции с обратной связью профиля должно быть более консервативным (большим), чтобы сделать инструмент эффективным.

max-cse-path-length

Максимальное количество блоков на пути, которое CSE рассматривает. Значение по умолчанию — 10.

max-cse-insns

Максимальное количество инструкций, которые обрабатывает CSE перед сбросом. Значение по умолчанию — 1000.

ggc-min-expand

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

Значение по умолчанию — 30% + 70% * (ОЗУ/1 ГБ) с верхним пределом 100%, когда ОЗУ ≥ 1 ГБ. Если getrlimit доступен, понятие «ОЗУ» — это меньшее из фактического ОЗУ и RLIMIT_DATA или RLIMIT_AS. Если GCC не может рассчитать ОЗУ на определённой платформе, используется нижний предел 30%. Установка этого параметра и ggc-min-heapsize в ноль приводит к выполнению полной сборки при каждой возможности. Это очень медленно, но может быть полезно для отладки.

ggc-min-heapsize

Минимальный размер кучи сборщика мусора, прежде чем он начнёт утруждаться сбором мусора. Первая сборка происходит после расширения кучи на ggc-min-expand% за пределами ggc-min-heapsize. Опять же, настройка этого может улучшить скорость компиляции и не влияет на генерацию кода.

Значение по умолчанию — меньшее из значений ОЗУ/8, RLIMIT_RSS или предел, который пытается гарантировать, что RLIMIT_DATA или RLIMIT_AS не превышены, но с нижним пределом 4096 (четыре мегабайта) и верхним пределом 131072 (128 мегабайт). Если GCC не может рассчитать ОЗУ на определённой платформе, используется нижний предел. Установка этого параметра очень большим значением фактически отключает сбор мусора. Установка этого параметра и ggc-min-expand в ноль приводит к выполнению полной сборки при каждой возможности.

max-reload-search-insns

Максимальное количество инструкций перезагрузки, которое должно искать назад эквивалентный регистр. Увеличение значений означает более агрессивную оптимизацию, увеличивая время компиляции, вероятно, с немного лучшей производительностью. Значение по умолчанию — 100.

max-cselib-memory-locations

Максимальное количество ячеек памяти, которые cselib должен учитывать. Увеличение значений означает более агрессивную оптимизацию, увеличивая время компиляции, вероятно, с немного лучшей производительностью. Значение по умолчанию — 500.

reorder-blocks-duplicate

reorder-blocks-duplicate-feedback

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

Параметр reorder-block-duplicate-feedback используется только при наличии обратной связи от профиля. Его можно установить на более высокие значения, чем reorder-block-duplicate, так как информация о горячих точках более точная.

max-sched-ready-insns

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

max-sched-region-blocks

Максимальное количество блоков в области, которые необходимо учитывать для межблочного планирования. Значение по умолчанию — 10.

max-pipeline-region-blocks

Максимальное количество блоков в области, которые необходимо учитывать для конвейеризации в селективном планировщике. Значение по умолчанию — 15.

max-sched-region-insns

Максимальное число инструкций в области, которые необходимо учитывать для межблочного планирования. Значение по умолчанию — 100.

max-pipeline-region-insns

Максимальное количество инструкций в области, которые необходимо учитывать для конвейеризации в селективном планировщике. Значение по умолчанию — 200.

min-spec-prob

Минимальная вероятность (в процентах) достижения исходного блока для межблочного упреждающего планирования. Значение по умолчанию — 40.

max-sched-extend-regions-iters

Максимальное число итераций через CFG для расширения областей. Значение 0 (значение по умолчанию) отключает расширения областей.

max-sched-insn-conflict-delay

Максимальная задержка конфликта для инструкции, которая должна рассматриваться для упреждающего перемещения. Значение по умолчанию — 3.

sched-spec-prob-cutoff

Минимальная вероятность успешной упреждающей обработки (в процентах), при которой упреждающие инструкции планируются. Значение по умолчанию — 40.

sched-spec-state-edge-prob-cutoff

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

sched-mem-true-dep-cost

Минимальное расстояние (в циклах ЦП) между сохранением и загрузкой, которые нацелены на те же места в памяти. Значение по умолчанию — 1.

selsched-max-lookahead

Максимальный размер окна предвидения селективного планирования. Это глубина поиска доступных инструкций. Значение по умолчанию — 50.

selsched-max-sched-times

Максимальное количество раз, когда инструкция планируется во время селективного планирования. Это предел количества итераций, через которые инструкция может быть передана в конвейер. Значение по умолчанию — 2.
selsched-max-insns-to-rename: Максимальное количество лучших инструкций в списке готовности, которые рассматриваются для переименования в селективном планировщике. Значение по умолчанию — 2.
sms-min-sc: Минимальное значение количества стадий, которое планировщик swing modulo генерирует. Значение по умолчанию — 2.
max-last-value-rtl: Максимальный размер, измеряемый как количество RTL, которые могут быть записаны в выражении в комбинирующем блоке для псевдорегистра в качестве последнего известного значения этого регистра. Значение по умолчанию — 10000.
max-combine-insns: Максимальное количество инструкций, которые RTL-комбинер пытается объединить. Значение по умолчанию — 2 при -Og и 4 в остальных случаях.
integer-share-limit: Маленькие целочисленные константы могут использовать общую структуру данных, уменьшая использование памяти компилятором и увеличивая его скорость. Это устанавливает максимальное значение общей целочисленной константы. Значение по умолчанию — 256.
ssp-buffer-size: Минимальный размер буферов (т. е. массивов), которые получают защиту от переполнения стека при использовании -fstack-protection.
min-size-for-stack-sharing: Минимальный размер переменных, участвующих в совместном использовании слотов стека при отсутствии оптимизации. Значение по умолчанию — 32.
max-jump-thread-duplication-stmts: Максимальное количество операторов, разрешенных в блоке, который нужно дублировать при потоковой передаче прыжков.
max-fields-for-field-sensitive: Максимальное количество полей в структуре, обрабатываемых с учетом чувствительности к полям при анализе указателей. Значение по умолчанию — ноль для -O0 и -O1, и 100 для -Os, -O2 и -O3.
prefetch-latency: Оценки среднего количества инструкций, которые выполняются до завершения предварительной выборки. Расстояние, предварительно взятое вперёд, пропорционально этой константе. Увеличение этого числа может также привести к меньшему числу потоков, которые предварительно загружаются (см. simultaneous-prefetches).
simultaneous-prefetches: Максимальное количество предварительных выборок, которые могут выполняться одновременно.
l1-cache-line-size: Размер строки кэша в кэше L1 в байтах.
l1-cache-size: Размер кэша L1 в килобайтах.
l2-cache-size: Размер кэша L2 в килобайтах.
min-insn-to-prefetch-ratio: Минимальное соотношение между количеством инструкций и количеством предварительных выборок для включения предварительной выборки в цикле.
prefetch-min-insn-to-mem-ratio: Минимальное соотношение между количеством инструкций и количеством обращений к памяти для включения предварительной выборки в цикле.
use-canonical-types: Следует ли компилятору использовать «каноническую» систему типов. По умолчанию это всегда должно быть 1, что использует более эффективную внутреннюю механику для сравнения типов в C++ и Objective-C++. Однако, если ошибки в канонической системе типов вызывают сбои компиляции, установите это значение в 0, чтобы отключить канонические типы.
switch-conversion-max-branch-ratio: Переключение инициализации преобразования отказывается создавать массивы, которые больше, чем switch-conversion-max-branch-ratio умножить на количество ветвей в переключении.
max-partial-antic-length: Максимальная длина частичного антимножества, вычисленного во время оптимизации частичной избыточности дерева (-ftree-pre) при оптимизации на -O3 и выше. Для некоторых типов исходного кода оптимизация расширенной частичной избыточности может работать бесконечно, потребляя всю доступную память на хост-машине. Этот параметр устанавливает ограничение на длину вычисляемых множеств, что предотвращает неконтролируемое поведение. Установка значения 0 для этого параметра позволяет неограниченной длине множеств.
sccvn-max-scc-size: Максимальный размер сильно связной компоненты (SCC) во время обработки SCCVN. Если этот предел достигнут, обработка SCCVN для всей функции не выполняется, и оптимизации, зависящие от нее, отключаются. По умолчанию максимальный размер SCC составляет 10000.
sccvn-max-alias-queries-per-access: Максимальное количество запросов алиаса-оркула, которые мы выполняем при поиске избыточности для загрузки и сохранения. Если этот предел достигнут, поиск прерывается, и загрузка или сохранение не рассматриваются как избыточные. Количество запросов алгоритмически ограничено количеством сохранений на всех путях от загрузки до входа в функцию. По умолчанию максимальное количество запросов составляет 1000.
ira-max-loops-num: IRA по умолчанию использует региональное распределение регистров. Если функция содержит больше циклов, чем указанное число, только максимальное количество заданного числа наиболее часто выполняемых циклов образуют области для регионального распределения регистров. Значение параметра по умолчанию — 100.
ira-max-conflict-table-size: Хотя IRA использует сложный алгоритм для сжатия таблицы конфликтов, таблица все еще может требовать чрезмерного количества памяти для огромных функций. Если таблица конфликтов для функции может быть больше, чем размер в МБ, заданный этим параметром, распределитель регистров вместо этого использует более быстрый, более простой и менее качественный алгоритм, который не требует построения псевдорегистровой таблицы конфликтов. Значение параметра по умолчанию — 2000.
ira-loop-reserved-regs: IRA может быть использован для оценки более точного давления на регистры в циклах для принятия решений о перемещении инвариантов цикла (см. -O3). Количество доступных регистров, зарезервированных для некоторых других целей, задается этим параметром. Значение параметра по умолчанию — 2, что является минимальным количеством регистров, необходимых типичным инструкциям. Это значение является лучшим из многочисленных экспериментов.
lra-inheritance-ebb-probability-cutoff: LRA пытается повторно использовать значения, перезагруженные в регистрах в последующих инструкциях. Эта оптимизация называется наследованием. EBB используется в качестве области для выполнения этой оптимизации. Параметр определяет минимальную вероятность перехода без ветвления в процентах, используемую для добавления BB к наследуемой EBB в LRA. Значение параметра по умолчанию — 40. Это значение было выбрано по результатам многочисленных запусков SPEC2000 на x86-64.
loop-invariant-max-bbs-in-loop: Перемещение инварианта цикла может быть очень дорогостоящим, как во времени компиляции, так и в количестве требуемой памяти во время компиляции, при очень больших циклах. Циклы с большим количеством базовых блоков, чем этот параметр, не будут проходить оптимизацию перемещения инварианта цикла. Значение параметра по умолчанию — 1000 для -O1 и 10000 для -O2 и выше.
loop-max-datarefs-for-datadeps: Построение зависимостей данных дорогостоящее для очень больших циклов. Этот параметр ограничивает количество ссылок на данные в циклах, которые рассматриваются для анализа зависимостей данных. Эти большие циклы не обрабатываются оптимизациями, использующими зависимости данных в циклах. Значение по умолчанию — 1000.
max-vartrack-size: Устанавливает максимальное количество слотов таблицы хэширования для использования во время анализа потока данных отслеживания переменных для любой функции. Если этот предел превышен при включенном отслеживании переменных в операциях присваивания, анализ для этой функции повторяется без него, после удаления всех инструкций отладки из функции. Если предел превышен даже без инструкций отладки, анализ отслеживания переменных полностью отключается для функции. Установка параметра в ноль делает его неограниченным.
max-vartrack-expr-depth: Устанавливает максимальное количество уровней рекурсии при попытке сопоставить имена переменных или временные отладки с выражениями значений. Это обменивает время компиляции на более полную информацию об отладке. Если это значение слишком мало, выражения значений, которые доступны и могут быть представлены в отладочной информации, могут в итоге не использоваться; установка этого значения выше может позволить компилятору находить более сложные выражения отладки, но время компиляции и использование памяти могут увеличиться. Значение по умолчанию — 12.
min-nondebug-insn-uid: Использовать идентификаторы, начиная с этого параметра, для инструкций без отладки. Диапазон ниже параметра зарезервирован исключительно для инструкций отладки, созданных -fvar-tracking-assignments, но инструкции отладки могут получить (непересекающиеся) идентификаторы выше него, если зарезервированный диапазон исчерпан.
ipa-sra-ptr-growth-factor: IPA-SRA заменяет указатель на агрегат одним или несколькими новыми параметрами только тогда, когда их суммарный размер меньше или равен ipa-sra-ptr-growth-factor умножить на размер исходного параметра указателя.
sra-max-scalarization-size-Osize: Два прохода по скалярному сокращению агрегатов (SRA и IPA-SRA) стремятся заменить скалярные части агрегатов использованием независимых скалярных переменных. Эти параметры контролируют максимальный размер агрегата в единицах хранения, который рассматривается для замены при компиляции для скорости (sra-max-scalarization-size-Ospeed) или размера (sra-max-scalarization-size-Osize) соответственно.
tm-max-aggregate-size: При создании копий переменных, локальных для потока, в транзакции этот параметр указывает размер в байтах, после которого переменные сохраняются с функциями ведения журнала вместо пар сохранения/восстановления кодов.
graphite-max-nb-scop-params: Чтобы избежать экспоненциальных эффектов в преобразованиях циклов Graphite, количество параметров в статической управляющей части (SCoP) ограничено. Значение по умолчанию — 10 параметров. Переменная, значение которой неизвестно во время компиляции и определена вне SCoP, является параметром SCoP.
graphite-max-bbs-per-function: Чтобы избежать экспоненциальных эффектов при обнаружении SCoP, размер функций, анализируемых Graphite, ограничен. Значение по умолчанию — 100 базовых блоков.
loop-block-tile-size: Преобразования блокирования циклов или strip mining, включенные с -floop-block или -floop-strip-mine, strip mining каждый цикл в цикле вложенности на заданное количество итераций. Длина полосы может быть изменена с помощью параметра loop-block-tile-size. Значение по умолчанию — 51 итерация.
loop-unroll-jam-size: Укажите коэффициент размотки для параметра -floop-unroll-and-jam. Значение по умолчанию — 4.
loop-unroll-jam-depth: Укажите размерность для размотки (считая с самого внутреннего цикла) для -floop-unroll-and-jam. Значение по умолчанию — 2.
ipa-cp-value-list-size: IPA-CP пытается отслеживать все возможные значения и типы, передаваемые параметру функции, чтобы распространять их и выполнять девиртуализацию. ipa-cp-value-list-size — максимальное количество значений и типов, которые он хранит на один формальный параметр функции.
ipa-cp-eval-threshold: IPA-CP рассчитывает свой собственный балл клонирования по эвристике рентабельности и выполняет те возможности клонирования с баллами, которые превышают ipa-cp-eval-threshold.
ipa-cp-recursion-penalty: Процент штрафа, который получат рекурсивные функции при оценке на клонирование.
ipa-cp-single-call-penalty: Процент штрафа, который получат функции, содержащие единственный вызов другой функции, при оценке на клонирование.
ipa-max-agg-items

IPA-CP также может распространять ряд скалярных значений, переданных в агрегате. ipa-max-agg-items управляет максимальным количеством таких значений на один параметр.

ipa-cp-loop-hint-bonus

Когда IPA-CP определяет, что кандидат на клонирование сделает известным количество итераций цикла, он добавляет бонус ipa-cp-loop-hint-bonus к баллу рентабельности кандидата.

ipa-cp-array-index-hint-bonus

Когда IPA-CP определяет, что кандидат на клонирование сделает известным индекс доступа к массиву, он добавляет бонус ipa-cp-array-index-hint-bonus к баллу рентабельности кандидата.

ipa-max-aa-steps

При анализе тел функций IPA-CP использует анализ алиасов для отслеживания значений, на которые указывают параметры функций. Чтобы не тратить слишком много времени на анализ больших функций, он отказывается и считает всю память затертой после проверки ipa-max-aa-steps инструкций, изменяющих память.

lto-partitions

Укажите желаемое количество партиций, созданных во время компиляции WHOPR. Количество партиций должно превышать количество процессоров, используемых для компиляции. Значение по умолчанию — 32.

lto-minpartition

Размер минимальной партиции для WHOPR (в оценочных инструкциях). Это предотвращает затраты на разделение очень маленьких программ на слишком много партиций.

cxx-max-namespaces-for-diagnostic-help

Максимальное количество пространств имен для консультации по предложениям, когда поиск имени в C++ для идентификатора завершается неудачно. Значение по умолчанию — 1000.

sink-frequency-threshold

Максимальная относительная частота выполнения (в процентах) целевого блока относительно исходного блока инструкции для разрешения опускания инструкции. Более высокие значения приводят к более агрессивному опусканию инструкций. Значение по умолчанию — 75. Небольшая положительная корректировка применяется для инструкций с операциями памяти, поскольку они ещё более рентабельны для опускания.

max-stores-to-sink

Максимальное количество пар условных записей, которые могут быть опущены. Установлено в 0, если отключена либо векторизация (-ftree-vectorize), либо преобразование if (-ftree-loop-if-convert). Значение по умолчанию — 2.

allow-store-data-races

Разрешить оптимизаторам вводить новые данные о гонках при записи. Установить в 1 для разрешения, в противном случае в 0. Этот параметр включён по умолчанию при уровне оптимизации -Ofast.

case-values-threshold

Наименьшее количество различных значений, для которых лучше использовать таблицу переходов, а не дерево условных ветвлений. Если значение равно 0, используется значение по умолчанию для машины. Значение по умолчанию — 0.

tree-reassoc-width

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

sched-pressure-algorithm

Выберите между двумя доступными реализациями -fsched-pressure. Алгоритм 1 — оригинальная реализация и скорее всего предотвратит переупорядочение инструкций. Алгоритм 2 был разработан как компромисс между относительно консервативным подходом, принятым алгоритмом 1, и довольно агрессивным подходом, принятым по умолчанию планировщиком. Он в большей степени полагается на наличие обычного файла регистров и точных классов давления на регистры. Подробнее см. haifa-sched.c в исходных кодах GCC.

Выбор по умолчанию зависит от целевой платформы.

max-slsr-cand-scan

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

asan-globals

Включить обнаружение переполнения буфера для глобальных объектов. Этот вид защиты включён по умолчанию, если вы используете параметр -fsanitize=address. Чтобы отключить защиту глобальных объектов, используйте --param asan-globals=0.

asan-stack

Включить обнаружение переполнения буфера для стековых объектов. Этот вид защиты включён по умолчанию при использовании -fsanitize=address. Чтобы отключить защиту стека, используйте параметр --param asan-stack=0.

asan-instrument-reads

Включить обнаружение переполнения буфера для чтений памяти. Этот вид защиты включён по умолчанию при использовании -fsanitize=address. Чтобы отключить защиту чтений памяти, используйте --param asan-instrument-reads=0.

asan-instrument-writes

Включить обнаружение переполнения буфера для записей в память. Этот вид защиты включён по умолчанию при использовании -fsanitize=address. Чтобы отключить защиту записей в память, используйте параметр --param asan-instrument-writes=0.

asan-memintrin

Включить обнаружение для встроенных функций. Этот вид защиты включён по умолчанию при использовании -fsanitize=address. Чтобы отключить защиту встроенных функций, используйте --param asan-memintrin=0.

asan-use-after-return

Включить обнаружение использования после возврата. Этот вид защиты включен по умолчанию при использовании параметра -fsanitize=address. Чтобы отключить обнаружение использования после возврата, используйте --param asan-use-after-return=0.

asan-instrumentation-with-call-threshold

Если количество обращений к памяти в инструментируемой функции больше или равно этому числу, используйте обратные вызовы вместо встроенных проверок. Например, чтобы отключить встроенный код, используйте --param asan-instrumentation-with-call-threshold=0.

chkp-max-ctor-size

Статические конструкторы, сгенерированные Пограничным контролем указателей, могут стать очень большими и значительно увеличить время компиляции на уровнях оптимизации -O1 и выше. Этот параметр — максимальное количество инструкций в одном сгенерированном конструкторе. Значение по умолчанию — 5000.

max-fsm-thread-path-insns

Максимальное количество инструкций для копирования при дублировании блоков на пути потока перехода автомата конечного состояния. Значение по умолчанию — 100.

max-fsm-thread-length

Максимальное количество основных блоков на пути потока перехода автомата конечного состояния. Значение по умолчанию — 10.

max-fsm-thread-paths

Максимальное количество новых путей потоков перехода для создания автомата конечного состояния. Значение по умолчанию — 50.

Следующая: Параметры препроцессора, Предыдущая: Параметры отладки, Вернуться: Вызов GCC [Оглавление][Индекс]

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