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

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 
-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 включает все флаги оптимизации, указанные в -O. Он также включает следующие флаги оптимизации:

-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-pre 
-ftree-switch-conversion  -ftree-tail-merge 
-ftree-vrp

Обратите внимание на предупреждение под -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-loop-vectorize 
-ftree-partial-pre 
-ftree-slp-vectorize 
-funswitch-loops 
-fvect-cost-model 
-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.

-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  -fssa-phiopt 
-ftree-bit-ccp  -ftree-dse  -ftree-pta  -ftree-sra

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

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

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

-fno-defer-pop

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

-fforward-propagate

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

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

-ffp-contract=style

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

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

-fomit-frame-pointer

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

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

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

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

-foptimize-sibling-calls

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

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

-foptimize-strlen

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

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

-fno-inline

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

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

-finline-small-functions

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

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

-findirect-inlining

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

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

-finline-functions

Рассматривать все функции для встраивания, даже если они не объявлены как 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, чтобы запретить это поведение.

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

-fmerge-all-constants

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

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

-fmodulo-sched

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

-fmodulo-sched-allow-regmoves

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

-fno-branch-count-reg

Отключить проход оптимизации, который ищет возможности использования инструкций «декремент и переход» (decrement and branch) по регистру счётчика вместо последовательностей инструкций, которые декрементируют регистр, сравнивают его с нулём и затем переходят, в зависимости от результата. Этот параметр имеет смысл только на архитектурах, которые поддерживают такие инструкции, включая 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

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

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

-fsplit-wide-types

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

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

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

-faggressive-loop-optimizations

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

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

-funconstrained-commons

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

-fcrossjumping

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

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

-fauto-inc-dec

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

-fdce

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

-fdse

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

-fif-conversion

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

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

-fif-conversion2

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

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

-fdeclone-ctor-dtor

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

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

-fdelete-null-pointer-checks

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

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

Этот параметр включен по умолчанию на большинстве целевых платформ. На Nios II ELF он выключен по умолчанию. На AVR, CR16 и 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++ значение объекта зависит только от изменений в течение его жизненного цикла: когда конструктор начинается, объект имеет неопределенное значение, а любые изменения в течение жизненного цикла объекта мертвы, когда объект уничтожается. Обычно удаление мёртвых хранилищ будет использовать это; если ваш код полагается на сохранение значения хранилища объекта за пределами жизненного цикла объекта, вы можете использовать этот флаг для отключения этой оптимизации. Чтобы сохранить хранилища перед началом конструктора (например, потому что ваш оператор 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 для оценки давления на регистры в проходе повышения кода для принятия решений о повышении выражений. Этот параметр обычно приводит к меньшему коду, но может замедлить компилятор.

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

-fira-loop-pressure

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

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

-fno-ira-share-save-slots

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

-fno-ira-share-spill-slots

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

-flra-remat

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

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

-fdelayed-branch

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

Включено на уровнях -O, -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

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

-freschedule-modulo-scheduled-loops

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

-fselective-scheduling

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

-fselective-scheduling2

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

-fsel-sched-pipelining

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

-fsel-sched-pipelining-outer-loops

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

-fsemantic-interposition

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

-fshrink-wrap

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

-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

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

-fcode-hoisting

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

-ftree-pre

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

-ftree-partial-pre

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

-ftree-forwprop

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

-ftree-fre

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

-ftree-phiprop

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

-fhoist-adjacent-loads

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

-ftree-copy-prop

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

-fipa-pure-const

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

-fipa-reference

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

-fipa-reference-addressable

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

-fipa-stack-alignment

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

-fipa-pta

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

-fipa-profile

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

-fipa-modref

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

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

-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

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

Несмотря на сходство с оптимизацией 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 или errno. Изолировать эти пути от основного потока управления и преобразовать оператор с ошибочным или неопределенным поведением в ловушку. В настоящее время это не включено, но может быть включено в -O2 в будущем.

-ftree-sink

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

-ftree-bit-ccp

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

-ftree-ccp

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

-fssa-backprop

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

-fssa-phiopt

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

-ftree-switch-conversion

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

-ftree-tail-merge

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

-ftree-dce

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

-ftree-builtin-call-dce

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

-ffinite-loops

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

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

-ftree-dominator-opts

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

-ftree-dse

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

-ftree-ch

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

-ftree-loop-optimize

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

-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 zero. Например, цикл

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

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

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

и цикл инициализации преобразуется в вызов memset zero. Этот флаг включён по умолчанию при -O3. Также включается при -fprofile-use и -fauto-profile.

-floop-interchange

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

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

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

-ftree-loop-im

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

-ftree-loop-ivcanon

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

-ftree-scev-cprop

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

-fivopts

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

-ftree-parallelize-loops=n

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

-ftree-pta

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

-ftree-sra

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

-fstore-merging

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

-ftree-ter

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

-ftree-slsr

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

-ftree-vectorize

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

-ftree-loop-vectorize

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

-ftree-slp-vectorize

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

-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

Выполнить распространение диапазонов значений на деревьях. Это аналогично прохождению по константам, но вместо значений распространяются диапазоны значений. Это позволяет оптимизаторам удалять ненужные проверки диапазонов, такие как проверки границ массива и проверки на нулевой указатель. Включено по умолчанию в -O2 и выше. Устранение проверки на нулевой указатель выполняется только в случае включения -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

Отключить любые машинные оптимизации «peephole». Разница между -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

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

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

-freorder-blocks-algorithm=algorithm

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

По умолчанию используется ‘simple’ на уровнях -O, -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.

-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.

-fweb

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

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

-fwhole-program

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

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

-flto[=n]

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

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

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

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

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

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

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

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

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

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

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

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

-fcompare-elim

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

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

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

-fcprop-registers

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

Включено на уровнях -O, -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).

