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

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

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

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

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

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

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

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

-O

-O1

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

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

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

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

-O2

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

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

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

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

-O3

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

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

-O0

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

-Os

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

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

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

-Ofast

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

-Og

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

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

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

-Oz

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

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

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

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

END_OF_DOCUMENT_MARKER

-fno-defer-pop

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

-fforward-propagate

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

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

-ffp-contract=style

-ffp-contract=off отключает сокращение выражений с плавающей точкой. -ffp-contract=fast включает сокращение выражений с плавающей точкой, например, формирование операций умножения-сложения слияния, если целевая платформа имеет для них собственную поддержку. -ffp-contract=on включает сокращение выражений с плавающей точкой, если это разрешено стандартом языка. Это реализовано для C и C++, где оно включает сокращение в рамках одного выражения, но не через разные операторы.

По умолчанию используется -ffp-contract=off для C в режиме соответствия стандартам (-std=c11 или аналогичном), -ffp-contract=fast в противном случае.

-fomit-frame-pointer

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

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

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

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

-foptimize-sibling-calls

Оптимизируйте вызовы функций-сиблингов и хвостовой рекурсии.

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

-foptimize-strlen

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

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

-finline-stringops[=fn]

Встраивайте операции с памятью и строками (на данный момент только memset) встраиваемо, даже когда длина переменная или достаточно большая, чтобы потребовалось циклическое выполнение. Это наиболее полезно вместе с -ffreestanding и -fno-builtin.

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

-fno-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. См. Объявление атрибутов функций.

-fkeep-inline-functions

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

-fkeep-static-functions

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

-fkeep-static-consts

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

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

-fmerge-constants

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

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

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

-fmerge-all-constants

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

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

-fmodulo-sched

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

-fmodulo-sched-allow-regmoves

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

-fno-branch-count-reg

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

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

-fno-function-cse

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

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

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

-fno-zero-initialized-in-bss

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

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

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

-fthread-jumps

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

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

-fsplit-wide-types

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

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

-fsplit-wide-types-early

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

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

-fcse-follow-jumps

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

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

-fcse-skip-blocks

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

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

-frerun-cse-after-loop

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

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

-fgcse

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

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

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

-fgcse-lm

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

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

-fgcse-sm

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

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

-fgcse-las

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

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

-fgcse-after-reload

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

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

-faggressive-loop-optimizations

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

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

-funconstrained-commons

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

-fcrossjumping

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

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

-fauto-inc-dec

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

-fdce

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

-fdse

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

-fif-conversion

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

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

-fif-conversion2

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

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

-fdeclone-ctor-dtor

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

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

-fdelete-null-pointer-checks

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

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

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

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

-fdevirtualize

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

-fdevirtualize-speculatively

END_OF_DOCUMENT_MARKER

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

-fdevirtualize-at-ltrans

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

-fexpensive-optimizations

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

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

-free

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

Включён для Alpha, AArch64, LoongArch, PowerPC, RISC-V, SPARC, h83000 и 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

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

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

-fschedule-insns

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

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

-fschedule-insns2

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

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

-fno-sched-interblock

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

-fno-sched-spec

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

-fsched-pressure

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

-fsched-spec-load

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

-fsched-spec-load-dangerous

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

-fsched-stalled-insns

-fsched-stalled-insns=n

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

-fsched-stalled-insns-dep

-fsched-stalled-insns-dep=n

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

-fsched2-use-superblocks

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

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

-fsched-group-heuristic

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

-fsched-critical-path-heuristic

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

-fsched-spec-insn-heuristic

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

-fsched-rank-heuristic

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

-fsched-last-insn-heuristic

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

-fsched-dep-count-heuristic

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

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

-fcode-hoisting

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

-ftree-pre

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

-ftree-partial-pre

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

-ftree-forwprop

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

-ftree-fre

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

-ftree-phiprop

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

-fhoist-adjacent-loads

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

-ftree-copy-prop

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

-fipa-pure-const

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

-fipa-reference

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

-fipa-reference-addressable

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

-fipa-stack-alignment

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

