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

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

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

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

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

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

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

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

-O

-O1

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

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

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

-fauto-inc-dec 
-fbranch-count-reg 
-fcombine-stack-adjustments 
-fcompare-elim 
-fcprop-registers 
-fdce 
-fdefer-pop 
-fdelayed-branch 
-fdse 
-fforward-propagate 
-fguess-branch-probability 
-fif-conversion2 
-fif-conversion 
-finline-functions-called-once 
-fipa-pure-const 
-fipa-profile 
-fipa-reference 
-fmerge-constants 
-fmove-loop-invariants 
-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-sink 
-ftree-slsr 
-ftree-sra 
-ftree-pta 
-ftree-ter 
-funit-at-a-time

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

-O2

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

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

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

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

-O3

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

-O0

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

-Os

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

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

-falign-functions  -falign-jumps  -falign-loops 
-falign-labels  -fprefetch-loop-arrays

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

-Ofast

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

-Og

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

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

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

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

-fno-defer-pop

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

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

-fforward-propagate

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

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

-ffp-contract=style

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

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

-fomit-frame-pointer

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

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

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

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

-foptimize-sibling-calls

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

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

-foptimize-strlen

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

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

-fno-inline

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

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

-finline-small-functions

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

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

-findirect-inlining

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

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

-finline-functions

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

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

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

-finline-functions-called-once

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

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

-fearly-inlining

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

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

-fipa-sra

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

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

-finline-limit=n

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

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

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

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

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

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

-fno-keep-inline-dllexport

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

-fkeep-inline-functions

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

-fkeep-static-functions

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

-fkeep-static-consts

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

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

-fmerge-constants

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

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

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

-fmerge-all-constants

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

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

-fmodulo-sched

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

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

-fno-function-cse

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

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

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

-fno-zero-initialized-in-bss

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

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

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

-fthread-jumps

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

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

-fsplit-wide-types

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

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

-fcse-follow-jumps

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

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

-fcse-skip-blocks

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

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

-frerun-cse-after-loop

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

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

-fgcse

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

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

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

-fgcse-lm

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

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

-fgcse-sm

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

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

-fgcse-las

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

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

-fgcse-after-reload

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

-faggressive-loop-optimizations

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

-funconstrained-commons

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

-fcrossjumping

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

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

-fauto-inc-dec

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

-fdce

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

-fdse

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

-fif-conversion

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

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

-fif-conversion2

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

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

-fdeclone-ctor-dtor

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

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

-fdelete-null-pointer-checks

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

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

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

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

-fdevirtualize

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

-fdevirtualize-speculatively

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

-fdevirtualize-at-ltrans

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

-fexpensive-optimizations

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

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

-free

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

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

-fno-lifetime-dse

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

-flive-range-shrinkage

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

-fira-algorithm=algorithm

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

-fira-region=region

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

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

-fira-hoist-pressure

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

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

-fira-loop-pressure

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

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

-fno-ira-share-save-slots

-fno-ira-share-spill-slots

-flra-remat

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

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

-fdelayed-branch

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

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

-fschedule-insns

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

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

-fschedule-insns2

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

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

-fno-sched-interblock

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

-fno-sched-spec

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

-fsched-pressure

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

-fsched-spec-load

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

-fsched-spec-load-dangerous

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

-fsched-stalled-insns

-fsched-stalled-insns=n

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

-fsched-stalled-insns-dep

-fsched-stalled-insns-dep=n

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

-fsched2-use-superblocks

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

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

-fsched-group-heuristic

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

-fsched-critical-path-heuristic

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

-fsched-spec-insn-heuristic

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

-fsched-rank-heuristic

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

-fsched-last-insn-heuristic

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

-fsched-dep-count-heuristic

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

-freschedule-modulo-scheduled-loops

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

-fselective-scheduling

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

-fselective-scheduling2

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

-fsel-sched-pipelining

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

-fsel-sched-pipelining-outer-loops

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

-fsemantic-interposition

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

-fshrink-wrap

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

-fshrink-wrap-separate

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

-fcaller-saves

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

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

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

-fcombine-stack-adjustments

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

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

-fipa-ra

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

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

-fconserve-stack

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

-ftree-reassoc

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

-fcode-hoisting

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

-ftree-pre

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

-ftree-partial-pre

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

-ftree-forwprop

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

-ftree-fre

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

-ftree-phiprop

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

-fhoist-adjacent-loads

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

-ftree-copy-prop

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

-fipa-pure-const

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

-fipa-reference

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

-fipa-pta

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

-fipa-profile

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

-fipa-cp

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

-fipa-cp-clone

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

-fipa-bit-cp

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

-fipa-vrp

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

-fipa-icf

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

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

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

-fisolate-erroneous-paths-dereference

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

-fisolate-erroneous-paths-attribute

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

-ftree-sink

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