Если указан путь, GCC ищет файлы данных профиля обратной связи по пути. См. -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

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

-fexcess-precision=standard не реализован для языков, кроме 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

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

По умолчанию используется -fno-unsafe-math-optimizations.

-fassociative-math

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

По умолчанию используется -fno-associative-math.

-freciprocal-math

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

По умолчанию используется -fno-reciprocal-math.

-ffinite-math-only

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

По умолчанию используется -fno-finite-math-only.

-fno-signed-zeros

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

По умолчанию используется -fsigned-zeros.

-fno-trapping-math

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

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

По умолчанию используется -ftrapping-math.

-frounding-math

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

По умолчанию используется -fno-rounding-math.

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

-fsignaling-nans

Компилировать код с предположением, что сигнализирующие NaN IEEE могут генерировать видимые пользователю ловушки во время операций с плавающей запятой. Установка этого параметра отключает оптимизации, которые могут изменить количество исключений, видимых с сигнализирующими 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 для каждого исходного файла. Информация в этом файле сильно зависит от структуры сгенерированного кода, поэтому вы должны использовать тот же исходный код и те же параметры оптимизации для обеих компиляций.

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

-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:

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

Максимальное количество инструкций для дублирования в блок, который переходит к вычисленному переходу. Чтобы избежать поведения O(N^2) в ряде проходов, GCC сворачивает вычисленные переходы на ранней стадии процесса компиляции и разворачивает их как можно позже. Только вычисленные переходы в конце основных блоков с количеством инструкций не более 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-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.

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

Максимальное количество похожих блоков базовых блоков (bbs), с которыми сравнивается 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

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

max-completely-peel-times

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

max-completely-peel-loop-nest-depth

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

max-unswitch-insns

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

max-unswitch-level

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

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

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

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 при преобразовании, если цикл не помечен pragma simd.

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

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

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

ggc-min-heapsize

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

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

max-reload-search-insns

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

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

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

max-last-value-rtl

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

max-combine-insns

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

integer-share-limit

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

ssp-buffer-size

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

min-size-for-stack-sharing

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