-fipa-pta

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

-fipa-profile

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

-fipa-modref

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

-fipa-cp

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

-fipa-cp-clone

Выполнить клонирование функций, чтобы усилить межпроцедурную константную прокладку. При включении межпроцедурная константная прокладка выполняет клонирование функций, когда внешне видимая функция может вызываться с константными аргументами. Поскольку эта оптимизация может создавать несколько копий функций, она может значительно увеличить размер кода (см. --param ipa-cp-unit-growth=значение). Этот флаг включен по умолчанию в -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 могут быть частично включены на двух разных уровнях.

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

‘inline-clone’

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

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

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

‘inline-only-static’

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

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

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

Если -flive-patching указан без значения, значение по умолчанию равно inline-clone.

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

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

-fisolate-erroneous-paths-dereference

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

-fisolate-erroneous-paths-attribute

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

-ftree-sink

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

-ftree-bit-ccp

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

-ftree-ccp

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

-fssa-backprop

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

-fssa-phiopt

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

-ftree-switch-conversion

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

-ftree-tail-merge

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

-ftree-dce

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

-ftree-builtin-call-dce

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

-ffinite-loops

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

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

-ftree-dominator-opts

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

-ftree-dse

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

-ftree-ch

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

-ftree-loop-optimize

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

-ftree-loop-linear

-floop-strip-mine

-floop-block

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

-fgraphite-identity

Включить тождественное преобразование для графита. Для каждого 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.

-floop-interchange

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

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

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

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

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

-floop-unroll-and-jam

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

-ftree-loop-im

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

-ftree-loop-ivcanon

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

-ftree-scev-cprop

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

-fivopts

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

-ftree-parallelize-loops=n

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

-ftree-pta

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

-ftree-sra

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

-fstore-merging

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

-ftree-ter

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

-ftree-slsr

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

-ftree-vectorize

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

-ftree-loop-vectorize

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

-ftree-slp-vectorize

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

-ftrivial-auto-var-init=choice

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

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

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

По умолчанию «uninitialized».

Обратите внимание, что значения инициализатора, будь то ‘zero’ или ‘pattern’, относятся к представлению данных (в памяти или машинных регистрах), а не к их интерпретации как числовых значений. Это различие может быть важным в языках, которые поддерживают типы с смещениями или неявными множителями, и с такими расширениями, как ‘hardbool» (см. Указание атрибутов типов). Например, переменная, которая использует 8 бит для представления (смещённых) величин в range 160..400, будет инициализирована битовыми шаблонами 0x00 или 0xFE, в зависимости от choice, независимо от того, представляют ли эти представления значения в этом диапазоне, и даже если они это делают, интерпретация значения, хранимого в переменной, будет зависеть от смещения. Переменная «hardbool», которая использует, скажем, 0X5A и 0xA5 для false и true, соответственно, будет сообщать об ошибке с любым «choice» тривиальной инициализации, т.е. инициализация «zero» не преобразуется в представление для false, даже если бы это было для переменной static того же типа. Это означает, что шаблон инициализатора в общем случае не зависит от типа инициализируемой переменной. Одно важное исключение заключается в том, что (неусиленные) булевы переменные, которые помещаются в регистры, инициализируются с false (нуль), даже когда запрашивается ‘pattern’.

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

-fvect-cost-model=model

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

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

-fsimd-cost-model=model

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

-ftree-vrp

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

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

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

-freorder-blocks-algorithm=algorithm

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

По умолчанию используется ‘simple’ на уровнях -O1, -Os, и ‘stc’ на уровнях -O2, -O3.

-freorder-blocks-and-partition

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

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

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

-freorder-functions

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

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

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

-fstrict-aliasing

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

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

union a_union {
  int i;
  double d;
};

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

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

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

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

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

Опция -fstrict-aliasing включена на уровнях -O2, -O3, -Os.

-fipa-strict-aliasing

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

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

-falign-functions

-falign-functions=n

-falign-functions=n:m

-falign-functions=n:m:n2

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

