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

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

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

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

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

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

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

В зависимости от целевой платформы и того, как был сконфигурирован 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-conversion
-fif-conversion2
-finline-functions-called-once
-fipa-modref
-fipa-profile
-fipa-pure-const
-fipa-reference
-fipa-reference-addressable
-fmerge-constants
-fmove-loop-invariants
-fmove-loop-stores
-fomit-frame-pointer
-freorder-blocks
-fshrink-wrap
-fshrink-wrap-separate
-fsplit-wide-types
-fssa-backprop
-fssa-phiopt
-ftree-bit-ccp
-ftree-ccp
-ftree-ch
-ftree-coalesce-vars
-ftree-copy-prop
-ftree-dce
-ftree-dominator-opts
-ftree-dse
-ftree-forwprop
-ftree-fre
-ftree-phiprop
-ftree-pta
-ftree-scev-cprop
-ftree-sink
-ftree-slsr
-ftree-sra
-ftree-ter
-funit-at-a-time

-O2

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

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

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

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

-O3

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

-fgcse-after-reload
-fipa-cp-clone
-floop-interchange
-floop-unroll-and-jam
-fpeel-loops
-fpredictive-commoning
-fsplit-loops
-fsplit-paths
-ftree-loop-distribution
-ftree-partial-pre
-funswitch-loops
-fvect-cost-model=dynamic
-fversion-loops-for-strides

-O0

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

-Os

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

-falign-functions  -falign-jumps
-falign-labels  -falign-loops
-fprefetch-loop-arrays  -freorder-blocks-algorithm=stc

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

-Ofast

Игнорирование строгого соблюдения стандартов. -Ofast включает все оптимизации -O3. Он также включает оптимизации, которые не являются допустимыми для всех программ, соответствующих стандартам. Он включает -ffast-math, -fallow-store-data-races и специфичную для Fortran -fstack-arrays, если не указан -fmax-stack-var-size, и -fno-protect-parens. Он отключает -fsemantic-interposition.

-Og

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

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

-fbranch-count-reg  -fdelayed-branch
-fdse  -fif-conversion  -fif-conversion2
-finline-functions-called-once
-fmove-loop-invariants  -fmove-loop-stores  -fssa-phiopt
-ftree-bit-ccp  -ftree-dse  -ftree-pta  -ftree-sra

-Oz

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

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

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

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

END_OF_DOCUMENT_MARKER

-fno-defer-pop

Для машин, которые должны извлекать аргументы после вызова функции, всегда извлекайте аргументы сразу после каждого возврата функции. На уровнях -O1 и выше, -fdefer-pop используется по умолчанию; это позволяет компилятору позволить аргументам накапливаться в стеке для нескольких вызовов функций и извлечь их все сразу.

-fforward-propagate

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

Этот параметр включен по умолчанию на уровнях оптимизации -O1, -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

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

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

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

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

-foptimize-sibling-calls

Оптимизировать вызовы функции с одинаковыми именами (последовательные и хвостовые рекурсивные вызовы).

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

-foptimize-strlen

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

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

-fno-inline

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

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

-finline-small-functions

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

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

-findirect-inlining

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

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

-finline-functions

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

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

Включено на уровнях -O2, -O3, -Os. Также включено опциями -fprofile-use и -fauto-profile.

-finline-functions-called-once

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

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

-fearly-inlining

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

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

-fipa-sra

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

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

-finline-limit=n

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

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

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

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

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

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

-fno-keep-inline-dllexport

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

-fkeep-inline-functions

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

-fkeep-static-functions

Выводить static функции в объектный файл, даже если функция никогда не используется.

-fkeep-static-consts

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

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

-fmerge-constants

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

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

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

-fmerge-all-constants

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

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

-fmodulo-sched

Выполнить планирование с модульной арифметикой (swing modulo scheduling) непосредственно перед первым проходом планирования. Этот проход рассматривает вложенные циклы и переупорядочивает инструкции, перекрывая разные итерации.

-fmodulo-sched-allow-regmoves

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

-fno-branch-count-reg

Отключить проход оптимизации, который ищет возможности использования инструкций «декремент и переход» по регистру счётчика вместо последовательностей инструкций, которые декрементируют регистр, сравнивают его с нулём, а затем осуществляют переход в зависимости от результата. Этот параметр имеет смысл только на архитектурах, которые поддерживают такие инструкции, включая x86, PowerPC, IA-64 и S/390. Обратите внимание, что опция -fno-branch-count-reg не удаляет инструкции декремента и перехода из генерируемого потока инструкций, введённые другими проходами оптимизации.

По умолчанию включено -fbranch-count-reg на -O1 и выше, за исключением -Og.

-fno-function-cse

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

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

По умолчанию используется -ffunction-cse

-fno-zero-initialized-in-bss

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

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

По умолчанию используется -fzero-initialized-in-bss.

-fthread-jumps

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

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

-fsplit-wide-types

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

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

-fsplit-wide-types-early

Полностью разделить широкие типы рано, а не очень поздно. Этот параметр не имеет эффекта, если -fsplit-wide-types не включён.

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

-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 включён, после загрузки выполняется проход по устранению избыточных загрузок. Цель этого прохода — очистить избыточные выталкивания.

Включено с -O3, -fprofile-use и -fauto-profile.

-faggressive-loop-optimizations

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

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

-funconstrained-commons

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

-fcrossjumping

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

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

-fauto-inc-dec

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

-fdce

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

-fdse

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

-fif-conversion

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

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

-fif-conversion2

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

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

-fdeclone-ctor-dtor

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

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

-fdelete-null-pointer-checks

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

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

Этот параметр включён по умолчанию на большинстве целевых платформ. В Nios II ELF он по умолчанию выключен. В AVR и MSP430 этот параметр полностью отключён.

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

-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++ значение объекта изменяется только в результате изменений в течение его жизненного цикла: когда начинается конструктор, объект имеет неопределённое значение, а любые изменения в течение жизненного цикла объекта игнорируются при его уничтожении. Обычно устранение мёртвых записей (dead store elimination) использует это; если ваш код полагается на сохранение значения хранилища объекта за пределами жизненного цикла объекта, вы можете использовать этот флаг для отключения этой оптимизации. Чтобы сохранить записи до начала конструктора (например, потому что ваш оператор new очищает хранилище объекта), но при этом рассматривать объект как мёртвый после деструктора, можно использовать -flifetime-dse=1. По умолчанию поведение можно явно выбрать с помощью -flifetime-dse=2. -flifetime-dse=0 эквивалентно -fno-lifetime-dse.

-flive-range-shrinkage

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

-fira-algorithm=algorithm

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

-fira-region=region

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

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

-fira-hoist-pressure

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

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

-fira-loop-pressure

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

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

-fno-ira-share-save-slots

Отключение совместного использования слотов стека, используемых для сохранения регистров, используемых в вызове (call-used hard registers), которые живут через вызов. Каждый регистр получает отдельный слот стека, в результате чего фреймы стека функций увеличиваются.

-fno-ira-share-spill-slots

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

-flra-remat

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

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

-fdelayed-branch

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

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

-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

Включить эвристику dependent-count в планировщике. Эта эвристика отдает предпочтение инструкции, от которой зависит больше инструкций. Она включена по умолчанию при включенном планировании, т.е. с -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 (где интерпозиция никогда не может изменить семантику), и для символов, явно объявленных слабыми.

-fshrink-wrap

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

-fshrink-wrap-separate

Сжимать отдельные части пролога и эпилога по отдельности, так что эти части выполняются только при необходимости. Этот параметр включен по умолчанию, но не имеет эффекта, если не включен также -fshrink-wrap, и целевая архитектура поддерживает это.

-fcaller-saves

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

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

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

-fcombine-stack-adjustments

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

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

-fipa-ra

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

Включен на уровнях -O2, -O3, -Os, однако параметр отключен, если сгенерированный код будет инструментирован для профилирования (-p или -pg) или если использование регистров вызываемой функцией нельзя узнать точно (это происходит на целевых архитектурах, которые не экспонируют прологи и эпилоги в RTL).

-fconserve-stack

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

-ftree-reassoc

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

-fcode-hoisting

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

-ftree-pre

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

-ftree-partial-pre

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

-ftree-forwprop

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

-ftree-fre

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

-ftree-phiprop

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

-fhoist-adjacent-loads

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

-ftree-copy-prop

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

-fipa-pure-const

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

-fipa-reference

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

-fipa-reference-addressable

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

-fipa-stack-alignment

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

