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

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

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

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

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

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

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

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

-O

-O1

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

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

-O — рекомендуемый уровень оптимизации для большого объёма кода, созданного автоматически: он обеспечивает разумный баланс между временем компиляции и использованием памяти. На более высоких уровнях оптимизации выполняются оптимизации с более высокой алгоритмической сложностью, чем при -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
-fivopts
-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-crc
-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

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

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

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

-fno-defer-pop

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

-fforward-propagate

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

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

-favoid-store-forwarding

-fno-avoid-store-forwarding

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

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

-ffp-contract=style

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

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

-fomit-frame-pointer

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

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

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

Включён по умолчанию начиная с -O1.

-foptimize-crc

Обнаруживает циклы, вычисляющие CRC (выполняющие полиномиальное деление столбиком), и заменяет их более быстрой реализацией. Обнаруживает CRC шириной 8, 16, 32 и 64 бита с постоянным полиномом без старшего бита 1 как для прямого, так и для обратного порядка битов. Если целевая платформа поддерживает инструкцию CRC, а полином в исходном коде совпадает с полиномом, используемым этой инструкцией, генерируется инструкция CRC. В противном случае, если целевая платформа поддерживает инструкцию умножения без переноса, CRC генерируется с её помощью; иначе генерируется CRC на основе таблицы.

Включён по умолчанию начиная с -O2.

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

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

-fmodulo-sched-allow-regmoves

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

-fno-branch-count-reg

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

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

-fno-function-cse

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

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

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

-fno-zero-initialized-in-bss

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

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

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

-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

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

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

-fauto-inc-dec

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

-fdce

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

-fdse

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

-fif-conversion

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

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

-fif-conversion2

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

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

-fdeclone-ctor-dtor

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

Включён параметром -Os.

-fdelete-null-pointer-checks

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

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

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

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

-fdevirtualize

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

-fdevirtualize-speculatively

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

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

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

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

-fdelayed-branch

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

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

-fschedule-insns

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

Обычно включён на уровнях оптимизации -O2 и -O3. Однако на многих целевых платформах это поведение переопределено. Например, на x86 параметр отключён на всех уровнях, а на AArch64 включён только на уровне -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 компилятор предполагает, что при подмене функций заменяющая функция будет иметь в точности ту же семантику (и побочные эффекты). Аналогично, при подмене переменных конструктор переменной будет тем же. Флаг не влияет на функции, явно объявленные встроенными (для них подмена, меняющая семантику, в любом случае не допускается), и на символы, явно объявленные слабыми.

-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

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

-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-reorder-for-locality

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

-fipa-stack-alignment

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

-fipa-pta

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

-fipa-profile

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

-fipa-modref

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

-fipa-cp

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

-fipa-cp-clone

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

-fipa-bit-cp

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

-fipa-vrp

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

-fipa-icf

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

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

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

-flate-combine-instructions

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

На большинстве целевых платформ этот флаг включен по умолчанию при -O2 и -Os.

-flive-patching=level

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

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

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

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

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

‘inline-clone’

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

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

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

‘inline-only-static’

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

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

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

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

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

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

-fisolate-erroneous-paths-dereference

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

-fisolate-erroneous-paths-attribute

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

-ftree-sink

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

-ftree-bit-ccp

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

-ftree-ccp

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

-fssa-backprop

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

-fssa-phiopt

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

-ftree-switch-conversion

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

-ftree-tail-merge

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

-ftree-cselim

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

-ftree-dce

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

-ftree-builtin-call-dce

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

-ffinite-loops

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

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

-ftree-dominator-opts

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

-ftree-dse

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

-ftree-ch

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

-ftree-loop-optimize

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

-ftree-loop-linear

-floop-strip-mine

-floop-block

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

-fgraphite-identity

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

-floop-nest-optimize

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

-floop-parallelize-all

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

-ftree-coalesce-vars

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

-ftree-loop-if-convert

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

-ftree-loop-distribution

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

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

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

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

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

-ftree-loop-distribute-patterns

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

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

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

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

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

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

-floop-interchange

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

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

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

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

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

-floop-unroll-and-jam

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

-ftree-loop-im

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

-ftree-loop-ivcanon

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

-ftree-scev-cprop

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

-fivopts

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

-ftree-parallelize-loops=n