Выравнивает начало функций по следующей степени двойки, большей или равной n, пропуская до m-1 байт. Это гарантирует, что по крайней мере первые m байт функции могут быть получены процессором без пересечения границы выравнивания на n байт. Это оптимизация производительности кода, и выравнивание игнорируется для функций, считающихся «холодными». Если выравнивание требуется для всех функций, используйте -fmin-function-alignment.

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

-fmin-function-alignment

Указывает минимальное выравнивание функций по следующей степени двойки, большей или равной n. В отличие от -falign-functions, это выравнивание применяется ко всем функциям (даже тем, которые считаются «холодными»). Выравнивание также не зависит от -flimit-function-alignment.

-fno-allocation-dce

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

-fallow-store-data-races

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

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

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

-funit-at-a-time

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

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

-fno-toplevel-reorder

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

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

-funreachable-traps

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

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

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

-fweb

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

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

-fwhole-program

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

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

-flto[=n]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-flto-partition=alg

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

-flto-compression-level=n

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

-fuse-linker-plugin

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

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

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

-ffat-lto-objects

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

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

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

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

-fcompare-elim

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

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

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

-ffold-mem-offsets

-fno-fold-mem-offsets

Попытаться устранить инструкции add путём их сворачивания в загрузках/сохранениях в памяти.

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

-fcprop-registers

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

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

-fprofile-correction

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

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

-fprofile-partial-training

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

-fprofile-use

-fprofile-use=path

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

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

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

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

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

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

-ffast-math

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

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

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

-fno-math-errno

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

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

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

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

-funsafe-math-optimizations

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

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

-fassociative-math

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

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

-freciprocal-math

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

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

-ffinite-math-only

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

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

-fno-signed-zeros

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

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

-fno-trapping-math

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

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

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

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

-frounding-math

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

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

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

-fsignaling-nans

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

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

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

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

-fno-fp-int-builtin-inexact

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

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

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

-fsingle-precision-constant

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

-fcx-limited-range

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

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

-fcx-fortran-rules

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

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

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

-fbranch-probabilities

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

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

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

-fprofile-values

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

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

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

-fprofile-reorder-functions

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

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

-fvpt

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

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

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

-frename-registers

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

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

-fschedule-fusion

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

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

-ftracer

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

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

-funroll-loops

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

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

-funroll-all-loops

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

-fpeel-loops

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

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

-fmove-loop-invariants

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

-fmove-loop-stores

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

-fsplit-loops

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

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

-funswitch-loops

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

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

-fversion-loops-for-strides

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

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

становится:

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

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

-ffunction-sections

-fdata-sections

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

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

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

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

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

-fstdarg-opt

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

-fsection-anchors

Попытка уменьшить количество вычислений символических адресов путём использования общих «якорных» символов для адресации близлежащих объектов. Эта трансформация может помочь уменьшить количество записей и обращений к 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

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

max-rtl-if-conversion-predictable-cost

Преобразование if-команд RTL попытается удалить условные ветвления вокруг блока и заменить их условно выполняемыми инструкциями. Эти параметры задают максимальную допустимую стоимость последовательности, которая будет сгенерирована преобразованием if, в зависимости от того, статически ли ветвление определяется как предсказуемое или нет. Единицы для этого параметра такие же, как и для метрики seq_cost в GCC. Компилятор попытается предоставить разумное значение по умолчанию для этого параметра, используя макрос 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-functions-called-once-loop-depth

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

max-inline-functions-called-once-insns

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

max-inline-insns-single

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

max-inline-insns-auto

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

max-inline-insns-small

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

max-inline-insns-size

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

uninlined-function-insns

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

uninlined-function-time

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

inline-heuristics-hint-percent

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

uninlined-thunk-insns

uninlined-thunk-time

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

inline-min-speedup

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

large-function-insns

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

large-function-growth

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

large-unit-insns

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

lazy-modules

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

inline-unit-growth

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

ipa-cp-unit-growth

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

ipa-cp-large-unit-insns

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

large-stack-frame

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

large-stack-frame-growth

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