-fipa-pta

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

-fipa-profile

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

-fipa-modref

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

-fipa-cp

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

-fipa-cp-clone

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

-fipa-bit-cp

При включенном флаге выполняется межпроцедурное побитовое распространение констант. Этот флаг включен по умолчанию при -O2 и при -fprofile-use и -fauto-profile. Требуется, чтобы был включен -fipa-cp.

-fipa-vrp

При включенном флаге выполняется межпроцедурная передача диапазонов значений. Этот флаг включен по умолчанию при -O2. Требуется, чтобы был включен -fipa-cp.

-fipa-icf

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

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

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

-flive-patching=level

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

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

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

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

Аргумент level должен быть одним из следующих:

‘inline-clone’

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

-flive-patching=inline-clone отключает следующие флаги оптимизации:

-fwhole-program  -fipa-pta  -fipa-reference  -fipa-ra
-fipa-icf  -fipa-icf-functions  -fipa-icf-variables
-fipa-bit-cp  -fipa-vrp  -fipa-pure-const
-fipa-reference-addressable
-fipa-stack-alignment -fipa-modref

‘inline-only-static’

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

В дополнение ко всем флагам, которые отключает -flive-patching=inline-clone, -flive-patching=inline-only-static отключает следующие дополнительные флаги оптимизации:

-fipa-cp-clone  -fipa-sra  -fpartial-inlining  -fipa-cp

Когда -flive-patching указан без значения, значение по умолчанию — inline-clone.

Этот флаг отключён по умолчанию.

Обратите внимание, что -flive-patching не поддерживается с оптимизацией на этапе компоновки (-flto).

-fisolate-erroneous-paths-dereference

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

-fisolate-erroneous-paths-attribute

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

-ftree-sink

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

-ftree-bit-ccp

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

-ftree-ccp

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

-fssa-backprop

Распространение информации об использовании значения по цепочке определения, чтобы упростить определения. Например, этот этап удаляет операции со знаком, если знак значения никогда не имеет значения. Флаг включён по умолчанию в -O1 и выше.

-fssa-phiopt

Сопоставление шаблонов на узлах SSA PHI для оптимизации условного кода. Этот этап включён по умолчанию в -O1 и выше, за исключением -Og.

-ftree-switch-conversion

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

-ftree-tail-merge

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

-ftree-dce

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

-ftree-builtin-call-dce

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

-ffinite-loops

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

Этот параметр включён по умолчанию в -O2 для C++ со значением -std=c++11 или выше.

-ftree-dominator-opts

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

-ftree-dse

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

-ftree-ch

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

-ftree-loop-optimize

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

-ftree-loop-linear

-floop-strip-mine

-floop-block

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

-fgraphite-identity

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

-floop-nest-optimize

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

-floop-parallelize-all

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

-ftree-coalesce-vars

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

-ftree-loop-if-convert

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

-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

Этот флаг включён по умолчанию в -O3. Он также включён в -fprofile-use и -fauto-profile.

-ftree-loop-distribute-patterns

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

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

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 нулём. Этот флаг включён по умолчанию при -O3. Он также включён при -fprofile-use и -fauto-profile.

-floop-interchange

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

for (int i = 0; i < N; i++)
  for (int j = 0; j < N; j++)
    for (int k = 0; k < N; k++)
      c[i][j] = c[i][j] + a[i][k]*b[k][j];

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

for (int i = 0; i < N; i++)
  for (int k = 0; k < N; k++)
    for (int j = 0; j < N; j++)
      c[i][j] = c[i][j] + a[i][k]*b[k][j];

Этот флаг включён по умолчанию при -O3. Он также включён при -fprofile-use и -fauto-profile.

-floop-unroll-and-jam

Применить преобразования развёртывания и склеивания (unroll and jam) к подходящим циклам. В цикле вложенности этот флаг разворачивает внешний цикл на некоторый множитель и объединяет полученные несколько внутренних циклов. Этот флаг включён по умолчанию при -O3. Он также включён при -fprofile-use и -fauto-profile.

-ftree-loop-im

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

-ftree-loop-ivcanon

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

-ftree-scev-cprop

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

-fivopts

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

-ftree-parallelize-loops=n

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

-ftree-pta

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

-ftree-sra

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

-fstore-merging

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

-ftree-ter

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

-ftree-slsr

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

-ftree-vectorize

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

-ftree-loop-vectorize

Выполнить векторизацию циклов по деревьям. Этот флаг включён по умолчанию при -O2 и -ftree-vectorize, -fprofile-use и -fauto-profile.

-ftree-slp-vectorize

Выполнить векторизацию базовых блоков по деревьям. Этот флаг включён по умолчанию при -O2 и -ftree-vectorize, -fprofile-use и -fauto-profile.

-ftrivial-auto-var-init=choice

Инициализировать автоматические переменные либо шаблоном, либо нулями, чтобы повысить безопасность и предсказуемость программы, предотвратив раскрытие и использование неинициализированной памяти. GCC по-прежнему считает автоматическую переменную неинициализированной, если у неё нет явной инициализации, -Wuninitialized и -Wanalyzer-use-of-uninitialized-value по-прежнему будут сообщать об ошибках для таких автоматических переменных, и компилятор будет выполнять оптимизацию так, как будто переменная неинициализирована. С этим параметром GCC также инициализирует любые заполнители автоматических переменных, имеющих типы структур или объединений, нулями. Однако текущая реализация не может инициализировать автоматические переменные, объявленные между управляющим выражением и первым case оператора switch. Используйте -Wtrivial-auto-var-init для отчёта обо всех таких случаях.

Три значения choice:

‘uninitialized’ не инициализирует автоматические переменные. Это по умолчанию для C и C++.
‘pattern’ Инициализировать автоматические переменные значениями, которые, вероятно, превратят логические ошибки в ошибки выполнения, легко распознаются в дампе ошибки и не являются значениями, на которые программисты могут полагаться для полезной семантики программы. Текущее значение — шаблон повторяемый по байтам с байтом "0xFE". Значения, используемые для инициализации шаблонов, могут быть изменены в будущем.
‘zero’ Инициализировать автоматические переменные нулями.

По умолчанию — ‘uninitialized’.

Вы можете контролировать это поведение для конкретной переменной, используя атрибут переменной uninitialized (см. Указание атрибутов переменных).

-fvect-cost-model=model

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

Модель затрат по умолчанию зависит от других флагов оптимизации и равна ‘dynamic’ или ‘cheap’.

-fsimd-cost-model=model

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

-ftree-vrp

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

-fsplit-paths

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

-fsplit-ivs-in-unroller

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

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

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

-fvariable-expansion-in-unroller

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

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

-fpartial-inlining

Встраивание частей функций. Этот параметр оказывает влияние только в том случае, если само встраивание включено с помощью параметров -finline-functions или -finline-small-functions.

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

-fpredictive-commoning

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

Этот параметр включен на уровне -O3. Он также включен параметрами -fprofile-use и -fauto-profile.

-fprefetch-loop-arrays

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

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

Отключено на уровне -Os.

-fno-printf-return-value

Не заменяйте константы известным значением возвращаемого результата функций форматированного вывода, таких как sprintf, snprintf, vsprintf, и vsnprintf (но не printf из fprintf). Эта трансформация позволяет GCC оптимизировать или даже устранить ветвления на основе известного значения возвращаемого результата этих функций, вызываемых с аргументами, которые являются либо константами, либо значения которых известны в диапазоне, позволяющем определить точное значение возвращаемого результата. Например, когда -fprintf-return-value активен, и ветвление, и тело оператора if (но не вызов snprint) могут быть оптимизированы, когда i является 32-битным или меньшим целым числом, потому что значение возвращаемого результата гарантировано не больше 8.

char buf[9];
if (snprintf (buf, "%08x", i) >= sizeof buf)
  …

Параметр -fprintf-return-value полагается на другие оптимизации и даёт лучшие результаты с -O2 и выше. Он работает в паре с параметрами -Wformat-overflow и -Wformat-truncation. Параметр -fprintf-return-value включен по умолчанию.

-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 были легче понять.

Также можно указать ожидаемую вероятность выражения с помощью встроенной функции __builtin_expect_with_probability.

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

-freorder-blocks

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

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

-freorder-blocks-algorithm=algorithm