Распараллеливать циклы, то есть делить пространство их итераций для выполнения в n потоках. Это возможно только для циклов с независимыми итерациями, порядок которых можно произвольно менять. Оптимизация выгодна только на многопроцессорных машинах и для циклов с высокой загрузкой ЦП, а не для циклов, ограниченных, например, пропускной способностью памяти. Этот параметр подразумевает -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» отключает векторизацию циклов при необходимости любых проверок зависимости данных или выравнивания во время выполнения, а также отключает векторизацию завершающих циклов; в остальном она эквивалентна модели «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 и если i — целое число размером 32 бита или меньше, можно оптимизировать ветвление и тело оператора if (но не вызов snprint), поскольку гарантируется, что возвращаемое значение не превышает 8.

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

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

-fno-peephole

-fno-peephole2

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

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

-fno-guess-branch-probability

Не угадывать вероятности переходов с помощью эвристик.

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

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

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

-freorder-blocks

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

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

-freorder-blocks-algorithm=algorithm

Использовать указанный алгоритм переупорядочивания базовых блоков. Аргумент algorithm может быть равен «simple»: этот алгоритм не увеличивает размер кода (кроме случаев, когда это происходит вследствие вторичных эффектов, например выравнивания); либо «stc» — алгоритм «software trace cache», который стремится сгруппировать часто выполняемый код, сокращая число выполняемых переходов за счет создания дополнительных копий кода.

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

-freorder-blocks-and-partition

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

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

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

-freorder-functions

Переупорядочивать функции в объектном файле, чтобы повысить локальность кода. В отличие от -fipa-reorder-for-locality, этот параметр отдает приоритет группировке всех функций одной категории (горячие/обычные/холодные/не выполняющиеся) вместе. Это реализуется с помощью специальных подсекций .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;
}

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

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

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

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

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

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

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

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

-fmin-function-alignment

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

-fno-allocation-dce

Не удалять неиспользуемые выделения памяти в C++ (с помощью оператора new и оператора delete) при удалении мертвого кода.

См. также -fmalloc-dce.

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

Как правило, параметры, указанные при компоновке, переопределяют параметры, заданные при компиляции, хотя в некоторых случаях 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’ создаёт новый раздел для каждого символа, если это возможно; ‘cache’ балансирует размеры частей, сохраняя связанные символы вместе для улучшения кэширования при инкрементальной LTO. Значение ‘none’ отключает разбиение и потоковую обработку. Значение по умолчанию — ‘balanced’. Хотя ‘1to1’ можно использовать как обходной путь при различных проблемах с порядком кода, разбиение ‘max’ предназначено только для внутреннего тестирования. Значение ‘one’ указывает, что следует использовать ровно один раздел, а значение ‘none’ отключает разбиение и выполняет этап оптимизации на этапе компоновки непосредственно из фазы WPA.

-flto-incremental=path

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

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

Несколько экземпляров GCC могут параллельно использовать один и тот же кэш.

-flto-incremental-cache-size=n

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

-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 без Fat файлы make необходимо изменить так, чтобы они использовали эти обёртки.

Обратите внимание, что современные 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

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

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

Если указано значение path, 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

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

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

Например:

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

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

Например:

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

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

-fexcess-precision=style

Эта опция позволяет управлять избыточной точностью на машинах, где операции с плавающей запятой выполняются в формате с большей точностью или диапазоном, чем стандартные и обменные типы с плавающей запятой IEEE. Примером такой цели является число с плавающей запятой x87 на процессорах x86, в котором внутренне используется 80-битное представление вместо 64-битного формата IEEE. Для большинства программ избыточная точность безвредна, но некоторые программы могут полагаться на требования стандартов языков C или C++ при обработке значений 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 без избыточной точности, а во втором округление непредсказуемо.

-ffloat-store

Не сохранять переменные с плавающей запятой в регистрах и отключать другие опции, которые могут изменить способ получения значения с плавающей запятой из регистра или памяти. Эта опция в целом была заменена на -fexcess-precision=standard, которая является более универсальной. Если вы все же используете -ffloat-store, вам может потребоваться изменить программу так, чтобы явно сохранять промежуточные вычисления во временных переменных, поскольку -ffloat-store выполняет округление до формата IEEE только при присваиваниях, а не при приведении типов, как это делает -fexcess-precision=standard.

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

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

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

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

Значение по умолчанию — -ftrapping-math.

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

-frounding-math

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

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

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