max-inline-insns-recursive

max-inline-insns-recursive-auto

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

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

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

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

tracer-max-code-growth

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

tracer-min-branch-ratio

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

tracer-min-branch-probability

tracer-min-branch-probability-feedback

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

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

stack-clash-protection-guard-size

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

stack-clash-protection-probe-interval

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

max-cse-path-length

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

max-cse-insns

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

ggc-min-expand

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

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

ggc-min-heapsize

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

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

max-reload-search-insns

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

max-cselib-memory-locations

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

max-sched-ready-insns

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

max-sched-region-blocks

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

max-pipeline-region-blocks

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

max-sched-region-insns

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

max-pipeline-region-insns

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

min-spec-prob

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

max-sched-extend-regions-iters

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

max-sched-insn-conflict-delay

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

sched-spec-prob-cutoff

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

sched-state-edge-prob-cutoff

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

sched-mem-true-dep-cost

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

selsched-max-lookahead

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

selsched-max-sched-times

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

selsched-insns-to-rename

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

sms-min-sc

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

max-last-value-rtl

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

max-combine-insns

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

integer-share-limit

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

ssp-buffer-size

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

min-size-for-stack-sharing

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

max-jump-thread-duplication-stmts

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

max-jump-thread-paths

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

max-fields-for-field-sensitive

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

prefetch-latency

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

simultaneous-prefetches

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

l1-cache-line-size

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

l1-cache-size

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

l2-cache-size

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

prefetch-dynamic-strides

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

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

prefetch-minimum-stride

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

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

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

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

destructive-interference-size

constructive-interference-size

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

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

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

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

loop-interchange-max-num-stmts

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

loop-interchange-stride-ratio

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

min-insn-to-prefetch-ratio

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

prefetch-min-insn-to-mem-ratio

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

use-canonical-types

Следует ли компилятору использовать «каноническую» систему типов. Должно всегда быть равно 1, что использует более эффективный внутренний механизм для сравнения типов в C++ и Objective-C++. Однако, если ошибки в канонической системе типов вызывают сбои компиляции, установите это значение в 0, чтобы отключить канонические типы.

switch-conversion-max-branch-ratio

Переключение инициализации преобразования отказывается создавать массивы, которые больше, чем switch-conversion-max-branch-ratio умноженное на количество ветвей в переключении.

max-partial-antic-length

Максимальная длина частичного антимножества, вычисленного во время оптимизации частичной избыточности дерева (-ftree-pre) при оптимизации на уровне -O3 и выше. Для некоторых типов исходного кода оптимизация частичной избыточности может неограниченно расти, потребляя всю доступную память на хост-машине. Этот параметр устанавливает ограничение на длину вычисляемых множеств, что предотвращает подобное поведение. Установка значения 0 для этого параметра позволяет неограниченную длину множества.

rpo-vn-max-loop-depth

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

sccvn-max-alias-queries-per-access

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

ira-max-loops-num

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

ira-max-conflict-table-size

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

ira-loop-reserved-regs

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

ira-consider-dup-in-all-alts

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

ira-simple-lra-insn-threshold

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

lra-inheritance-ebb-probability-cutoff

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

loop-invariant-max-bbs-in-loop

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

loop-max-datarefs-for-datadeps

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

max-vartrack-size

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

max-vartrack-expr-depth

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

max-debug-marker-count

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

min-nondebug-insn-uid

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

ipa-sra-deref-prob-threshold

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

ipa-sra-ptr-growth-factor

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

ipa-sra-ptrwrap-growth-factor

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

ipa-sra-max-replacements

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

sra-max-scalarization-size-Ospeed

sra-max-scalarization-size-Osize

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

sra-max-propagations

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

tm-max-aggregate-size

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

graphite-max-nb-scop-params

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

hardcfr-max-blocks

Отключить -fharden-control-flow-redundancy для функций с большим количеством блоков, чем указано. Ноль удаляет любое ограничение.

hardcfr-max-inline-blocks

Вынудить -fharden-control-flow-redundancy использовать внеблочную проверку для функций с большим количеством базовых блоков, чем указано.