Использовать указанный алгоритм для переупорядочивания базовых блоков. Аргумент algorithm может быть ‘simple’, который не увеличивает размер кода (за исключением иногда из-за вторичных эффектов, таких как выравнивание), или ‘stc’, алгоритм «кеш трассы программного обеспечения», который пытается поместить весь часто выполняемый код вместе, минимизируя количество выполненных ветвлений, создавая дополнительные копии кода.

По умолчанию «simple» на уровнях -O1, -Os, и «stc» на уровнях -O2, -O3.

-freorder-blocks-and-partition

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

Эта оптимизация автоматически отключается в присутствии обработки исключений или таблиц развёртывания (на целях, использующих setjump/longjump или целевой схеме), для секций linkonce, для функций с атрибутом пользовательской секции и на любой архитектуре, которая не поддерживает именованные секции. При использовании -fsplit-stack этот параметр по умолчанию отключен (чтобы избежать ошибок линкера), но может быть включен явно (если используется рабочий линкер).

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

-freorder-functions

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

Этот параметр неэффективен, если вы не предоставите обратную связь о профилировании (см. -fprofile-arcs для получения подробной информации) или вручную не анимируете функции с помощью атрибутов hot или cold (см. Общие атрибуты функций).

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

-fstrict-aliasing

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

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

union a_union {
  int i;
  double d;
};

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

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

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.

-fipa-strict-aliasing

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

Параметр -fipa-strict-aliasing включён по умолчанию и эффективен только в сочетании с -fstrict-aliasing.

-falign-functions

-falign-functions=n

-falign-functions=n:m

-falign-functions=n:m:n2

-falign-functions=n:m:n2:m2

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

Если m не указан, он по умолчанию равен n.

Примеры: -falign-functions=32 выравнивает функции до ближайшей 32-байтовой границы, -falign-functions=24 выравнивает до ближайшей 32-байтовой границы только в том случае, если это можно сделать, пропустив 23 байта или меньше, -falign-functions=32:7 выравнивает до ближайшей 32-байтовой границы только в том случае, если это можно сделать, пропустив 6 байтов или меньше.

Вторая пара значений n2:m2 позволяет указать вторичное выравнивание: -falign-functions=64:7:32:3 выравнивает до ближайшей 64-байтовой границы, если это можно сделать, пропустив 6 байтов или меньше, в противном случае выравнивает до ближайшей 32-байтовой границы, если это можно сделать, пропустив 2 байта или меньше. Если m2 не указан, он по умолчанию равен n2.

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

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

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

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

-flimit-function-alignment

Если этот параметр включен, компилятор пытается избежать ненужного избыточного выравнивания функций. Он пытается указать ассемблеру выравнивать на величину, указанную параметром -falign-functions, но не пропускать больше байтов, чем размер функции.

-falign-labels

-falign-labels=n

-falign-labels=n:m

-falign-labels=n:m:n2

-falign-labels=n:m:n2:m2

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

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

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

Если n не указан или равен нулю, используется зависящая от машины по умолчанию, которая, скорее всего, будет ‘1’, означающая отсутствие выравнивания. Максимальное разрешённое значение параметра n — 65536.

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

-falign-loops

-falign-loops=n

-falign-loops=n:m

-falign-loops=n:m:n2

-falign-loops=n:m:n2:m2

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

Если -falign-labels больше этого значения, используется его значение.

Параметры этого параметра аналогичны параметру -falign-functions. -fno-align-loops и -falign-loops=1 эквивалентны и означают, что циклы не выравниваются. Максимальное разрешённое значение параметра n — 65536.

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

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

-falign-jumps

-falign-jumps=n

-falign-jumps=n:m

-falign-jumps=n:m:n2

-falign-jumps=n:m:n2:m2

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

Если -falign-labels больше этого значения, используется его значение.

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

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

-fno-allocation-dce

Не удалять неиспользуемые C++ выделения в оптимизации удаления неиспользуемого кода.

-fallow-store-data-races

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

Примеры оптимизаций, включённых параметром -fallow-store-data-races, включают поднятие или преобразование операторов if, которые могут привести к тому, что значение, которое уже находится в памяти, будет перезаписано тем же самым значением. Такая перезапись безопасна в однопоточной среде, но может быть небезопасной в многопоточной среде. Обратите внимание, что на некоторых процессорах преобразования if могут потребоваться для включения векторизации.

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

-funit-at-a-time

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

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

-fno-toplevel-reorder

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

-ftoplevel-reorder является значением по умолчанию на -O1 и выше, а также на -O0, если -fsection-anchors явно запрошено. Кроме того, -fno-toplevel-reorder подразумевает -fno-section-anchors.

-funreachable-traps

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

Этот параметр имеет тот же эффект, что и -fsanitize=unreachable -fsanitize-trap=unreachable, но не влияет на значения этих параметров. Если -fsanitize=unreachable включено, этот параметр имеет меньший приоритет.

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

-fweb

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

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

-fwhole-program

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

С -flto этот параметр имеет ограниченное применение. В большинстве случаев точный список символов, используемых или экспортируемых из двоичного файла, известен, и информация о разрешении передаётся оптимизатору времени связывания через плагин компоновщика. Он по-прежнему полезен, если не используется плагин компоновщика или во время инкрементного этапа компоновки, когда генерируется окончательный код (с -flto -flinker-output=nolto-rel).

-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. Вы всегда можете переопределить автоматическое решение выполнить оптимизацию при компоновке, передав -fno-lto команде компоновки.

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

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

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

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

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

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

Следующие опции -fPIC, -fpic, -fpie и -fPIE комбинируются в соответствии со следующей схемой:

-fPIC + -fpic = -fpic
-fPIC + -fno-pic = -fno-pic
-fpic/-fPIC + (no option) = (no option)
-fPIC + -fPIE = -fPIE
-fpic + -fPIE = -fpie
-fPIC/-fpic + -fpie = -fpie

Некоторые флаги, изменяющие 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. Вы можете переопределить их при компоновке.

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

Когда вам нужно передать опции ассемблеру через -Wa или -Xassembler, убедитесь, что вы либо компилируете такие единицы перевода с -fno-lto, либо последовательно используете те же опции ассемблера во всех единицах перевода. Вы также можете указать опции ассемблера на этапе компоновки LTO.

Для включения генерации отладочной информации необходимо указать -g на этапе компиляции. Если любой из входных файлов на этапе компоновки был скомпилирован с включённой генерацией отладочной информации, компоновка также включит генерацию отладочной информации. Любые сложные настройки отладочной информации, такие как уровень DWARF -gdwarf-5, необходимо явно повторять в командной строке линковщика, и смешивание разных настроек в разных единицах перевода не рекомендуется.

Если 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.

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

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

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

Используйте -flto=auto, чтобы использовать сервер задач GNU make, если он доступен, или в противном случае использовать автоматическое обнаружение количества потоков процессора, присутствующих в вашей системе.

-flto-partition=alg

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

-flto-compression-level=n

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

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

Обратите внимание, что современные утилиты binutils предоставляют механизм автоматической загрузки плагинов. Установка плагина компоновщика в $libdir/bfd-plugins имеет тот же эффект, что и использование оболочек команд (gcc-ar, gcc-nm и gcc-ranlib).

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

-fcompare-elim

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

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

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

-fcprop-registers

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

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

-fprofile-correction

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

Эта опция включена с помощью -fauto-profile.

-fprofile-partial-training

С помощью -fprofile-use все части программ, не выполненные во время этапа обучения, оптимизируются агрессивно по размеру, а не по скорости. В некоторых случаях непрактично обучать все возможные горячие пути в программе. (Например, программа может содержать функции, специфичные для данного оборудования, и обучение может не охватить все конфигурации оборудования, на которых запускается программа). С помощью -fprofile-partial-training информация из профиля будет проигнорирована для всех функций, не выполненных во время этапа обучения, что приведет к их оптимизации так, как если бы они были скомпилированы без обратной связи из профиля. Это приводит к лучшей производительности, когда этап обучения не является представительным, но также приводит к значительно большему коду.

-fprofile-use

-fprofile-use=path

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

-fbranch-probabilities  -fprofile-values
-funroll-loops  -fpeel-loops  -ftracer  -fvpt
-finline-functions  -fipa-cp  -fipa-cp-clone  -fipa-bit-cp
-fpredictive-commoning  -fsplit-loops  -funswitch-loops
-fgcse-after-reload  -ftree-loop-vectorize  -ftree-slp-vectorize
-fvect-cost-model=dynamic  -ftree-loop-distribute-patterns
-fprofile-reorder-functions