max-jump-thread-duplication-stmts

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

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

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

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). Количество доступных регистров, зарезервированных для других целей, задаётся этим параметром. Значение по умолчанию для параметра выбрано на основе многочисленных экспериментов.
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-ptr-growth-factor: IPA-SRA заменяет указатель на агрегат одним или несколькими новыми параметрами только тогда, когда их совокупный размер меньше или равен ipa-sra-ptr-growth-factor раз размеру исходного параметра-указателя.
ipa-sra-max-replacements: Максимальное количество частей агрегата, отслеживаемых IPA-SRA. Соответственно, это также максимальное количество замен формального параметра.
sra-max-scalarization-size-Osize: Два прохода по скалярному сокращению агрегатов (SRA и IPA-SRA) стремятся заменить скалярные части агрегатов использованием независимых скалярных переменных. Эти параметры контролируют максимальный размер, в единицах хранения, агрегата, который рассматривается для замены при компиляции на скорость (sra-max-scalarization-size-Ospeed) или размер (sra-max-scalarization-size-Osize) соответственно.
sra-max-propagations: Максимальное количество искусственных обращений, которые Scalar Replacement of Aggregates (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-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.c в исходных кодах GCC.

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

max-slsr-cand-scan

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

asan-globals

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

asan-stack

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

asan-instrument-reads

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

asan-instrument-writes

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

asan-memintrin

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

asan-use-after-return

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

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

asan-instrumentation-with-call-threshold

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

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

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

max-fsm-thread-length

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

max-fsm-thread-paths

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

parloops-chunk-size

Размер блока omp расписания для циклов, распараллеленных с помощью parloops.

parloops-schedule

Тип расписания omp расписания для циклов, распараллеленных с помощью parloops (static, dynamic, guided, auto, runtime).

parloops-min-per-thread

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

max-ssa-name-query-depth

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

max-speculative-devirt-maydefs

Максимальное количество may-defs, которые анализируются при поиске must-def, определяющего динамический тип объекта, вызывающего виртуальный вызов, который мы можем попытаться девиртуализировать спекулятивно.

max-vrp-switch-assertions

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

evrp-mode

Устанавливает режим работы Early VRP.

unroll-jam-min-percent

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

unroll-jam-max-unroll

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

max-rtl-if-conversion-unpredictable-cost

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

max-variable-expansions-in-unroller

Если используется -fvariable-expansion-in-unroller, максимальное количество раз, которое отдельная переменная будет развернута при разворачивании цикла.

tracer-min-branch-probability-feedback

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

partial-inlining-entry-probability

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

max-tracked-strlens

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

gcse-after-reload-partial-fraction

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

gcse-after-reload-critical-fraction

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

max-loop-header-insns

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

vect-epilogues-nomask

Включить векторизацию эпилога цикла с использованием меньшего размера вектора.

vect-partial-vector-usage

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

avoid-fma-max-bits

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

sms-loop-average-count-threshold

Порог по среднему числу итераций, учитываемый планировщиком swing modulo.

sms-dfa-history

Количество циклов, учитываемых планировщиком swing modulo при проверке конфликтов с использованием DFA.

max-inline-insns-recursive-auto

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

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.

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, для которого должны быть добавлены обратные операции.

END_OF_DOCUMENT_MARKER

tracer-dynamic-coverage-feedback: Процент функций, взвешенный частотой выполнения, который должен быть покрыт формированием трассировки. Используется при наличии обратной связи профилирования.
max-inline-recursive-depth-auto: Максимальная глубина рекурсивной вставки для не-встраиваемых функций.
fsm-scale-path-stmts: Множитель масштабирования, применяемый к числу инструкций в потоке нити, при сравнении с числом (масштабированных) блоков.
fsm-maximum-phi-arguments: Максимальное число аргументов, которые может иметь PHI-оператор, прежде чем модуль FSM-нити не будет пытаться нитировать через блок.
uninit-control-dep-attempts: Максимальное число вложенных вызовов для поиска зависимостей управления во время анализа неинициализированных переменных.
sra-max-scalarization-size-Osize: Максимальный размер агрегата в единицах хранения, который следует учитывать для скаляризации при компиляции по размеру.
fsm-scale-path-blocks: Множитель масштабирования, применяемый к числу блоков в пути нити, при сравнении с числом (масштабированных) инструкций.
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: Максимальная глубина вычисления логического выражения, которую диапазон будет просматривать при оценке диапазонов исходящих ребер.
openacc-kernels: Укажите режим обработки конструкций OpenACC «kernels». С помощью --param=openacc-kernels=decompose, конструкции OpenACC «kernels» декомпонируются на части, последовательность вычислительных конструкций, каждая затем обрабатывается индивидуально. Это работа в процессе. С помощью --param=openacc-kernels=parloops, конструкции OpenACC «kernels» обрабатываются этапом «parloops», целиком. Это текущий стандартный режим.

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

aarch64-sve-compare-costs

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

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

aarch64-sve-compare-costs

Количество итераций Ньютона для вычисления обратной величины для типа 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.

Следующее: Параметры программирования, Предыдущее: Параметры отладки вашей программы, Наверх: Параметры командной строки GCC [Оглавление][Индекс]

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