loop-block-tile-size

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

ipa-jump-function-lookups

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

ipa-cp-value-list-size

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

ipa-cp-eval-threshold

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

ipa-cp-max-recursive-depth

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

ipa-cp-min-recursive-probability

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

ipa-cp-profile-count-base

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

ipa-cp-recursive-freq-factor

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

ipa-cp-recursion-penalty

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

ipa-cp-single-call-penalty

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

ipa-max-agg-items

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

ipa-cp-loop-hint-bonus

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

ipa-max-loop-predicates

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

ipa-max-aa-steps

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

ipa-max-switch-predicate-bounds

Максимальное количество граничных конечных точек диапазонов значений оператора switch. Для операторов switch, превышающих этот лимит, IPA-CP не будет строить предикаты стоимости клонирования, используемые для оценки выгоды от клонирования, для оператора default оператора 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) или преобразование условных операторов (-ftree-loop-if-convert).

case-values-threshold

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

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

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

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

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

tree-reassoc-width

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

sched-pressure-algorithm

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

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

max-slsr-cand-scan

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

asan-globals

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

asan-stack

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

asan-instrument-reads

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

asan-instrument-writes

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

asan-memintrin

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

asan-use-after-return

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

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

asan-instrumentation-with-call-threshold

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

asan-kernel-mem-intrinsic-prefix

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

hwasan-instrument-stack

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

hwasan-random-frame-tag

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

hwasan-instrument-allocas

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

hwasan-instrument-reads

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

hwasan-instrument-writes

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

hwasan-instrument-mem-intrinsics