Прежде чем использовать эту опцию, необходимо сгенерировать информацию о профилировании. См. Параметры инструментации программы для получения информации об опции -fprofile-generate.

По умолчанию GCC выводит сообщение об ошибке, если профили обратной связи не соответствуют исходному коду. Эту ошибку можно преобразовать в предупреждение с помощью -Wno-error=coverage-mismatch. Обратите внимание, что это может привести к плохо оптимизированному коду. Кроме того, по умолчанию GCC также выводит предупреждение, если профили обратной связи отсутствуют (см. -Wmissing-profile).

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

-fauto-profile

-fauto-profile=path

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

-fbranch-probabilities  -fprofile-values
-funroll-loops  -fpeel-loops  -ftracer  -fvpt
-finline-functions  -fipa-cp  -fipa-cp-clone  -fipa-bit-cp
-fpredictive-commoning  -fsplit-loops  -funswitch-loops
-fgcse-after-reload  -ftree-loop-vectorize  -ftree-slp-vectorize
-fvect-cost-model=dynamic  -ftree-loop-distribute-patterns
-fprofile-correction

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, и используются типы с плавающей запятой. По умолчанию используется -fexcess-precision=fast; это означает, что операции могут выполняться с большей точностью, чем указано в исходном коде, если это приведет к более быстрому коду, и неясно, когда происходит округление до типов, указанных в исходном коде. При компиляции C или C++, если указано -fexcess-precision=standard, то избыточная точность соответствует правилам, указанным в ISO C99 или C++; в частности, как приведения типов, так и присваивания приводят к округлению значений до соответствующих типов (в то время как -ffloat-store влияет только на присваивания). Этот параметр включен по умолчанию для C или C++ при использовании параметров строгого соответствия, таких как -std=c99 или -std=c++17. -ffast-math включает -fexcess-precision=fast по умолчанию независимо от того, используется ли параметр строгого соответствия.

-fexcess-precision=standard не реализован для языков, отличных от C или C++. На 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 и -fexcess-precision=fast.

Этот параметр определяет препроцессорную макрокоманду __FAST_MATH__.

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

-fno-math-errno

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

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

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

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

-funsafe-math-optimizations

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

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

Значение по умолчанию - -fno-unsafe-math-optimizations.

-fassociative-math