-fsignaling-nans

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

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

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

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

-fno-fp-int-builtin-inexact

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

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

Даже если используется -fno-fp-int-builtin-inexact, если функции генерируют вызов функции библиотеки, исключение «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, чтобы улучшить оптимизацию на основе количества срабатываний каждой ветвления (branch). Когда программа, скомпилированная с -fprofile-arcs, завершает работу, она сохраняет счетчики выполнения дуг (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

Переупорядочивание функций на основе профильного инструментирования собирает время первого выполнения функции и упорядочивает эти функции по возрастанию с целью оптимизации запуска программы за счет более эффективной загрузки сегментов кода (text segments).

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

-fvpt

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

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

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

-frename-registers

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

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

-fschedule-fusion

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

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

-ftracer

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

Включается опциями -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

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

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

-fmalloc-dce

Управляет тем, могут ли malloc (и её варианты, такие как calloc или strdup) быть оптимизированы и удалены, при условии, что её возвращаемое значение используется только в качестве параметра вызова free или сравнивается с NULL. Если используется -fmalloc-dce=1, разрешены только вызовы free, в то время как при -fmalloc-dce=2 сравнения с указателем NULL также считаются безопасными для удаления.

Значение по умолчанию — -fmalloc-dce=2. См. также -fallocation-dce.

-fmove-loop-invariants

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

-fmove-loop-stores

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

-fsplit-loops

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

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

-funswitch-loops

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

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

-fversion-loops-for-strides

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

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] = …;

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

-ffunction-sections

-fdata-sections

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

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

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

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

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

-fstdarg-opt

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

-fsection-anchors

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

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

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

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

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

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

-fzero-call-used-regs=choice

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

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

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

--param name=value

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

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

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

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

phiopt-factor-max-stmts-live

При вынесении операторов из if/then/else это максимальное число операторов после определяющего оператора, на которое разрешено продлить время жизни имени.

predictable-branch-outcome

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

max-rtl-if-conversion-insns

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

file-cache-files

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

file-cache-lines

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

max-rtl-if-conversion-predictable-cost

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

max-crossjump-edges

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

min-crossjump-insns

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

max-grow-copy-bb-insns

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

max-goto-duplication-insns

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

max-delay-slot-insn-search

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

max-delay-slot-live-search

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

max-gcse-memory

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

max-gcse-insertion-ratio

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

max-pending-list-length

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

max-modulo-backtrack-attempts

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

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

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

max-inline-functions-called-once-insns

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

max-inline-insns-single

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

max-inline-insns-auto

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

max-inline-insns-small

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

max-inline-insns-size

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

uninlined-function-insns

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

uninlined-function-time

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

inline-heuristics-hint-percent

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

uninlined-thunk-insns

uninlined-thunk-time

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

inline-min-speedup

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

large-function-insns

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

large-function-growth

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

large-unit-insns

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

lazy-modules

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

inline-unit-growth

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

ipa-cp-unit-growth

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

ipa-cp-large-unit-insns

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

large-stack-frame

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

large-stack-frame-growth

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

max-inline-insns-recursive

max-inline-insns-recursive-auto

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

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

max-inline-recursive-depth

max-inline-recursive-depth-auto

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

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

min-inline-recursive-probability

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

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

early-inlining-insns

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

max-early-inliner-iterations

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

comdat-sharing-probability

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

modref-max-bases

modref-max-refs

modref-max-accesses

Задаёт максимальное число базовых указателей, ссылок и обращений, сохраняемых анализом mod/ref для одной функции.

modref-max-tests

Задаёт максимальное число проверок, которые может выполнить анализатор алиасов, чтобы различить адреса памяти с использованием информации mod/ref. Этот параметр должен быть больше, чем --param modref-max-bases и --param modref-max-refs.

modref-max-depth

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

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

max-tail-merge-iterations

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

store-merging-allow-unaligned

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

max-stores-to-merge

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

max-store-chains-to-track

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

max-stores-to-track

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

max-unrolled-insns

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

max-average-unrolled-insns

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

max-unroll-times

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

max-peeled-insns

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

max-peel-times

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

max-peel-branches

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

max-completely-peeled-insns

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

max-completely-peel-times

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

max-completely-peel-loop-nest-depth

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

max-unswitch-insns

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

max-unswitch-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

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

scev-max-expr-size

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