Включить инструментацию hwasan для встроенных функций. Инструментация этих встроенных функций включена по умолчанию для обоих -fsanitize=hwaddress и -fsanitize=kernel-hwaddress. Чтобы отключить инструментацию встроенных функций, используйте --param hwasan-instrument-mem-intrinsics=0.
use-after-scope-direct-emission-threshold: Если размер локальной переменной в байтах меньше или равен этому числу, непосредственно отравлять (или снимать отравление) теневую память вместо использования обратных вызовов во время выполнения.
tsan-distinguish-volatile: Выводить специальную инструментацию для обращений к переменным volatile.
tsan-instrument-func-entry-exit: Выводить вызовы инструментации __tsan_func_entry() и __tsan_func_exit().
max-fsm-thread-path-insns: Максимальное количество инструкций для копирования при дублировании блоков на пути потока прыжка автомата конечного состояния.
threader-debug: threader-debug=[none|all] Включает подробную выгрузку решателя threader.
parloops-chunk-size: Размер блока omp schedule для циклов, распараллеленных с помощью parloops.
parloops-schedule: Тип планирования omp schedule для циклов, распараллеленных с помощью parloops (static, dynamic, guided, auto, runtime).
parloops-min-per-thread: Минимальное количество итераций на поток во внутреннем распараллеленном цикле, для которого распараллеленная версия предпочтительнее однопоточной. Обратите внимание, что для вложенного распараллеленного цикла минимальное количество итераций внешнего цикла на поток равно двум.
max-ssa-name-query-depth: Максимальная глубина рекурсии при запросе свойств имён SSA в таких операциях, как процедуры сворачивания. Один уровень рекурсии соответствует слежению за цепочкой использования-определения.
max-speculative-devirt-maydefs: Максимальное количество may-defs, которые мы анализируем при поиске must-def, определяющего динамический тип объекта, вызывающего виртуальный вызов, который мы можем девиртуализировать умозрительно.
ranger-debug: Указывает тип отладочного вывода для диапазонов.
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, максимальное количество раз, которое отдельная переменная будет расширена во время развёртывания цикла.
partial-inlining-entry-probability: Максимальная вероятность входа BB разделяемой области (в процентах относительно BB входа функции), чтобы сделать частичное встраивание.
max-tracked-strlens: Максимальное количество строк, для которых оптимизирующий проход strlen будет отслеживать длины строк.
gcse-after-reload-partial-fraction: Пороговое соотношение для выполнения частичного удаления избыточности после загрузки.
gcse-after-reload-critical-fraction: Пороговое соотношение числа выполнения критических ребер, которое позволяет выполнить удаление избыточности после загрузки.
max-loop-header-insns: Максимальное количество insn в заголовке цикла, дублированных проходом копирования заголовков циклов.
vect-epilogues-nomask: Включить векторизацию эпилога цикла с использованием меньшего размера вектора.
vect-partial-vector-usage: Управляет тем, когда векторизатор циклов рассматривает использование частичных векторизованных загрузок и сохранений как альтернативу возвращению к скалярному коду. 0 останавливает векторизатор от использования частичных векторизованных загрузок и сохранений. 1 разрешает частичные векторизованные загрузки и сохранения, если векторизация устраняет необходимость кода в итерации. 2 разрешает частичные векторизованные загрузки и сохранения во всех циклах. Параметр действует только на целевые платформы, которые поддерживают частичные векторизованные загрузки и сохранения.
vect-inner-loop-cost-factor: Максимальный коэффициент, который векторизатор циклов применяет к стоимости операторов во внутреннем цикле относительно векторизованного цикла. Применяемый коэффициент — это максимальное значение из оцениваемого количества итераций внутреннего цикла и этого параметра. Значение параметра по умолчанию — 50.
vect-induction-float: Включить векторизацию цикла для индуктивов с плавающей точкой.
vrp-sparse-threshold: Максимальное количество базовых блоков, прежде чем VRP использует кэш разреженной битовой карты.
vrp-switch-limit: Максимальное количество исходящих ребер в переключении, прежде чем VRP не обработает его.
vrp-vector-threshold: Максимальное количество базовых блоков, чтобы VRP использовал базовый векторный кэш.
avoid-fma-max-bits: Максимальное количество битов, для которых мы избегаем создания FMAs.
fully-pipelined-fma: Является ли целевая платформа полностью конвейерируемой для инструкций FMA. Если не равно нулю, перегруппировка рассматривает выгоду от распараллеливания части умножения FMA и части сложения FMA, предполагая, что FMUL и FMA используют те же блоки, которые также могут выполнять FADD.
sms-loop-average-count-threshold: Порог среднего числа итераций, которое учитывается планировщиком swing modulo.
sms-dfa-history: Количество циклов, которые планировщик swing modulo рассматривает при проверке конфликтов с использованием DFA.
graphite-allow-codegen-errors: Должны ли ошибки кодогенерации быть ICE, когда используется -fchecking.
sms-max-ii-factor: Коэффициент для настройки верхней границы, которую планировщик swing modulo использует для планирования цикла.
lra-max-considered-reload-pseudos: Максимальное число псевдонимов загрузки, которые учитываются при вытеснении псевдонима без загрузки.
max-pow-sqrt-depth: Максимальная глубина цепочек sqrt для использования при синтезе возведения в степень действительной константой.
max-dse-active-local-stores: Максимальное количество активных локальных сохранений в устранении мёртвых сохранений RTL.
asan-instrument-allocas: Включить защиту asan для allocas/VLAs.
max-iterations-computation-cost: Граница стоимости выражения для вычисления числа итераций.
max-isl-operations: Максимальное количество операций isl, 0 означает неограниченное.
graphite-max-arrays-per-scop: Максимальное количество массивов на scop.
max-vartrack-reverse-op-size: Максимальный размер списка loc, для которого должны быть добавлены обратные операции.
fsm-scale-path-stmts: Коэффициент масштабирования, применяемый к количеству операторов в пути потока, пересекающего обратное ребро цикла, при сравнении с --param=max-jump-thread-duplication-stmts.
uninit-control-dep-attempts: Максимальное количество вложенных вызовов для поиска зависимостей управления во время анализа неинициализированных переменных.
uninit-max-chain-len: Максимальное количество предикатов, связанных операцией `and`, для каждого предиката, объединённого операцией `or` в нормализованной цепи предикатов.
uninit-max-num-chains: Максимальное количество предикатов, объединённых операцией `or` в нормализованной цепи предикатов.
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: Максимальное количество взрывоопасных узлов «после суперузла» внутри анализатора на суперузел, перед завершением анализа.
analyzer-text-art-string-ellipsis-threshold: Количество байтов, при котором будут усечены строковые литералы в диаграммах анализатора.
analyzer-text-art-ideal-canvas-width: Идеальная ширина в символах текстовых диаграмм, генерируемых анализатором.
analyzer-text-art-string-ellipsis-head-len: Количество байтов литерала, которые необходимо показать в начале строкового литерала в текстовой диаграмме при усечении.
analyzer-text-art-string-ellipsis-tail-len: Количество байтов литерала, которые необходимо показать в конце строкового литерала в текстовой диаграмме при усечении.
ranger-logical-depth: Максимальная глубина вычисления логического выражения, которую будет просматривать диапазон, при оценке диапазонов исходящих ребер.
ranger-recompute-depth: Максимальная глубина цепочек инструкций для рассмотрения пересчёта в вычислителе исходящих диапазонов.
relation-block-limit: Максимальное количество отношений, которые зарегистрирует oracle в базовом блоке.
min-pagesize: Минимальный размер страницы для целей вывода предупреждений.
openacc-kernels