Разрешить повторную ассоциацию операндов в рядах операций с плавающей запятой. Это нарушает стандарт языка ISO C и C++, возможно изменяя результат вычисления. ПРИМЕЧАНИЕ: переупорядочение может изменить знак нуля, а также игнорировать NaN и предотвращать или создавать потерю или переполнение (и поэтому не может использоваться в коде, который полагается на поведение округления, например (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 или +-Inf.

Значение по умолчанию - -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.

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

-frounding-math

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

Значение по умолчанию - -fno-rounding-math.

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

-fsignaling-nans

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

Этот параметр определяет препроцессорную макрокоманду __SUPPORT_SNAN__.

Значение по умолчанию - -fno-signaling-nans.

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

-fno-fp-int-builtin-inexact

Не допускать, чтобы встроенные функции ceil, floor, round и trunc, а также их варианты float и long double, генерировали код, поднимающий исключение «неточно» для нецелочисленных аргументов. ISO C99 и C11 разрешают этим функциям поднимать исключение «неточно», но ISO/IEC TS 18661-1:2014, привязки C к IEEE 754-2008, как интегрированные в ISO C2X, не разрешают этим функциям это делать.

Значение по умолчанию - -ffp-int-builtin-inexact, что разрешает поднять исключение, если не выбран C2X или более поздний стандарт C. Этот параметр ничего не делает, если -ftrapping-math не включен.

Даже если используется -fno-fp-int-builtin-inexact, если функции генерируют вызов библиотечной функции, исключение «неточно» может быть поднято, если реализация библиотеки не следует TS 18661.

-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 (см. Параметры инструментации программы), можно повторно скомпилировать её с помощью -fbranch-probabilities, чтобы улучшить оптимизации, основанные на количестве прохождения каждого ветвления. При завершении программы, скомпилированной с -fprofile-arcs, она сохраняет счётчики выполнения дуг в файл, названный sourcename.gcda для каждого исходного файла. Информация в этом файле сильно зависит от структуры сгенерированного кода, поэтому для обеих компиляций необходимо использовать тот же исходный код и те же параметры оптимизации. Подробнее о наименовании файлов см. в -fprofile-arcs.

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

Включается с -fprofile-use и -fauto-profile.

-fprofile-values

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

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

Включается с -fprofile-generate, -fprofile-use и -fauto-profile.

-fprofile-reorder-functions

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

Включается с -fprofile-use.

-fvpt

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

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

Включается с -fprofile-use и -fauto-profile.

-frename-registers

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

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

-fschedule-fusion

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

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

-ftracer

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

Включается с -fprofile-use и -fauto-profile.

-funroll-loops

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

Включается с -fprofile-use и -fauto-profile.

-funroll-all-loops

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

-fpeel-loops

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

Включается с -O3, -fprofile-use и -fauto-profile.

-fmove-loop-invariants

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

-fmove-loop-stores

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

-fsplit-loops

Разделить цикл на два, если он содержит условие, которое всегда истинно для одной стороны области итераций и ложно для другой.

Включается с -fprofile-use и -fauto-profile.

-funswitch-loops

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

Включается с -fprofile-use и -fauto-profile.

-fversion-loops-for-strides

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

for (int i = 0; i < n; ++i)
  x[i * stride] = …;

становится:

if (stride == 1)
  for (int i = 0; i < n; ++i)
    x[i] = …;
else
  for (int i = 0; i < n; ++i)
    x[i * stride] = …;

Это особенно полезно для массивов с предполагаемой формой в Fortran, где (например) позволяет лучше векторизовать, предполагая непрерывные обращения. Этот флаг включен по умолчанию в -O3. Также включен с -fprofile-use и -fauto-profile.

-ffunction-sections

-fdata-sections

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

Используйте эти параметры на системах, где компоновщик может выполнять оптимизации для повышения локальности ссылок в адресном пространстве инструкций. Большинство систем, использующих формат ELF-объектов, имеют компоновщики с такими оптимизациями. На AIX компоновщик переупорядочивает секции (CSECT) на основе графа вызовов. Влияние на производительность различно.

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

На системах ELF/DWARF эти параметры не ухудшают качество отладочной информации. Могут возникнуть проблемы с другими форматами файлов/отладочной информации.

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

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

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

-fzero-call-used-regs=choice

Обнулить используемые в вызовах регистры при возвращении из функции, чтобы повысить безопасность программы, либо смягчая атаки Return-Oriented Programming (ROP), либо предотвращая утечку информации через регистры.

Возможные значения choice совпадают со значениями атрибута zero_call_used_regs (см. Объявление атрибутов функций). По умолчанию — ‘skip’.

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

--param name=value

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

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

Для получения минимальных, максимальных и стандартных значений параметра используйте параметры --help=param -Q.

В каждом случае value является целым числом. Для всех целевых платформ распознаются следующие варианты name:

END_OF_DOCUMENT_MARKER

predictable-branch-outcome

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

max-rtl-if-conversion-insns

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

max-rtl-if-conversion-predictable-cost

RTL преобразование условных операторов if будет пытаться удалить условные ветви вокруг блока и заменить их условно выполняемыми инструкциями. Эти параметры задают максимальную допустимую стоимость последовательности, которая будет сгенерирована преобразованием if, в зависимости от того, предсказуема ли ветвь статически или нет. Единицы для этого параметра такие же, как и для внутренней метрики GCC seq_cost. Компилятор постарается предоставить разумное значение по умолчанию для этого параметра, используя макрос BRANCH_COST целевой системы.

max-crossjump-edges

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

min-crossjump-insns

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

max-grow-copy-bb-insns

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

max-goto-duplication-insns

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

max-delay-slot-insn-search

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

max-delay-slot-live-search

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

max-gcse-memory

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

max-gcse-insertion-ratio

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

max-pending-list-length

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

max-modulo-backtrack-attempts

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

max-inline-functions-called-once-loop-depth

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

max-inline-functions-called-once-insns

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

max-inline-insns-single

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

max-inline-insns-auto

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

max-inline-insns-small

Это ограничение применяется к вызовам, которые считаются релевантными с -finline-small-functions.

max-inline-insns-size

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

uninlined-function-insns

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

uninlined-function-time

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

inline-heuristics-hint-percent

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

uninlined-thunk-insns

uninlined-thunk-time

То же, что --param uninlined-function-insns и --param uninlined-function-time, но применяется к функционным тхнкам.

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.

lazy-modules

Максимальное количество одновременно открытых файлов модулей C++ при леничной загрузке.

inline-unit-growth

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

ipa-cp-unit-growth

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

ipa-cp-large-unit-insns

Размер трансляционной единицы, который рассматривает проход IPA-CP как большой.

large-stack-frame

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

large-stack-frame-growth

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

max-inline-insns-recursive

max-inline-insns-recursive-auto

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

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

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.

min-inline-recursive-probability

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

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

early-inlining-insns

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

max-early-inliner-iterations

Предел итераций раннего инлайнера. Это в основном ограничивает количество вложенных косвенных вызовов, которые может разрешить ранний инлайнер. Более глубокие цепочки по-прежнему обрабатываются поздним инлайнингом.
comdat-sharing-probability: Вероятность (в процентах), что функция C++ inline с видимостью comdat будет совместно использоваться в нескольких единицах компиляции.
modref-max-bases
modref-max-refs
modref-max-accesses: Указывает максимальное количество базовых указателей, ссылок и обращений, хранящихся для одной функции анализом mod/ref.
modref-max-tests: Указывает максимальное количество тестов, которые может выполнить оракул алиасов, чтобы разобрать расположения памяти с использованием информации mod/ref. Этот параметр должен быть больше, чем --param modref-max-bases и --param modref-max-refs.
modref-max-depth: Указывает максимальную глубину обхода DFS, используемого анализом modref escape. Установка в 0 полностью отключает анализ.
modref-max-escape-points: Указывает максимальное количество точек выхода, отслеживаемых modref на один SSA-имя.
modref-max-adjustments: Указывает максимальное значение, на которое диапазон доступа увеличивается при анализе потоков данных modref.
profile-func-internal-id: Параметр, контролирующий использование внутреннего идентификатора функции в поиске по базе профилей. Если значение равно 0, компилятор использует идентификатор, основанный на имени сборщика функций и имени файла, что делает старые данные профиля более устойчивыми к изменениям исходного кода, таким как переупорядочивание функций и т. д.
min-vect-loop-bound: Минимальное количество итераций, при котором циклы не векторизуются при использовании -ftree-vectorize. Количество итераций после векторизации должно быть больше, чем указано в этом параметре, чтобы разрешить векторизацию.
gcse-cost-distance-ratio: Коэффициент масштабирования при расчете максимального расстояния, на которое выражение может быть перемещено оптимизациями GCSE. В настоящее время это поддерживается только в проходе перемещения кода. Чем больше коэффициент, тем более агрессивным является перемещение кода простых выражений, то есть выражений, стоимость которых меньше, чем gcse-unrestricted-cost. Указание 0 отключает перемещение простых выражений.
gcse-unrestricted-cost: Стоимость, приблизительно измеренная как стоимость одной типичной машинной инструкции, при которой оптимизации GCSE не ограничивают расстояние, которое может пройти выражение. В настоящее время это поддерживается только в проходе перемещения кода. Чем меньше стоимость, тем более агрессивным является перемещение кода. Указание 0 позволяет всем выражениям перемещаться на неограниченные расстояния.
max-hoist-depth: Глубина поиска в дереве доминаторов для подъема выражений. Это используется для избежания квадратичного поведения в алгоритме подъема. Значение 0 не ограничивает поиск, но может замедлить компиляцию очень больших функций.
max-tail-merge-comparisons: Максимальное количество похожих блоков базовых команд (bb), с которыми сравнивается bb. Это используется для предотвращения квадратичного поведения в слиянии хвостов деревьев.
max-tail-merge-iterations: Максимальное количество итераций прохода по функции. Это используется для ограничения времени компиляции при слиянии хвостов деревьев.
store-merging-allow-unaligned: Разрешить проходу слияния хранилищ вводить невыровненные хранилища, если это допустимо.
max-stores-to-merge: Максимальное количество хранилищ, которые необходимо попытаться объединить в более широкие хранилища в проходе слияния хранилищ.
max-store-chains-to-track: Максимальное количество цепочек хранилищ, которые необходимо отслеживать одновременно при попытке объединения в более широкие хранилища в проходе слияния хранилищ.
max-stores-to-track: Максимальное количество хранилищ, которые нужно отслеживать одновременно, чтобы попытаться объединить их в более широкие хранилища в проходе слияния хранилищ.
max-unrolled-insns: Максимальное количество инструкций, которые может иметь цикл для разворачивания. Если цикл развернут, этот параметр также определяет, сколько раз код цикла будет развернут.
max-average-unrolled-insns: Максимальное количество инструкций, взвешенных по вероятностям их выполнения, которые может иметь цикл для разворачивания. Если цикл развернут, этот параметр также определяет, сколько раз код цикла будет развернут.
max-unroll-times: Максимальное количество развёртываний одного цикла.
max-peeled-insns: Максимальное количество инструкций, которые может иметь цикл для обрезки. Если цикл обрезан, этот параметр также определяет, сколько раз код цикла будет обрезан.
max-peel-times: Максимальное количество обрезки одного цикла.
max-peel-branches: Максимальное количество ветвлений на горячем пути через обрезанную последовательность.
max-completely-peeled-insns: Максимальное количество insns полностью обрезанного цикла.
max-completely-peel-times: Максимальное количество итераций цикла, подходящего для полной обрезки.
max-completely-peel-loop-nest-depth: Максимальная глубина вложенности циклов, подходящая для полной обрезки.
max-unswitch-insns: Максимальное количество insns непереключенного цикла.
max-unswitch-depth: Максимальная глубина вложенности циклов для переключения.
lim-expensive: Минимальная стоимость дорогостоящего выражения в перемещении инварианты цикла.
min-loop-cond-split-prob: При наличии информации о профиле FDO, min-loop-cond-split-prob указывает минимальный порог вероятности для полуинвариантного условия, чтобы вызвать разделение цикла.
iv-consider-all-candidates-bound: Ограничение на количество кандидатов для индуктивных переменных, ниже которого все кандидаты рассматриваются для каждого использования в оптимизациях индуктивных переменных. Если кандидатов больше, чем это значение, учитываются только наиболее релевантные, чтобы избежать квадратичной временной сложности.
iv-max-considered-uses: Оптимизации индуктивных переменных отказываются от циклов, содержащих больше используемых индуктивных переменных.
iv-always-prune-cand-set-bound: Если количество кандидатов в наборе меньше этого значения, всегда пытайтесь удалить ненужные iv из набора при добавлении нового.
avg-loop-niter: Среднее число итераций цикла.
dse-max-object-size: Максимальный размер (в байтах) объектов, отслеживаемых байтово удалением мёртвых хранилищ. Более крупные значения могут привести к более длительному времени компиляции.
dse-max-alias-queries-per-store: Максимальное количество запросов к оракулу алиасов на хранение. Более высокие значения приводят к увеличению времени компиляции и могут привести к удалению большего количества мертвых хранилищ.
scev-max-expr-size: Ограничение на размер выражений, используемых в анализаторе скалярных эволюций. Большие выражения замедляют анализатор.
scev-max-expr-complexity: Ограничение на сложность выражений в анализаторе скалярных эволюций. Сложные выражения замедляют анализатор.
max-tree-if-conversion-phi-args: Максимальное количество аргументов в PHI, поддерживаемом TREE при преобразовании, если цикл не помечен псевдонимом simd.
vect-max-layout-candidates: Максимальное количество возможных схем размещения векторов (например, перестановок), которые необходимо рассмотреть при оптимизации кода, подлежащего векторизации.
vect-max-version-for-alignment-checks: Максимальное количество проверок во время выполнения, которые могут быть выполнены при выполнении версии циклов для выравнивания в векторизаторе.
vect-max-version-for-alias-checks: Максимальное количество проверок во время выполнения, которые могут быть выполнены при выполнении версии циклов для алиасов в векторизаторе.
vect-max-peeling-for-alignment: Максимальное количество обрезки циклов для повышения выравнивания доступа для векторизатора. Значение -1 означает отсутствие ограничения.
max-iterations-to-track: Максимальное количество итераций цикла, которое алгоритм грубой силы для анализа числа итераций цикла пытается оценить.
hot-bb-count-fraction: Знаменатель n дроби 1/n от максимального количества выполнений базового блока во всей программе, которое базовый блок должен иметь как минимум, чтобы считаться горячим. По умолчанию это 10000, что означает, что базовый блок считается горячим, если его количество выполнений больше, чем 1/10000 от максимального количества выполнений. 0 означает, что он никогда не считается горячим. Используется в режиме без LTO.
hot-bb-count-ws-permille: Количество наиболее часто выполняемых промилле, в диапазоне от 0 до 1000, профилированного выполнения всей программы, к которой должно относиться количество выполнений базового блока, чтобы считаться горячим. По умолчанию это 990, что означает, что базовый блок считается горячим, если его количество выполнений составляет более 990 промилле или 99,0% от профилированного выполнения всей программы. 0 означает, что он никогда не считается горячим. Используется в режиме LTO.
hot-bb-frequency-fraction: Знаменатель n дроби 1/n частоты выполнения входного блока функции, которую базовый блок этой функции должен иметь как минимум, чтобы считаться горячим. По умолчанию это 1000, что означает, что базовый блок считается горячим в функции, если он выполняется чаще, чем 1/1000 частоты входного блока функции. 0 означает, что он никогда не считается горячим.
unlikely-bb-count-fraction: Знаменатель n дроби 1/n количества профилированных запусков всей программы, ниже которого должно быть количество выполнений базового блока, чтобы базовый блок считался маловероятным для выполнения. По умолчанию это 20, что означает, что базовый блок считается маловероятным для выполнения, если он выполняется меньше, чем 1/20 или 5% от запусков программы. 0 означает, что он всегда считается маловероятным для выполнения.
max-predicted-iterations: Максимальное число итераций цикла, которое мы прогнозируем статически. Это полезно в тех случаях, когда функция содержит один цикл с известной границей и другой цикл с неизвестной границей. Известное число итераций прогнозируется правильно, а неизвестное число итераций усредняется примерно до 10. Это означает, что цикл без границ искусственно выглядит холодным по сравнению с другим.
builtin-expect-probability: Управление вероятностью того, что выражение имеет указанное значение. Этот параметр принимает процент (т. е. 0 ... 100) в качестве входных данных.
builtin-string-cmp-inline-length: Максимальная длина строковой константы для вызова встроенной строковой функции cmp, пригодной для инлайнинга.
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-probability

tracer-min-branch-probability-feedback

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

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

stack-clash-protection-guard-size

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

stack-clash-protection-probe-interval

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

max-cse-path-length

Максимальное количество базовых блоков на пути, которое учитывает CSE.

max-cse-insns

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

ggc-min-expand

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

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

ggc-min-heapsize

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

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

max-reload-search-insns

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

max-cselib-memory-locations

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

max-sched-ready-insns

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

max-sched-region-blocks

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

max-pipeline-region-blocks

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

max-sched-region-insns

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

max-pipeline-region-insns

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

min-spec-prob

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

max-sched-extend-regions-iters

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

max-sched-insn-conflict-delay

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

sched-spec-prob-cutoff

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

sched-state-edge-prob-cutoff

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

sched-mem-true-dep-cost

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

selsched-max-lookahead

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

selsched-max-sched-times

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

selsched-insns-to-rename

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

sms-min-sc

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

max-last-value-rtl

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

max-combine-insns

Максимальное количество инструкций, которые пытается объединить комбинирующее устройство RTL.

integer-share-limit

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

ssp-buffer-size

Минимальный размер буферов (т.е. массивов), которые получают защиту от разрушения стека, когда используется -fstack-protector.

min-size-for-stack-sharing

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

max-jump-thread-duplication-stmts

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

max-jump-thread-paths

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

max-fields-for-field-sensitive

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

prefetch-latency

Оценка среднего количества инструкций, выполняемых до завершения предварительной выборки. Расстояние, предварительно выбранное вперёд, пропорционально этой константе. Увеличение этого числа также может привести к тому, что будет выбрано меньше потоков (см. simultaneous-prefetches).

simultaneous-prefetches

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

l1-cache-line-size

Размер строки кеша в кэше данных L1, в байтах.

l1-cache-size

Размер кэша данных L1, в килобайтах.

l2-cache-size

Размер кэша данных L2, в килобайтах.

prefetch-dynamic-strides

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

Устанавливается в 1, если подсказки предварительной выборки должны выдаваться для не постоянных шагов. Устанавливается в 0, если подсказки предварительной выборки должны выдаваться только для шагов, которые известны как постоянные и меньше prefetch-minimum-stride.

prefetch-minimum-stride

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

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

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

Эта настройка полезна только для шагов, которые известны и постоянны.

destructive-interference-size

constructive-interference-size

Значения для переменных C++17 std::hardware_destructive_interference_size и std::hardware_constructive_interference_size. Размер деструктивного интерференции — минимальное рекомендуемое смещение между двумя независимыми одновременно используемыми объектами; размер конструктивной интерференции — максимальный рекомендуемый размер смежных областей памяти, которые используются вместе. Обычно оба размера будут размером строки кэша L1 для целевого устройства в байтах. Для универсальной цели, охватывающей диапазон размеров строк кэша L1, размер конструктивной интерференции обычно будет меньшим значением диапазона, а размер деструктивной — большим.

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

Размер конструктивной интерференции менее чувствителен, так как обычно используется только в ‘static_assert’ для проверки соответствия типа строке кэша.

См. также -Winterference-size.

loop-interchange-max-num-stmts

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

loop-interchange-stride-ratio

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

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

rpo-vn-max-loop-depth

Максимальная глубина цикла, которая оптимизируется по значениям. Когда ограничение достигает самых внутренних циклов rpo-vn-max-loop-depth, и самый внешний цикл в цикле вложен в оптимизацию по значениям, а остальные нет.

sccvn-max-alias-queries-per-access

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

ira-max-loops-num

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

ira-max-conflict-table-size

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

ira-loop-reserved-regs

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

ira-consider-dup-in-all-alts

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

ira-simple-lra-insn-threshold

Приблизительное количество инструкций в функции в единицах 1К, запускающих простую локальную аллокацию регистров.

lra-inheritance-ebb-probability-cutoff

LRA пытается повторно использовать значения, перезагруженные в регистры, в последующих инструкциях. Эта оптимизация называется наследованием. EBB используется как область для выполнения этой оптимизации. Параметр определяет минимальную вероятность перехода без ветвления в процентах, используемую для добавления BB к наследованию EBB в LRA. Значение по умолчанию выбрано на основе многочисленных запусков SPEC2000 на x86-64.

loop-invariant-max-bbs-in-loop

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

loop-max-datarefs-for-datadeps

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

max-vartrack-size

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

max-vartrack-expr-depth

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

max-debug-marker-count

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

min-nondebug-insn-uid

Использовать UID, начиная с этого параметра, для инструкций без отладки. Диапазон ниже параметра зарезервирован исключительно для инструкций отладки, созданных с помощью -fvar-tracking-assignments, но инструкции отладки могут получить (непересекающиеся) UID выше, если зарезервированный диапазон исчерпан.

ipa-sra-deref-prob-threshold

IPA-SRA заменяет указатель, который известен как не NULL, одним или несколькими новыми параметрами только тогда, когда вероятность (в процентах, относительно входа в функцию) его разыменования выше этого параметра.

ipa-sra-ptr-growth-factor

IPA-SRA заменяет указатель на агрегат одним или несколькими новыми параметрами только тогда, когда их суммарный размер меньше или равен ipa-sra-ptr-growth-factor умноженного на размер исходного параметра указателя.

ipa-sra-ptrwrap-growth-factor

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

ipa-sra-max-replacements

Максимальное количество фрагментов агрегата, которые отслеживает IPA-SRA. Вследствие этого, это также максимальное количество замен формального параметра.

sra-max-scalarization-size-Ospeed

sra-max-scalarization-size-Osize

Два прохода (SRA и IPA-SRA) по скалярному преобразованию агрегатов предназначены для замены скалярных частей агрегатов использованием независимых скалярных переменных. Эти параметры контролируют максимальный размер агрегата в единицах хранения, который рассматривается для замены при компиляции на скорость (sra-max-scalarization-size-Ospeed) или размер (sra-max-scalarization-size-Osize) соответственно.

sra-max-propagations

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

tm-max-aggregate-size

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

graphite-max-nb-scop-params

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

loop-block-tile-size

Преобразования блокирования циклов или разрезания циклов, включенные с -floop-block или -floop-strip-mine, разрезают каждый цикл в цикле вложенного цикла на заданное число итераций. Длина разрезки может быть изменена с помощью параметра loop-block-tile-size.

ipa-jump-function-lookups

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

ipa-cp-value-list-size

IPA-CP пытается отследить все возможные значения и типы, передаваемые параметру функции, чтобы распространить их и выполнить девиртуализацию. ipa-cp-value-list-size — максимальное количество значений и типов, которые он хранит для каждого формального параметра функции.

ipa-cp-eval-threshold

IPA-CP рассчитывает собственный рейтинг эвристик прибыльности клонирования и выполняет эти возможности клонирования с оценками, которые превышают ipa-cp-eval-threshold.

ipa-cp-max-recursive-depth

Максимальная глубина рекурсивного клонирования для саморекурсивной функции.

ipa-cp-min-recursive-probability

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

ipa-cp-profile-count-base

При использовании опции -fprofile-use IPA-CP будет рассматривать измеренное количество выполнений ребра графа вызовов в этой процентной позиции в их гистограмме как основу для вычисления своих эвристик.

ipa-cp-recursive-freq-factor

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

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-max-loop-predicates

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

ipa-max-aa-steps

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

ipa-max-switch-predicate-bounds

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

ipa-max-param-expr-ops

IPA-CP будет анализировать условные операторы, которые ссылаются на некоторые параметры функции, чтобы оценить выгоду от клонирования при определенном постоянном значении. Но если количество операций в выражении параметра превышает ipa-max-param-expr-ops, выражение считается сложным и не обрабатывается анализом IPA.

lto-partitions

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

lto-min-partition

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

lto-max-partition

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

lto-max-streaming-parallelism

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

cxx-max-namespaces-for-diagnostic-help

Максимальное количество пространств имен для консультации по предложениям при неудачном поиске имени идентификатора C++.

sink-frequency-threshold

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

max-stores-to-sink

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

case-values-threshold

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

jump-table-max-growth-ratio-for-size

Максимальное отношение роста размера кода при расширении в таблицу переходов (в процентах). Параметр используется при оптимизации по размеру.

jump-table-max-growth-ratio-for-speed

Максимальное отношение роста размера кода при расширении в таблицу переходов (в процентах). Параметр используется при оптимизации по скорости.

tree-reassoc-width

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

sched-pressure-algorithm

Выберите между двумя доступными реализациями -fsched-pressure. Алгоритм 1 - это оригинальная реализация, и она с большей вероятностью предотвратит переупорядочение инструкций. Алгоритм 2 был разработан как компромисс между относительно консервативным подходом, принятым алгоритмом 1, и довольно агрессивным подходом, принятым по умолчанию планировщиком. Он в большей степени полагается на наличие обычного файла регистров и точных классов давления регистров. Дополнительную информацию см. в файле haifa-sched.cc в исходных кодах 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.

Примечание: по умолчанию проверка отключена во время выполнения. Для включения её добавьте detect_stack_use_after_return=1 в переменную среды ASAN_OPTIONS.

asan-instrumentation-with-call-threshold

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

asan-kernel-mem-intrinsic-prefix

Если ненулевое, префикс вызовов memcpy, memset и memmove с «__asan_» или «__hwasan_» соответственно для -fsanitize=kernel-address или ‘-fsanitize=kernel-hwaddress’.

hwasan-instrument-stack

Включить hwasan инструментирование статически размещенных переменных, выделенных в стеке. Этот тип инструментирования включен по умолчанию при использовании -fsanitize=hwaddress и отключен по умолчанию при использовании -fsanitize=kernel-hwaddress. Для отключения инструментирования стека используйте --param hwasan-instrument-stack=0, а для включения - --param hwasan-instrument-stack=1.

hwasan-random-frame-tag

При использовании инструментирования стека, выбирайте теги для переменных стека, используя детерминированную последовательность, начинающуюся с случайного тега для каждого кадра. Без указания этого параметра, теги выбираются, используя ту же последовательность, но начиная с 1. Включено по умолчанию для -fsanitize=hwaddress и недоступно для -fsanitize=kernel-hwaddress. Для отключения используйте --param hwasan-random-frame-tag=0.

hwasan-instrument-allocas

Включить hwasan инструментирование динамически размещенных переменных, выделенных в стеке. Этот тип инструментирования включен по умолчанию при использовании -fsanitize=hwaddress и отключен по умолчанию при использовании -fsanitize=kernel-hwaddress. Для отключения инструментирования таких переменных используйте --param hwasan-instrument-allocas=0, а для включения - --param hwasan-instrument-allocas=1.

hwasan-instrument-reads

Включить hwasan проверки при чтении из памяти. Инструментирование чтений включено по умолчанию для -fsanitize=hwaddress и -fsanitize=kernel-hwaddress. Для отключения проверок чтения из памяти используйте --param hwasan-instrument-reads=0.

hwasan-instrument-writes

Включить hwasan проверки при записи в память. Инструментирование записей включено по умолчанию для -fsanitize=hwaddress и -fsanitize=kernel-hwaddress. Для отключения проверок записи в память используйте --param hwasan-instrument-writes=0.

hwasan-instrument-mem-intrinsics

Включить hwasan инструментирование встроенных функций. Инструментирование этих встроенных функций включено по умолчанию для -fsanitize=hwaddress и -fsanitize=kernel-hwaddress. Для отключения инструментирования встроенных функций используйте --param hwasan-instrument-mem-intrinsics=0.

use-after-scope-direct-emission-threshold

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

tsan-distinguish-volatile

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

tsan-instrument-func-entry-exit

Выводить вызовы инструментирования в __tsan_func_entry() и __tsan_func_exit().
max-fsm-thread-path-insns: Максимальное количество инструкций для копирования при дублировании блоков по пути потока прыжка конечного автомата.
threader-debug: threader-debug=[none|all] Включает подробную информацию о выводе решателя threader.
parloops-chunk-size: Размер блока omp schedule для циклов, распараллеленных parloops.
parloops-schedule: Тип расписания omp schedule для циклов, распараллеленных parloops (static, dynamic, guided, auto, runtime).
parloops-min-per-thread: Минимальное количество итераций на поток для вложенного цикла, для которого предпочтительнее распараллеленная версия, чем однопоточная. Обратите внимание, что для вложенного распараллеленного цикла минимальное количество итераций внешнего цикла на поток равно двум.
max-ssa-name-query-depth: Максимальная глубина рекурсии при запросе свойств имён SSA в таких функциях, как fold. Один уровень рекурсии соответствует прослеживанию цепочки использования-определения.
max-speculative-devirt-maydefs: Максимальное количество may-def, которые анализируются при поиске must-def, определяющего динамический тип объекта, вызывающего виртуальный вызов, который можно спекулятивно девиртуализировать.
evrp-sparse-threshold: Максимальное количество основных блоков, прежде чем EVRP использует кэширование с разреженностью.
ranger-debug: Определяет тип отладочного вывода, который будет выдан для диапазонов.
evrp-switch-limit: Указывает максимальное количество случаев переключения, прежде чем EVRP проигнорирует переключение.
unroll-jam-min-percent: Минимальный процент ссылок на память, которые должны быть оптимизированы, для того чтобы преобразование unroll-and-jam считалось выгодным.
unroll-jam-max-unroll: Максимальное число раз, которое внешний цикл должен быть развёрнут преобразованием unroll-and-jam.
max-rtl-if-conversion-unpredictable-cost: Максимальная допустимая стоимость последовательности, которая будет сгенерирована проходом преобразования if-в-RTL для ветви, которая считается непредсказуемой.
max-variable-expansions-in-unroller: Если используется -fvariable-expansion-in-unroller, максимальное количество раз, которое отдельная переменная будет расширена во время развёртывания цикла.
partial-inlining-entry-probability: Максимальная вероятность входа BB разделяемой области (в процентах относительно входа BB функции), чтобы сделать частичное инлайнирование.
max-tracked-strlens: Максимальное количество строк, для которых проход оптимизации strlen будет отслеживать длину строк.
gcse-after-reload-partial-fraction: Пороговое соотношение для выполнения частичной элиминации избыточности после загрузки.
gcse-after-reload-critical-fraction: Пороговое соотношение количества исполнений критических рёбер, которые позволяют выполнить элиминацию избыточности после загрузки.
max-loop-header-insns: Максимальное количество инструкций в заголовке цикла, дублированных проходом копирования заголовков циклов.
vect-epilogues-nomask: Включить векторизацию эпилога цикла с использованием меньшего размера вектора.
vect-partial-vector-usage: Управляет тем, когда векторизатор циклов рассматривает использование частичных векторных загрузок и сохранений как альтернативу возвращению к скалярному коду. 0 останавливает векторизатор от использования частичных векторных загрузок и сохранений. 1 допускает частичные векторные загрузки и сохранения, если векторизация устраняет необходимость итерации кода. 2 допускает частичные векторные загрузки и сохранения во всех циклах. Параметр действует только на целевые платформы, которые поддерживают частичные векторные загрузки и сохранения.
vect-inner-loop-cost-factor: Максимальный коэффициент, который векторизатор циклов применяет к стоимости операторов во внутреннем цикле относительно векторизуемого цикла. Применяемый коэффициент является максимальным из оценочного количества итераций внутреннего цикла и этого параметра. Значение параметра по умолчанию равно 50.
vect-induction-float: Включить векторизацию циклов для индукций с плавающей точкой.
avoid-fma-max-bits: Максимальное количество бит, для которых мы избегаем создания FMAs.
sms-loop-average-count-threshold: Порог по среднему количеству итераций, рассматриваемый планировщиком swing modulo.
sms-dfa-history: Количество циклов, рассматриваемых планировщиком swing modulo при проверке конфликтов с использованием DFA.
graphite-allow-codegen-errors: Должны ли ошибки кодогенерации быть ICE, когда -fchecking.
sms-max-ii-factor: Коэффициент для настройки верхней границы, используемой планировщиком swing modulo для планирования цикла.
lra-max-considered-reload-pseudos: Максимальное количество псевдонимов загрузки, которые учитываются во время вытеснения не-псевдонима загрузки.
max-pow-sqrt-depth: Максимальная глубина цепочек sqrt для использования при синтезе возведения в степень вещественной константой.
max-dse-active-local-stores: Максимальное количество активных локальных сохранений в RTL dead store elimination.
asan-instrument-allocas: Включить защиту asan для allocas/VLAs.
max-iterations-computation-cost: Граница стоимости выражения для вычисления количества итераций.
max-isl-operations: Максимальное количество операций isl, 0 означает неограниченно.
graphite-max-arrays-per-scop: Максимальное количество массивов на scop.
max-vartrack-reverse-op-size: Максимальный размер списка loc, для которого должны быть добавлены обратные операции.
fsm-scale-path-stmts: Коэффициент масштабирования для применения к количеству операторов в пути потока, пересекающего петлю обратной связи, при сравнении с --param=max-jump-thread-duplication-stmts.
uninit-control-dep-attempts: Максимальное количество вложенных вызовов для поиска зависимостей управления во время анализа неинициализированных переменных.
uninit-max-chain-len: Максимальное количество предикат и, для каждого предиката или в нормализованной цепочке предикатов.
uninit-max-num-chains: Максимальное количество предикатов или в нормализованной цепочке предикатов.
sched-autopref-queue-depth: Флаг управления моделью планировщика автопрефечера аппаратных средств. Количество циклов прогнозирования, которые модель рассматривает; при ’ ’ включить только эвристику сортировки инструкций.
loop-versioning-max-inner-insns: Максимальное количество инструкций, которые может содержать внутренний цикл, прежде чем проход версии цикла сочтет его слишком большим для копирования.
loop-versioning-max-outer-insns: Максимальное количество инструкций, которые может содержать внешний цикл, прежде чем проход версии цикла сочтет его слишком большим для копирования, не учитывая инструкции во внутренних циклах, которые напрямую получают выгоду от версии.
ssa-name-def-chain-limit: Максимальное число назначений SSA_NAME, которые необходимо отслеживать для определения свойства переменной, например, её значения. Это ограничивает количество итераций или рекурсивных вызовов GCC, выполняемых при оптимизации определенных операторов или при определении их корректности перед выводом диагностических сообщений.
store-merging-max-size: Максимальный размер одной области слияния сохранений в байтах.
hash-table-verification-limit: Количество элементов, для которых выполняется проверка хеш-таблицы для каждого искомого элемента.
max-find-base-term-values: Максимальное количество VALUE, обрабатываемых во время одного вызова find_base_term.
analyzer-max-enodes-per-program-point: Максимальное количество взорванных узлов на точку программы в анализаторе, прежде чем анализ этой точки будет завершён.
analyzer-max-constraints: Максимальное количество ограничений на состояние.
analyzer-min-snodes-for-call-summary: Минимальное количество суперузлов в функции для анализатора, чтобы рассмотреть возможность обобщения его эффектов в местах вызова.
analyzer-max-enodes-for-full-dump: Максимальная глубина взорванных узлов, которые должны появиться в дампе DOT, прежде чем переключится на менее подробный формат.
analyzer-max-recursion-depth: Максимальное количество появлений места вызова в стеке вызовов в анализаторе, прежде чем анализ вызова, который бы рекурсировал глубже, будет завершён.
analyzer-max-svalue-depth: Максимальная глубина символического значения, прежде чем значение будет приближено как неизвестное.
analyzer-max-infeasible-edges: Максимальное количество невозможных рёбер для отклонения, прежде чем диагностика будет объявлена невозможной.
gimple-fe-computed-hot-bb-threshold: Количество исполнений основного блока, которое считается горячим. Параметр используется только в GIMPLE FE.
analyzer-bb-explosion-factor: Максимальное количество взорванных узлов «после суперузла» в анализаторе на суперузел, прежде чем анализ будет завершен.
ranger-logical-depth: Максимальная глубина логического выражения, которая будет просмотрена диапазоном при оценке выходных диапазонов рёбер.
ranger-recompute-depth: Максимальная глубина цепочек инструкций для рассмотрения повторного вычисления в вычислителе выходных диапазонов.
relation-block-limit: Максимальное количество отношений, которые зарегистрирует оракул в основном блоке.
min-pagesize: Минимальный размер страницы для целей вывода предупреждений.
openacc-kernels: Указывает режим обработки конструкций OpenACC «kernels». С помощью --param=openacc-kernels=decompose конструкции OpenACC «kernels» декомпозируются на части, последовательность инструкций compute, каждая из которых затем обрабатывается индивидуально. Эта работа находится в стадии разработки. С помощью --param=openacc-kernels=parloops конструкции OpenACC «kernels» обрабатываются проходом «parloops», как единое целое. Это текущий режим по умолчанию.
openacc-privatization: Управляет тем, выдают ли опции -fopt-info-omp-note и соответствующие -fdump-tree-*-details диагностические сообщения OpenACC о приватизации. При --param=openacc-privatization=quiet не выводить диагностику. Это текущий режим по умолчанию. При --param=openacc-privatization=noisy выводить диагностику.

Следующие варианты name доступны на целевых платформах AArch64:

aarch64-sve-compare-costs

При векторизации для SVE следует рассмотреть использование «распакованных» векторов для элементов меньшего размера и использовать модель затрат для выбора наилучшего подхода. Также используйте модель затрат для выбора между векторизацией SVE и Advanced SIMD.

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

aarch64-float-recp-precision

Количество итераций Ньютона для вычисления обратной величины для типа float. Точность деления пропорциональна этому параметру, когда включено приближение деления. Значение по умолчанию — 1.

aarch64-double-recp-precision

Количество итераций Ньютона для вычисления обратной величины для типа double. Точность деления пропорциональна этому параметру, когда включено приближение деления. Значение по умолчанию — 2.

aarch64-autovec-preference

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

‘0’: Использование стандартных эвристик.
‘1’: Использование только Advanced SIMD для автоматической векторизации.
‘2’: Использование только SVE для автоматической векторизации.
‘3’: Использование как Advanced SIMD, так и SVE. При равных затратах отдавать предпочтение Advanced SIMD.
‘4’: Использование как Advanced SIMD, так и SVE. При равных затратах отдавать предпочтение SVE.

Значение по умолчанию — 0.

aarch64-loop-vect-issue-rate-niters

Настройка для некоторых процессоров AArch64 пытается учесть как задержки, так и скорости выдачи, когда определяется, следует ли векторизовать цикл с использованием SVE, векторизовать с использованием Advanced SIMD или вообще не векторизовать. Если этот параметр установлен в n, GCC не будет использовать эту эвристику для циклов, которые, как известно, выполняются менее чем за n итераций Advanced SIMD.

aarch64-vect-unroll-limit

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

Доступны следующие варианты name для целей i386 и x86_64:

x86-stlf-window-ninsns: Количество инструкций, превышение которого компенсирует штраф за задержку STFL.
x86-stv-max-visits: Максимальное количество посещений использования и определения при обнаружении цепочки STV перед прерыванием обнаружения.

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