scev-max-expr-complexity

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

max-tree-if-conversion-phi-args

Максимальное число аргументов PHI, поддерживаемых преобразованием if-conversion для 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.

stack-clash-protection-probe-interval

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

max-cse-path-length

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

max-cse-insns

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

ggc-min-expand

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

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

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

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

max-last-value-rtl

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

max-combine-insns

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

max-combine-search-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 отказывается создавать массивы, размер которых превышает число ветвей switch, умноженное на switch-conversion-max-branch-ratio.

switch-lower-slow-alg-max-cases

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

max-partial-antic-length

Максимальная длина частичного множества antic, вычисляемого при оптимизации частичного устранения избыточности в дереве (-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 уделять большое внимание ограничению на совпадение (номер дублированного операнда) во всех доступных альтернативах для предпочтительного класса регистров. Если задано значение 0, IRA учитывает ограничение на совпадение, только когда оно присутствует в единственной доступной альтернативе с подходящим классом регистров. В противном случае IRA проверяет все доступные альтернативы для предпочтительного класса регистров, даже если уже найден вариант с подходящим классом регистров, и учитывает найденное подходящее ограничение на совпадение.

ira-simple-lra-insn-threshold

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

lra-inheritance-ebb-probability-cutoff

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

loop-invariant-max-bbs-in-loop

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

loop-max-datarefs-for-datadeps

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

max-vartrack-size

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

max-vartrack-expr-depth

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

max-debug-marker-count

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

min-nondebug-insn-uid

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

ipa-sra-deref-prob-threshold

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

ipa-sra-ptr-growth-factor

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

ipa-sra-ptrwrap-growth-factor

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

ipa-sra-max-replacements

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

sra-max-scalarization-size-Ospeed

sra-max-scalarization-size-Osize

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

sra-max-propagations

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

tm-max-aggregate-size

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

graphite-max-nb-scop-params

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

hardcfr-max-blocks

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

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

ipa-max-param-expr-ops

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

lto-partitions

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

lto-min-partition

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

lto-max-partition

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

lto-partition-locality-frequency-cutoff

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

lto-partition-locality-size-cutoff

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

lto-max-locality-partition

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

lto-max-streaming-parallelism

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

cxx-max-namespaces-for-diagnostic-help

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

sink-frequency-threshold

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

max-stores-to-sink

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

case-values-threshold

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

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

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

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

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

tree-reassoc-width

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

sched-pressure-algorithm

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

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

max-slsr-cand-scan

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

asan-globals

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

asan-stack

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

asan-instrument-reads

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

asan-instrument-writes

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

asan-memintrin

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

asan-use-after-return

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

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

asan-instrumentation-with-call-threshold

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

asan-kernel-mem-intrinsic-prefix

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

hwasan-instrument-stack

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

hwasan-random-frame-tag

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

hwasan-instrument-allocas

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

hwasan-instrument-reads

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

hwasan-instrument-writes

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

hwasan-instrument-mem-intrinsics

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

use-after-scope-direct-emission-threshold

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

tsan-distinguish-volatile

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

tsan-instrument-func-entry-exit

Выдавать вызовы инструментирования __tsan_func_entry() и __tsan_func_exit().

max-fsm-thread-path-insns

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

threader-debug

threader-debug=[none|all] включает подробный вывод отладочной информации решателя протягивания переходов.

parloops-chunk-size

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

parloops-schedule

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

parloops-min-per-thread

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

max-ssa-name-query-depth

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

max-speculative-devirt-maydefs

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

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

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

max-tracked-strlens

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

gcse-after-reload-partial-fraction

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

gcse-after-reload-critical-fraction

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

max-loop-header-insns

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

vect-epilogues-nomask

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

vect-partial-vector-usage: Управляет тем, когда векторизатор циклов рассматривает частичные векторные загрузки и сохранения как альтернативу переходу к скалярному коду. Значение 0 запрещает векторизатору использовать частичные векторные загрузки и сохранения. Значение 1 разрешает их, если векторизация устраняет необходимость итераций кода. Значение 2 разрешает частичные векторные загрузки и сохранения во всех циклах. Параметр действует только на целевых платформах, поддерживающих частичные векторные загрузки и сохранения.
vect-inner-loop-cost-factor: Максимальный множитель, применяемый векторизатором циклов к стоимости операторов во внутреннем цикле относительно цикла, который векторизуется. Применяемый множитель равен максимуму из оценочного числа итераций внутреннего цикла и значения этого параметра. Значение параметра по умолчанию — 50.
vect-induction-float: Включить векторизацию циклов с индукционными переменными с плавающей точкой.
vect-force-slp: Принудительно использовать SLP при векторизации; завершить работу с ошибкой, если это невозможно.
vrp-block-limit: Максимальное число базовых блоков, при превышении которого VRP переключается на алгоритм с меньшими требованиями к памяти.
vrp-sparse-threshold: Максимальное число базовых блоков, при превышении которого VRP использует разреженный кэш растрового изображения.
vrp-switch-limit: Максимальное число исходящих рёбер в операторе switch, при превышении которого VRP не обрабатывает этот оператор.
vrp-vector-threshold: Максимальное число базовых блоков, при котором VRP использует базовый кэш-вектор.
avoid-fma-max-bits: Максимальное число бит, для которого мы не создаём FMA.
fully-pipelined-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: Включить защиту alloca/VLA в ASan.
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 в нормализованной цепочке предикатов.
uninit-max-prune-work: Максимальный объём работы по отсечению путей, на которых переменная всегда инициализирована.
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: Максимальный размер в байтах одной области объединения операций сохранения.
store-forwarding-max-distance: Максимальное расстояние в инструкциях, на которое пересылка данных из небольшого сохранения в более широкую загрузку может вызвать задержку. Значение ’0’ отключает проверки стоимости для прохода по предотвращению пересылки данных из сохранения.
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 просматривает при вычислении диапазонов исходящих рёбер.
ranger-recompute-depth: Максимальная глубина цепочек инструкций, рассматриваемых для повторного вычисления в калькуляторе диапазонов исходящих рёбер.
relation-block-limit: Максимальное число отношений, регистрируемых oracle в базовом блоке.
transitive-relations-work-bound: Ограничение объёма работы при обнаружении транзитивных отношений на основе существующих отношений.
min-pagesize: Минимальный размер страницы для векторизации с предупреждениями и досрочным завершением.
openacc-kernels: Задать режим обработки конструкций OpenACC ‘kernels’. При использовании --param=openacc-kernels=decompose конструкции OpenACC ‘kernels’ разбиваются на части — последовательность вычислительных конструкций, каждая из которых затем обрабатывается отдельно. Работа над этим режимом продолжается. При использовании --param=openacc-kernels=parloops конструкции OpenACC ‘kernels’ обрабатываются проходом ‘parloops’ целиком. Это текущий режим по умолчанию.
openacc-privatization: Управлять выдачей диагностических сообщений о приватизации OpenACC параметрами -fopt-info-omp-note и соответствующими параметрами -fdump-tree-*-details. При использовании --param=openacc-privatization=quiet диагностика не выдаётся. Это текущий режим по умолчанию. При использовании --param=openacc-privatization=noisy диагностика выдаётся.
cycle-accurate-model: Указывает, следует ли GCC предполагать, что описание планирования в основном представляет собой модель целевого процессора с точностью до такта, на котором должен выполняться код, при отсутствии промахов кэша. Ненулевое значение означает, что выбранная модель планирования точна и, вероятно, описывает процессор с последовательным выполнением команд, а также что при планировании следует активно использовать пролив, чтобы по возможности заполнить паузы в конвейере. Это текущее значение по умолчанию. Нулевое значение означает, что описание планирования может быть недоступно, неточным или вовсе неприменимым, например для современных процессоров с внеочередным выполнением команд.

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

aarch64-vect-compare-costs

При векторизации рассматривать несколько различных подходов и выбирать наиболее дешёвый с помощью модели стоимости. В частности:

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

aarch64-float-recp-precision

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

aarch64-double-recp-precision

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

aarch64-autovec-preference

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

‘default’: Использовать эвристики по умолчанию.
‘asimd-only’: Использовать для автоматической векторизации только Advanced SIMD.
‘sve-only’: Использовать для автоматической векторизации только SVE.
‘prefer-asimd’: Использовать Advanced SIMD и SVE. При равной стоимости отдавать предпочтение Advanced SIMD.
‘prefer-sve’: Использовать Advanced SIMD и SVE. При равной стоимости отдавать предпочтение SVE.

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

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

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

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

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

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-15.3.0/gcc/Optimize-Options.html