Укажите режим обработки конструкций OpenACC ‘kernels’. С помощью --param=openacc-kernels=decompose, конструкции OpenACC ‘kernels’ разбиваются на части, последовательность вычислительных конструкций, каждая из которых обрабатывается индивидуально. Эта функция находится в стадии разработки. С помощью --param=openacc-kernels=parloops, конструкции OpenACC ‘kernels’ обрабатываются проходом ‘parloops’ целиком. Это текущее значение по умолчанию.
openacc-privatization: Управляет тем, выводят ли опции -fopt-info-omp-note и соответствующие опции -fdump-tree-*-details диагностику приватизации OpenACC. С помощью --param=openacc-privatization=quiet, не выводить диагностику. Это текущее значение по умолчанию. С помощью --param=openacc-privatization=noisy, выводить диагностику.

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

aarch64-vect-compare-costs

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

Попытку использования как SVE, так и Advanced SIMD, когда SVE доступен.
Попытку использования 64-битных векторов Advanced SIMD для самых маленьких элементов данных вместо использования 128-битных векторов для всего.
Попытку использования «неупакованных» векторов SVE для более мелких элементов. Это включает хранение меньших элементов в более крупных контейнерах и доступ к элементам с помощью расширяющих загрузок и усекающих сохранений.

aarch64-float-recp-precision

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

aarch64-double-recp-precision

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

aarch64-autovec-preference

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

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

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

aarch64-ldp-policy

Политика тонкой настройки для пар загрузок. С помощью --param=aarch64-ldp-policy=default, используется политика структуры настройки. Это текущее значение по умолчанию. С помощью --param=aarch64-ldp-policy=always, генерируется ldp независимо от выравнивания. С помощью --param=aarch64-ldp-policy=never, не генерируется ldp. С помощью --param=aarch64-ldp-policy=aligned, генерируется ldp только если указатель источника выровнен по крайней мере вдвое больше, чем выравнивание типа.

aarch64-stp-policy

Политика тонкой настройки для пар сохранений. С помощью --param=aarch64-stp-policy=default, используется политика структуры настройки. Это текущее значение по умолчанию. С помощью --param=aarch64-stp-policy=always, генерируется stp независимо от выравнивания. С помощью --param=aarch64-stp-policy=never, не генерируется stp. С помощью --param=aarch64-stp-policy=aligned, генерируется stp только если указатель источника выровнен по крайней мере вдвое больше, чем выравнивание типа.

aarch64-ldp-alias-check-limit

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

aarch64-ldp-writeback

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

aarch64-loop-vect-issue-rate-niters

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

aarch64-vect-unroll-limit

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

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

gcn-preferred-vectorization-factor: Предпочтительный коэффициент векторизации: ‘default’, ‘32’, ‘64’.

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

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

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