-ftree-bit-ccp

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

-ftree-ccp

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

-fssa-backprop

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

-fssa-phiopt

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

-ftree-switch-conversion

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

-ftree-tail-merge

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

-ftree-dce

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

-ftree-builtin-call-dce

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

-ftree-dominator-opts

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

-ftree-dse

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

-ftree-ch

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

-ftree-loop-optimize

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

-ftree-loop-linear

-floop-interchange

-floop-strip-mine

-floop-block

-floop-unroll-and-jam

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

-fgraphite-identity

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

-floop-nest-optimize

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

-floop-parallelize-all

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

-ftree-coalesce-vars

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

-ftree-loop-if-convert

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

-ftree-loop-distribution

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

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

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

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

-ftree-loop-distribute-patterns

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

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

-ftree-loop-im

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

-ftree-loop-ivcanon

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

-fivopts

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

-ftree-parallelize-loops=n

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

-ftree-pta

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

-ftree-sra

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

-fstore-merging

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

-ftree-ter

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

-ftree-slsr

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

-ftree-vectorize

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

-ftree-loop-vectorize

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

-ftree-slp-vectorize

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

-fvect-cost-model=model

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

-fsimd-cost-model=model

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

-ftree-vrp

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

-fsplit-paths

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

-fsplit-ivs-in-unroller

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

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

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

-fvariable-expansion-in-unroller

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

-fpartial-inlining

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

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

-fpredictive-commoning

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

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

-fprefetch-loop-arrays

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

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

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

-fno-printf-return-value

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

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

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

-fno-peephole

-fno-peephole2

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

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

-fno-guess-branch-probability

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

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

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

-freorder-blocks

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

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

-freorder-blocks-algorithm=algorithm

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

По умолчанию ‘simple’ на уровнях -O, -Os, и ‘stc’ на уровнях -O2, -O3.

-freorder-blocks-and-partition

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

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

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

-freorder-functions

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

Также для эффективности этого параметра требуется доступ к обратной связи профилирования. См. -fprofile-arcs для подробностей.

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

-fstrict-overflow

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

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

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

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

-falign-functions

-falign-functions=n

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

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

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

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

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

-flimit-function-alignment

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

-falign-labels

-falign-labels=n

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

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

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

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

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

-falign-loops

-falign-loops=n

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

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

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

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

-falign-jumps

-falign-jumps=n

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

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

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

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

-funit-at-a-time

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

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

-fno-toplevel-reorder

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

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

-fweb

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

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

-fwhole-program

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

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

-flto[=n]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-flto-partition=alg

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

-flto-odr-type-merging

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

-flto-compression-level=n

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

-fuse-linker-plugin

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

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

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

-ffat-lto-objects

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

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

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

-fcompare-elim

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

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

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

-fcprop-registers

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

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

-fprofile-correction

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

-fprofile-use

-fprofile-use=path

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

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

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

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

-fauto-profile

-fauto-profile=path

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

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

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

Например:

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

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

Например:

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

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

-ffloat-store

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

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

-fexcess-precision=style

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

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

-ffast-math

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

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

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

-fno-math-errno

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

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

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

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

-funsafe-math-optimizations

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

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

-fassociative-math

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

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

-freciprocal-math

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

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

-ffinite-math-only

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

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

-fno-signed-zeros

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

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

-fno-trapping-math

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

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

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

-frounding-math

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

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

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

-fsignaling-nans

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

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

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

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

-fno-fp-int-builtin-inexact

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

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

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

-fsingle-precision-constant

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

-fcx-limited-range

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

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

-fcx-fortran-rules

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

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

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

-fbranch-probabilities

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

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

-fprofile-values

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

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

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

-fprofile-reorder-functions

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

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

-fvpt

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

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

-frename-registers

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

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

-fschedule-fusion

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

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

-ftracer

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

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

-funroll-loops

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

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

-funroll-all-loops

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

-funroll-all-loops подразумевает те же параметры, что и -funroll-loops.

-fpeel-loops

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

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

-fmove-loop-invariants

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

-fsplit-loops

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

-funswitch-loops

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

-ffunction-sections

-fdata-sections

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

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

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

-fbranch-target-load-optimize

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

-fbranch-target-load-optimize2

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

-fbtr-bb-exclusive

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

-fstdarg-opt

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

-fsection-anchors

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

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

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

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

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

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

--param name=value

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

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

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

END_OF_DOCUMENT_MARKER

predictable-branch-outcome

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

max-rtl-if-conversion-insns

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

max-rtl-if-conversion-predictable-cost

max-rtl-if-conversion-unpredictable-cost

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

max-crossjump-edges

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

min-crossjump-insns

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

max-grow-copy-bb-insns

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

max-goto-duplication-insns

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

max-delay-slot-insn-search

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

max-delay-slot-live-search

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

max-gcse-memory

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

max-gcse-insertion-ratio

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

max-pending-list-length

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

max-modulo-backtrack-attempts

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

max-inline-insns-single

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

max-inline-insns-auto

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

inline-min-speedup

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

large-function-insns

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

large-function-growth

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

large-unit-insns

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

inline-unit-growth

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

ipcp-unit-growth

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

large-stack-frame

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

large-stack-frame-growth

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

max-inline-insns-recursive

max-inline-insns-recursive-auto

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

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

max-inline-recursive-depth

max-inline-recursive-depth-auto

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

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

min-inline-recursive-probability

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

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

early-inlining-insns

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

max-early-inliner-iterations

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

comdat-sharing-probability

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

profile-func-internal-id

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

min-vect-loop-bound

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

gcse-cost-distance-ratio

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

gcse-unrestricted-cost

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

max-hoist-depth

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

max-tail-merge-comparisons

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

max-tail-merge-iterations

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

store-merging-allow-unaligned

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

max-stores-to-merge

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

max-unrolled-insns

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

max-average-unrolled-insns

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

max-unroll-times

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

max-peeled-insns

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

max-peel-times

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

max-peel-branches

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

max-completely-peeled-insns

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

max-completely-peel-times

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

max-completely-peel-loop-nest-depth

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

max-unswitch-insns

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

max-unswitch-level

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

max-loop-headers-insns

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

lim-expensive

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

iv-consider-all-candidates-bound

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

iv-max-considered-uses

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

iv-always-prune-cand-set-bound

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

avg-loop-niter

Среднее количество итераций цикла.

dse-max-object-size

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

scev-max-expr-size

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

scev-max-expr-complexity

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

max-tree-if-conversion-phi-args

Максимальное количество аргументов в PHI, поддерживаемом TREE при преобразовании, если цикл не помечен пragma simd.

vect-max-version-for-alignment-checks

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

vect-max-version-for-alias-checks

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

vect-max-peeling-for-alignment

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

max-iterations-to-track

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

hot-bb-count-ws-permille

Счётчик профиля базового блока считается горячим, если он вносит вклад в указанную промилию (т. е. 0...1000) всего профилированного выполнения.

hot-bb-frequency-fraction

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

max-predicted-iterations

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

builtin-expect-probability

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

align-threshold

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

align-loop-iterations

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

tracer-dynamic-coverage

tracer-dynamic-coverage-feedback

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

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

tracer-max-code-growth

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

tracer-min-branch-ratio

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

tracer-min-branch-probability

tracer-min-branch-probability-feedback

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

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

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

max-cse-path-length

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

max-cse-insns

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

ggc-min-expand

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

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

ggc-min-heapsize

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

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

max-reload-search-insns

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

max-cselib-memory-locations

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

max-sched-ready-insns

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

max-sched-region-blocks

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

max-pipeline-region-blocks

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

max-sched-region-insns

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

max-pipeline-region-insns

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

min-spec-prob

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

max-sched-extend-regions-iters

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

max-sched-insn-conflict-delay

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

sched-spec-prob-cutoff

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

sched-state-edge-prob-cutoff

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

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

ipa-cp-recursion-penalty

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

ipa-cp-single-call-penalty

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

ipa-max-agg-items

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

ipa-cp-loop-hint-bonus

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

ipa-cp-array-index-hint-bonus

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

ipa-max-aa-steps

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

lto-partitions

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

lto-min-partition

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

lto-max-partition

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

cxx-max-namespaces-for-diagnostic-help

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

sink-frequency-threshold

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

max-stores-to-sink

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

allow-store-data-races

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

case-values-threshold

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

tree-reassoc-width

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

sched-pressure-algorithm

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

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

max-slsr-cand-scan

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

asan-globals

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

asan-stack

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

asan-instrument-reads

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

asan-instrument-writes

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

asan-memintrin

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

asan-use-after-return

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

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

asan-instrumentation-with-call-threshold

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

use-after-scope-direct-emission-threshold

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

chkp-max-ctor-size

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

max-fsm-thread-path-insns

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

max-fsm-thread-length

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

max-fsm-thread-paths

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

parloops-chunk-size

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

parloops-schedule

Тип планирования omp schedule для циклов, распараллеленных с помощью parloops (статический, динамический, управляемый, автоматический, во время выполнения). По умолчанию статический.

max-ssa-name-query-depth

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

hsa-gen-debug-stores

Включить выпуск специальных дебажных сохранений внутри ядер HSA, которые затем считываются и сообщаются плагином libgomp. Генерация этих сохранений отключена по умолчанию, используйте --param hsa-gen-debug-stores=1, чтобы включить её.

max-speculative-devirt-maydefs

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

max-vrp-switch-assertions

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

Далее: Параметры инструментов, Предыдущее: Параметры отладки, Выше: Вызов GCC [Содержание][Индекс]

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