Spec-Zone.ru › GCC 4

3.10 Параметры, контролирующие оптимизацию

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

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

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

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

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

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

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

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

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

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

-fauto-inc-dec 
-fcompare-elim 
-fcprop-registers 
-fdce 
-fdefer-pop 
-fdelayed-branch 
-fdse 
-fguess-branch-probability 
-fif-conversion2 
-fif-conversion 
-fipa-pure-const 
-fipa-profile 
-fipa-reference 
-fmerge-constants
-fsplit-wide-types 
-ftree-bit-ccp 
-ftree-builtin-call-dce 
-ftree-ccp 
-ftree-ch 
-ftree-copyrename 
-ftree-dce 
-ftree-dominator-opts 
-ftree-dse 
-ftree-forwprop 
-ftree-fre 
-ftree-phiprop 
-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-sra 
-fisolate-erroneous-paths-dereference 
-foptimize-sibling-calls 
-fpartial-inlining 
-fpeephole2 
-freorder-blocks  -freorder-functions 
-frerun-cse-after-loop  
-fsched-interblock  -fsched-spec 
-fschedule-insns  -fschedule-insns2 
-fstrict-aliasing -fstrict-overflow 
-ftree-switch-conversion -ftree-tail-merge 
-ftree-pre 
-ftree-vrp

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

-O3
Оптимизировать ещё сильнее. -O3 включает все оптимизации, указанные в -O2, а также включает параметры -finline-functions, -funswitch-loops, -fpredictive-commoning, -fgcse-after-reload, -ftree-loop-vectorize, -ftree-slp-vectorize, -fvect-cost-model, -ftree-partial-pre и -fipa-cp-clone.
-O0
Сокращение времени компиляции и обеспечение того, чтобы отладка давала ожидаемые результаты. Это значение по умолчанию.
-Os
Оптимизировать под размер. -Os включает все -O2 оптимизации, которые обычно не увеличивают размер кода. Он также выполняет дополнительные оптимизации, направленные на уменьшение размера кода.

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

-falign-functions  -falign-jumps  -falign-loops 
-falign-labels  -freorder-blocks  -freorder-blocks-and-partition 
-fprefetch-loop-arrays
-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 управляет тем, поддерживает ли целевая машина этот флаг. См. Использование регистров.

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

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

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

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

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

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

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

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

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

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

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

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

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

-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++, генерировать все объявленные inline функции в объектный файл.
-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.

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

Примечание: При компиляции программы с использованием вычисленных переходов, расширения 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
Этот параметр сообщает оптимизатору циклов использовать ограничения языка для определения границ числа итераций цикла. Предполагается, что код цикла не вызывает неопределенное поведение, например, вызывая переполнение целых чисел со знаком или доступ к массивам за пределами границ. Границы числа итераций цикла используются для управления оптимизацией развертывания циклов, срезанием и оптимизацией проверки выхода из цикла. Этот параметр включен по умолчанию.
-funsafe-loop-optimizations
Этот параметр сообщает оптимизатору циклов, что предполагает, что индексы циклов не переполняются, и что циклы с нетривиальным условием выхода не бесконечны. Это позволяет оптимизировать более широкий класс циклов, даже если сам оптимизатор циклов не может доказать, что эти предположения верны. Если вы используете -Wunsafe-loop-optimizations, компилятор предупреждает вас, если находит такой цикл.
-fcrossjumping
Выполняется преобразование переходов через переходы. Это преобразование унифицирует эквивалентный код и сохраняет размер кода. Полученный код может быть лучше или хуже, чем без преобразования переходов через переходы.

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

-fauto-inc-dec
Объединение инкрементов или декрементов адресов с обращениями к памяти. Этот проход всегда пропускается на архитектурах, не поддерживающих такие инструкции. Включено по умолчанию на уровнях -O и выше на архитектурах, которые поддерживают это.
-fdce
Выполнение устранения неиспользуемого кода (DCE) на RTL. Включено по умолчанию на уровнях -O и выше.
-fdse
Выполнение устранения неиспользуемого хранения (DSE) на RTL. Включено по умолчанию на уровнях -O и выше.
-fif-conversion
Попытка преобразовать условные переходы в безусловные эквиваленты. Это включает использование условных перемещений, мин, макс, установки флагов и инструкций abs, а также некоторых трюков, выполнимых стандартной арифметикой. Использование условного выполнения на чипах, где оно доступно, контролируется параметром if-conversion2.

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

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

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

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

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

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

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

Некоторые целевые платформы, особенно встроенные, отключают этот параметр на всех уровнях. В противном случае он включен на всех уровнях: -O0, -O1, -O2, -O3, -Os. Процессы, использующие эту информацию, включаются независимо на разных уровнях оптимизации.

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

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

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

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

-fno-lifetime-dse
В C++ значение объекта затрагивается только изменениями в течение его жизненного цикла: когда начинается конструктор, объект имеет неопределенное значение, а любые изменения во время жизненного цикла объекта становятся неиспользуемыми при уничтожении объекта. Обычно устранение избыточных хранений использует это; если ваш код полагается на то, что хранение объекта сохраняется после окончания жизненного цикла объекта, вы можете использовать этот флаг для отключения этой оптимизации.
-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
Отключить совместное использование стековых слотов, выделенных для псевдорегистров. Каждый псевдорегистр, который не получает регистр жесткого типа, получает отдельный стековый слот, в результате чего кадры стека функций увеличиваются.
-fira-verbose=n
Управляет объёмом вывода файла дампов для интегрированного распределятеля регистров. Значение по умолчанию равно 5. Если значение n больше или равно 10, вывод дампов отправляется в stderr в том же формате, что и для n минус 10.
-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.
-fshrink-wrap
Выводить прологи функций только перед частями функции, которые в них нуждаются, а не в начале функции. Этот флаг включён по умолчанию на уровне -O и выше.
-fcaller-saves
Включить выделение значений в регистры, которые разрушаются вызовами функций, выдав дополнительные инструкции для сохранения и восстановления регистров вокруг таких вызовов. Такое выделение выполняется только в тех случаях, когда это, кажется, приводит к лучшему коду.

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

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

-fcombine-stack-adjustments
Отслеживает корректировки стека (записи и считывания) и ссылки на память стека, а затем пытается найти способы их комбинирования.

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

-fconserve-stack
Попытаться минимизировать использование стека. Компилятор пытается использовать меньше места в стеке, даже если это замедляет программу. Этот параметр подразумевает установку параметра large-stack-frame в 100 и параметра large-stack-frame-growth в 400.
-ftree-reassoc
Выполнить перегруппировку в деревьях. Этот флаг включён по умолчанию на уровне -O и выше.
-ftree-pre
Выполнить частичное устранение избыточности (PRE) в деревьях. Этот флаг включён по умолчанию на уровнях -O2 и -O3.
-ftree-partial-pre
Сделать частичное устранение избыточности (PRE) более агрессивным. Этот флаг включён по умолчанию на уровне -O3.
-ftree-forwprop
Выполнить распространение вперёд в деревьях. Этот флаг включён по умолчанию на уровне -O и выше.
-ftree-fre
Выполнить полное устранение избыточности (FRE) в деревьях. Разница между FRE и PRE состоит в том, что FRE рассматривает только выражения, которые вычисляются на всех путях, ведущих к избыточному вычислению. Этот анализ быстрее, чем PRE, хотя он обнаруживает меньше избыточностей. Этот флаг включён по умолчанию на уровне -O и выше.
-ftree-phiprop
Выполнить подъём загрузки из условных указателей в деревьях. Этот проход включён по умолчанию на уровне -O и выше.
-fhoist-adjacent-loads
Умозрительно поднять данные с обеих ветвей условного оператора if-then-else, если данные загружаются из смежных расположений в одной структуре, и целевая архитектура имеет инструкцию условного перемещения. Этот флаг включён по умолчанию при -O2 и выше.
-ftree-copy-prop
Выполнить распространение копирования по деревьям. Этот этап устраняет ненужные операции копирования. Этот флаг включён по умолчанию при -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.
-fisolate-erroneous-paths-dereference
Обнаружение путей, которые вызывают ошибочное или неопределённое поведение из-за разыменования указателя NULL. Изолировать эти пути от основного потока управления и преобразовать оператор с ошибочным или неопределённым поведением в ловушку.
-fisolate-erroneous-paths-attribute
Обнаружение путей, которые вызывают ошибочное или неопределённое поведение из-за использования значения NULL способом, запрещённым атрибутом returns_nonnull или nonnull. Изолировать эти пути от основного потока управления и преобразовать оператор с ошибочным или неопределённым поведением в ловушку. В настоящее время это не включено, но может быть включено -O2 в будущем.
-ftree-sink
Выполнить передвижение сохранения вперёд по деревьям. Этот флаг включён по умолчанию при -O и выше.
-ftree-bit-ccp
Выполнить распространение разреженной условной константы по битам и распространить информацию о выравнивании указателя по деревьям. Этот этап работает только с локальными скалярными переменными и включен по умолчанию при -O и выше. Требуется, чтобы -ftree-ccp был включен.
-ftree-ccp
Выполнить распространение разреженной условной константы (CCP) по деревьям. Этот этап работает только с локальными скалярными переменными и включен по умолчанию при -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. Для использования этого преобразования кода GCC необходимо сконфигурировать с --with-ppl и --with-cloog, чтобы включить инфраструктуру преобразования циклов Graphite.
-floop-interchange
Выполнить преобразования перестановки циклов для циклов. Перестановка двух вложенных циклов меняет внутренний и внешний циклы. Например, для цикла: 
DO J = 1, M
  DO I = 1, N
    A(J, I) = A(J, I) * C
  ENDDO
ENDDO

перестановка циклов преобразует цикл, как если бы он был написан: 

DO I = 1, N
  DO J = 1, M
    A(J, I) = A(J, I) * C
  ENDDO
ENDDO

что может быть полезно, когда N больше, чем кэш, потому что в Fortran элементы массива хранятся в памяти непрерывно по столбцам, а исходный цикл итерируется по строкам, потенциально создавая промах кэша при каждом обращении. Эта оптимизация применяется ко всем языкам, поддерживаемым GCC, и не ограничивается Fortran. Для использования этого преобразования кода GCC необходимо сконфигурировать с --with-ppl и --with-cloog, чтобы включить инфраструктуру преобразования циклов Graphite.

-floop-strip-mine
Выполнить преобразования разбиения циклов на полосы для циклов. Разбиение на полосы делит цикл на два вложенных цикла. Внешний цикл имеет шаги, равные размеру полосы, а внутренний цикл имеет шаги исходного цикла в пределах полосы. Длину полосы можно изменить, используя параметр loop-block-tile-size. Например, для цикла: 
DO I = 1, N
  A(I) = A(I) + C
ENDDO

разбиение цикла на полосы преобразует цикл, как если бы он был написан: 

DO II = 1, N, 51
  DO I = II, min (II + 50, N)
    A(I) = A(I) + C
  ENDDO
ENDDO

Эта оптимизация применяется ко всем языкам, поддерживаемым GCC, и не ограничивается Fortran. Для использования этого преобразования кода GCC необходимо сконфигурировать с --with-ppl и --with-cloog, чтобы включить инфраструктуру преобразования циклов Graphite.

-floop-block
Выполнить преобразования блочного разбиения для циклов. Блочное разбиение разбивает каждый цикл в цикловом вложении так, что обращения к памяти элементарных циклов помещаются в кэш. Длину полосы можно изменить, используя параметр loop-block-tile-size. Например, для цикла: 
DO I = 1, N
  DO J = 1, M
    A(J, I) = B(I) + C(J)
  ENDDO
ENDDO

блочное разбиение преобразует цикл, как если бы он был написан: 

DO II = 1, N, 51
  DO JJ = 1, M, 51
    DO I = II, min (II + 50, N)
      DO J = JJ, min (JJ + 50, M)
        A(J, I) = B(I) + C(J)
      ENDDO
    ENDDO
  ENDDO
ENDDO

что может быть полезно, когда M больше, чем кэш, потому что внутренний цикл итерируется по меньшему количеству данных, которые могут храниться в кэше. Эта оптимизация применяется ко всем языкам, поддерживаемым GCC, и не ограничивается Fortran. Для использования этого преобразования кода GCC необходимо сконфигурировать с --with-ppl и --with-cloog, чтобы включить инфраструктуру преобразования циклов Graphite.

-fgraphite-identity
Включить тождественное преобразование для graphite. Для каждого SCoP мы генерируем полигональное представление и преобразуем его обратно в gimple. С помощью -fgraphite-identity мы можем проверить затраты или выгоды преобразования GIMPLE -> GRAPHITE -> GIMPLE. Некоторые минимальные оптимизации также выполняются генератором кода CLooG, такие как разделение индексов и удаление мёртвого кода в циклах.
-floop-nest-optimize
Включить оптимизатор вложенных циклов на основе ISL. Это универсальный оптимизатор вложенных циклов, основанный на алгоритмах оптимизации Pluto. Он вычисляет структуру цикла, оптимизированную под локальность данных и параллелизм. Этот параметр экспериментальный.
-floop-parallelize-all
Использовать анализ зависимостей данных Graphite для определения циклов, которые можно распараллелить. Распараллелить все циклы, которые можно проанализировать, не содержащие внутрицикловых зависимостей, не проверяя, выгодно ли распараллеливать циклы.
-fcheck-data-deps
Сравнение результатов нескольких анализаторов зависимостей данных. Этот параметр используется для отладки анализаторов зависимостей данных.
-ftree-loop-if-convert
Попытка преобразовать условные переходы во вложенных циклах в их безусловные эквиваленты. Цель – удалить поток управления из вложенных циклов, чтобы улучшить возможность обработки этих циклов этапом векторизации. Включено по умолчанию, если векторизация включена.
-ftree-loop-if-convert-stores
Попытка также преобразовать условные переходы, содержащие записи в память. Это преобразование может быть небезопасным для многопоточных программ, так как оно преобразует условные записи в память в безусловные записи в память. Например, 
for (i = 0; i < N; i++)
  if (cond)
    A[i] = expr;

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

for (i = 0; i < N; i++)
  A[i] = cond ? expr : A[i];

что может привести к гонкам данных.

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

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

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

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

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

-ftree-loop-im
Выполнить перемещение инвариантов цикла по деревьям. Этот этап перемещает только инварианты, которые трудно обработать на уровне RTL (вызовы функций, операции, которые расширяются до нетривиальных последовательностей команд). С помощью -funswitch-loops он также перемещает операнды условий, которые являются инвариантами, из цикла, так что мы можем использовать только тривиальный анализ инвариантности в цикле unswitching. Этап также включает перемещение хранений.
-ftree-loop-ivcanon
Создать канонический счётчик для числа итераций в циклах, для которых определение числа итераций требует сложного анализа. Позже оптимизации смогут легко определить это число. Особенно полезно в связи с развёртыванием циклов.
-fivopts
Выполнить оптимизации переменных индукции (уменьшение силы, слияние переменных индукции и удаление переменных индукции) по деревьям.
-ftree-parallelize-loops=n
Параллелизовать циклы, т.е. разделить их пространство итераций для выполнения в n потоках. Это возможно только для циклов, итерации которых независимы и могут быть произвольно переупорядочены. Оптимизация выгодна только на многопроцессорных машинах для циклов, которые являются ресурсоёмкими по ЦП, а не ограниченными, например, пропускной способностью памяти. Этот параметр подразумевает -pthread, и поэтому поддерживается только на целевых платформах, которые поддерживают -pthread.
-ftree-pta
Выполнить локальный по функциям анализ указания на деревья. Этот флаг включён по умолчанию на уровне -O и выше.
-ftree-sra
Выполнить замену скаляров агрегатов. Этот этап заменяет ссылки на структуры скалярами, чтобы не сохранять структуры в памяти слишком рано. Этот флаг включён по умолчанию на уровне -O и выше.
-ftree-copyrename
Выполнить переименование копий на деревьях. Этот этап пытается переименовать временные переменные компилятора на другие переменные в местах копирования, что обычно приводит к именам переменных, которые более точно отражают исходные переменные. Этот флаг включён по умолчанию на уровне -O и выше.
-ftree-coalesce-inlined-vars
Указать этапу copyrename (см. -ftree-copyrename), чтобы попытаться комбинировать и небольшие пользовательские переменные тоже, но только если они были вставлены из других функций. Это более ограниченная форма -ftree-coalesce-vars. Это может навредить информацией отладки таких вставленных переменных, но сохранит переменные из вставленной в функцию отдельно друг от друга, так что они с большей вероятностью будут содержать ожидаемые значения в сессии отладки. Это был по умолчанию в версиях GCC старше 4.7.
-ftree-coalesce-vars
Указать этапу copyrename (см. -ftree-copyrename), чтобы попытаться комбинировать и небольшие пользовательские переменные тоже, а не только временные переменные компилятора. Это может существенно ограничить возможность отладки оптимизированной программы, скомпилированной с -fno-var-tracking-assignments. В отрицательной форме этот флаг предотвращает слияние SSA пользовательских переменных, включая вставленные. Этот параметр включён по умолчанию.
-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
Изменить модель затрат, используемую для векторизации циклов, помеченных директивой simd OpenMP или Cilk Plus. Аргумент model должен быть одним из unlimited, dynamic, cheap. Все значения model имеют то же значение, что и описано в -fvect-cost-model, и по умолчанию используется модель затрат, определённая с помощью -fvect-cost-model.
-ftree-vrp
Выполнить распространение диапазона значений на деревьях. Это похоже на этап распространения констант, но вместо значений распространяются диапазоны значений. Это позволяет оптимизаторам удалять ненужные проверки диапазонов, такие как проверки границ массивов и проверки на нулевой указатель. Этот параметр включен по умолчанию на уровне -O2 и выше. Удаление проверок на нулевой указатель выполняется только при включении -fdelete-null-pointer-checks.
-ftracer
Выполнить дублирование хвоста для увеличения размера суперблока. Это преобразование упрощает поток управления функцией, что позволяет другим оптимизациям лучше справиться с задачей.
-funroll-loops
Разворачивать циклы, число итераций которых может быть определено во время компиляции или при входе в цикл. -funroll-loops подразумевает -frerun-cse-after-loop. Этот параметр увеличивает размер кода, и может, а может и не, ускорить его выполнение.
-funroll-all-loops
Разворачивать все циклы, даже если их число итераций не определено при входе в цикл. Это, как правило, замедляет выполнение программ.
-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-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’ были легче понятны.

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

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

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

Практика чтения из другого члена объединения, чем тот, в который последним записывали (называемая «aliasing типов») распространена. Даже с -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 переполняется при использовании арифметики со знаком с дополнением до 2. Когда эта опция активна, любая попытка определить, произойдет ли переполнение при операции с целыми числами со знаком, должна быть тщательно разработана, чтобы фактически не вызвать переполнение.

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

См. также опцию -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 не указан или равен нулю, используется машино-зависимое значение по умолчанию.

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

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

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

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

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

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

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

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

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

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

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

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

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

Включено на уровнях -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 предназначено только для внутренних тестов.
-flto-compression-level=n
Этот параметр задаёт уровень сжатия, используемый для промежуточного языка, записанного в объектные файлы LTO, и имеет смысл только в сочетании с режимом LTO (-flto). Допустимые значения — от 0 (без сжатия) до 9 (максимальное сжатие). Значения вне этого диапазона усекаются до 0 или 9. Если параметр не задан, используется значение сжатия по умолчанию.
-flto-report
Выводит отчёт с внутренней информацией о работе оптимизатора на этапе компоновки. Содержимое этого отчёта может различаться в разных версиях. Он предназначен для использования разработчиками GCC при обработке объектных файлов в режиме LTO (через -flto).

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

-flto-report-wpa
Как -flto-report, но выводит информацию только для фазы WPA оптимизации на этапе компоновки.
-fuse-linker-plugin
Включает использование плагина линковщика во время оптимизации на этапе линковки. Этот параметр полагается на поддержку плагинов в линковщике, которая доступна в gold или в GNU ld 2.21 или новее.

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

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

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

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

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

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

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

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

-fuse-ld=bfd
Использовать линковщик bfd вместо стандартного линковщика.
-fuse-ld=gold
Использовать линковщик gold вместо стандартного линковщика.
-fcprop-registers
После размещения регистров и разделения инструкций после размещения регистров выполнить проход копирования для попытки уменьшить зависимости планирования и иногда устранить копирование.

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

-fprofile-correction
Профили, собранные с помощью инструментированного бинарного файла для многопоточных программ, могут быть несогласованными из-за пропущенных обновлений счётчиков. При указании этого параметра GCC использует эвристические методы для исправления или сглаживания таких несоответствий. По умолчанию GCC выводит сообщение об ошибке при обнаружении несогласованного профиля.
-fprofile-dir=path
Установить каталог для поиска файлов данных профиля в path. Этот параметр влияет только на данные профиля, сгенерированные -fprofile-generate, -ftest-coverage, -fprofile-arcs и используемые -fprofile-use и -fbranch-probabilities и их связанными параметрами. Можно использовать как абсолютные, так и относительные пути. По умолчанию GCC использует текущий каталог как path, поэтому файл данных профиля появляется в том же каталоге, что и объектный файл.
-fprofile-generate
-fprofile-generate=path
Включить параметры, обычно используемые для инструментирования приложения для создания профиля, полезного для последующей перекомпиляции с оптимизацией, основанной на обратной связи профиля. Вы должны использовать -fprofile-generate как при компиляции, так и при линковке вашей программы.

Включаются следующие параметры: -fprofile-arcs, -fprofile-values, -fvpt.

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

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

Включаются следующие параметры: -fbranch-probabilities, -fvpt, -funroll-loops, -fpeel-loops, -ftracer, -ftree-vectorize, ftree-loop-distribute-patterns

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

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

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

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

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

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

-fexcess-precision=standard не реализован для языков, кроме C, и не имеет эффекта, если указаны -funsafe-math-optimizations или -ffast-math. На 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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-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 (см. Параметры для отладки вашей программы или gcc), вы можете скомпилировать её во второй раз, используя -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 и -fpeel-loops.

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

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

-fmove-loop-invariants
Включает проход перемещения инвариантов цикла в оптимизаторе циклов RTL. Включается на уровне -O1
-funswitch-loops
Перемещает ветвления с условиями, инвариантными для цикла, из цикла, с дубликатами цикла на обеих ветвях (изменёнными в соответствии с результатом условия).
-ffunction-sections
-fdata-sections
Размещает каждую функцию или элемент данных в свой раздел в выходном файле, если целевой формат поддерживает произвольные разделы. Имя функции или имя элемента данных определяет имя раздела в выходном файле.

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

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

-fbranch-target-load-optimize
Выполнить оптимизацию загрузки регистра целевого адреса ветвления перед обработкой пролога/эпилога. Использование целевых регистров, как правило, становится доступным только во время перезагрузки, поэтому для подъёма загрузок из циклов и межблочной планировки требуется отдельный этап оптимизации.
-fbranch-target-load-optimize2
Выполнить оптимизацию загрузки регистра целевого адреса ветвления после обработки пролога/эпилога.
-fbtr-bb-exclusive
При выполнении оптимизации загрузки регистра целевого адреса ветвления не повторно использовать регистры целевого адреса ветвления в любом базовом блоке.
-fstack-protector
Вывести дополнительный код для проверки переполнения буфера, например, атак через переполнение стека. Это делается путем добавления защитной переменной к функциям с уязвимыми объектами. Это включает функции, которые вызывают alloca, и функции с буферами больше 8 байт. Защитные переменные инициализируются при входе в функцию и затем проверяются при выходе из функции. Если проверка защиты завершается неудачно, выводится сообщение об ошибке и программа завершается.
-fstack-protector-all
Подобно -fstack-protector, за исключением того, что все функции защищены.
-fstack-protector-strong
Подобно -fstack-protector, но включает дополнительные защищаемые функции — те, которые имеют локальные определения массивов или ссылки на локальные адреса фрейма.
-fsection-anchors
Попытаться уменьшить количество вычислений символических адресов, используя общие «якорные» символы для адресации близлежащих объектов. Эта трансформация может помочь уменьшить количество записей и обращений к GOT на некоторых целевых системах.

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

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

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

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

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

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

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

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

predictable-branch-outcome
Когда ветвь прогнозируется как взятая с вероятностью ниже этого порога (в процентах), она считается хорошо предсказуемой. По умолчанию значение 10.
max-crossjump-edges
Максимальное количество входящих рёбер, которые следует учитывать для перехода по пересечению. Алгоритм, используемый -fcrossjumping, имеет сложность O(N^2) относительно числа рёбер, входящих в каждый блок. Увеличение значений означает более агрессивную оптимизацию, что приводит к увеличению времени компиляции, но, вероятно, с небольшим улучшением размера исполняемого файла.
min-crossjump-insns
Минимальное количество инструкций, которые должны совпадать в конце двух блоков перед выполнением перехода по пересечению. Это значение игнорируется в случае, если все инструкции в блоке, из которого выполняется переход по пересечению, совпадают. Значение по умолчанию 5.
max-grow-copy-bb-insns
Максимальный коэффициент увеличения размера кода при копировании базовых блоков вместо перехода. Увеличение относительно инструкции перехода. Значение по умолчанию 8.
max-goto-duplication-insns
Максимальное количество инструкций для дублирования в блок, который переходит к вычисленному переходу goto. Для избежания поведения O(N^2) в ряде проходов, GCC раннее факторизует вычисленные goto в процессе компиляции и разфакторизует их как можно позже. Лишь вычисленные переходы в конце базового блока с не более чем 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. Этот параметр полезен в первую очередь для предотвращения чрезмерного времени компиляции, вызванного нелинейными алгоритмами, используемыми бэкэндом. Значение по умолчанию 2700.
large-function-growth
Указывает максимальный рост большой функции, вызванный инлайнингом, в процентах. Значение по умолчанию 100, что ограничивает рост большой функции до 2,0 раз от исходного размера.
large-unit-insns
Ограничение, определяющее большой трансляционный блок. Рост, вызванный инлайнингом блоков, больших, чем это ограничение, ограничен параметром --param inline-unit-growth. Для небольших блоков это может быть слишком жёстко. Например, рассмотрите блок, состоящий из функции A, которая имеет inline, и B, которая просто трижды вызывает A. Если B мала по отношению к A, рост блока составляет 300%, и тем не менее такой инлайнинг очень разумный. Однако для очень больших блоков, состоящих из небольших инлайнируемых функций, необходимо ограничение общего роста блока, чтобы избежать экспоненциального взрыва размера кода. Таким образом, для меньших блоков размер увеличивается до --param large-unit-insns перед применением --param inline-unit-growth. Значение по умолчанию 10000.
inline-unit-growth
Указывает максимальный общий рост трансляционного блока, вызванный инлайнингом. Значение по умолчанию 30, что ограничивает рост блока до 1,3 раз от исходного размера.
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
Указывает максимальное количество инструкций, до которых может вырасти внестрочная копия рекурсивной inline-функции при рекурсивном инлайнинге.

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

max-inline-recursive-depth
max-inline-recursive-depth-auto
Указывает максимальную глубину рекурсии, используемую для рекурсивного инлайнинга.

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

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

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

early-inlining-insns
Указывает рост, который может сделать ранний инлайнер. По сути, он увеличивает объём инлайнинга для кода с большой стоимостью абстракции. Значение по умолчанию 10.
max-early-inliner-iterations
max-early-inliner-iterations
Ограничение итераций раннего инлайнера. Это в основном ограничивает количество вложенных косвенных вызовов, которые ранний инлайнер может разрешить. Более глубокие цепочки всё же обрабатываются поздним инлайнингом.
comdat-sharing-probability
comdat-sharing-probability
Вероятность (в процентах) того, что функция C++ inline с видимостью comdat будет использоваться совместно несколькими блоками компиляции. Значение по умолчанию 20.
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
Максимальное количество подобных блоков (bbs), с которыми сравнивается bb. Это используется для предотвращения квадратичного поведения в слиянии хвостовых частей дерева. Значение по умолчанию 10.
max-tail-merge-iterations
Максимальное количество итераций прохода по функции. Это используется для ограничения времени компиляции при слиянии хвостовых частей дерева. Значение по умолчанию 2.
max-unrolled-insns
Максимальное количество инструкций, которые может иметь цикл для его развёртывания. Если цикл развернут, этот параметр также определяет, сколько раз код цикла развернётся.
max-average-unrolled-insns
Максимальное количество инструкций, взвешенных вероятностью их выполнения, которые может иметь цикл для его развёртывания. Если цикл развернут, этот параметр также определяет, сколько раз код цикла развернётся.
max-unroll-times
Максимальное количество развёртываний одного цикла.
max-peeled-insns
Максимальное количество инструкций, которые может иметь цикл для его отрезания. Если цикл обрезан, этот параметр также определяет, сколько раз код цикла обрезан.
max-peel-times
Максимальное количество отрезаний одного цикла.
max-peel-branches
Максимальное количество ветвей на горячей трассе через обрезанную последовательность.
max-completely-peeled-insns
Максимальное количество инструкций полностью обрезанного цикла.
max-completely-peel-times
Максимальное количество итераций цикла, которое подходит для полного отрезания.
max-completely-peel-loop-nest-depth
Максимальная глубина вложенности циклов, подходящая для полного вырезания.
max-unswitch-insns
Максимальное количество инструкций в непереключенном цикле.
max-unswitch-level
Максимальное количество ветвлений, непереключенных в одном цикле.
lim-expensive
Минимальная стоимость дорогостоящего выражения в оптимизации перемещения инвариантных выражений в цикле.
iv-consider-all-candidates-bound
Ограничение на количество кандидатов для индуктивных переменных, ниже которого все кандидаты рассматриваются для каждого использования в оптимизациях индуктивных переменных. Если кандидатов больше, чем это значение, рассматриваются только самые релевантные, чтобы избежать квадратичной временной сложности.
iv-max-considered-uses
Оптимизации индуктивных переменных отказываются от циклов, содержащих больше использований индуктивных переменных.
iv-always-prune-cand-set-bound
Если количество кандидатов в наборе меньше этого значения, всегда пытайтесь удалить ненужные индуктивные переменные из набора при добавлении нового.
scev-max-expr-size
Ограничение на размер выражений, используемых в анализаторе скалярных эволюций. Большие выражения замедляют анализатор.
scev-max-expr-complexity
Ограничение на сложность выражений в анализаторе скалярных эволюций. Сложные выражения замедляют анализатор.
omega-max-vars
Максимальное количество переменных в системе ограничений Омега. Значение по умолчанию — 128.
omega-max-geqs
Максимальное количество неравенств в системе ограничений Омега. Значение по умолчанию — 256.
omega-max-eqs
Максимальное количество равенств в системе ограничений Омега. Значение по умолчанию — 128.
omega-max-wild-cards
Максимальное количество символьных переменных, которые может вставить решатель Омега. Значение по умолчанию — 18.
omega-hash-table-size
Размер хеш-таблицы в решателе Омега. Значение по умолчанию — 550.
omega-max-keys
Максимальное количество ключей, используемых решателем Омега. Значение по умолчанию — 500.
omega-eliminate-redundant-constraints
При значении 1 используются дорогостоящие методы для устранения всех избыточных ограничений. Значение по умолчанию — 0.
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-ratio
tracer-min-branch-ratio-feedback
Остановка прямого роста, если вероятность лучшего ребра ниже этого порога.

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

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

reorder-block-duplicate-feedback используется только при наличии отзывов о профилях. Его можно установить на более высокие значения, чем reorder-block-duplicate, поскольку информация о горячих точках более точная.

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-spec-state-edge-prob-cutoff
Минимальная вероятность, которую должно иметь ребро, чтобы планировщик сохранил свое состояние через него. Значение по умолчанию — 10.
sched-mem-true-dep-cost
Минимальное расстояние (в тактах процессора) между записью и чтением, обращающимися к тем же ячейкам памяти. Значение по умолчанию — 1.
selsched-max-lookahead
Максимальный размер окна предвидения селективного планирования. Это глубина поиска доступных инструкций. Значение по умолчанию — 50.
selsched-max-sched-times
Максимальное количество раз, которое инструкция планируется во время селективного планирования. Это ограничение на количество итераций, через которые инструкция может быть конвейеризована. Значение по умолчанию — 2.
selsched-max-insns-to-rename
Максимальное количество лучших инструкций в очереди готовности, которые рассматриваются для переименования в селективном планировщике. Значение по умолчанию — 2.
sms-min-sc
Минимальное значение счётчика этапов, которое генерирует планировщик с модулем колебаний. Значение по умолчанию — 2.
max-last-value-rtl
Максимальный размер, измеренный как количество RTL, которые могут быть записаны в выражении в комбинаторе для псевдорегистра как последнее известное значение этого регистра. По умолчанию 10000.
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 раз, чем количество ветвей в switch.
max-partial-antic-length
Максимальная длина частичного антимножества, вычисленного во время оптимизации частичной избыточности дерева (-ftree-pre) при оптимизации на уровне -O3 и выше. Для некоторых типов исходного кода улучшенная оптимизация частичной избыточности может уйти в бесконечный цикл, используя всю доступную память на хост-машине. Этот параметр устанавливает ограничение на длину вычисляемых множеств, что предотвращает такое поведение. Установка значения 0 для этого параметра разрешает неограниченную длину множества.
sccvn-max-scc-size
Максимальный размер сильно связной компоненты (ССК) во время обработки SCCVN. Если это ограничение достигнуто, обработка SCCVN для всей функции не выполняется, и зависящие от нее оптимизации отключаются. По умолчанию максимальный размер ССК составляет 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, что является минимальным количеством регистров, необходимым для типичных инструкций. Это значение является лучшим, найденным в результате многочисленных экспериментов.
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 раз размеру исходного параметра указателя.
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 итерации.
ipa-cp-value-list-size
IPA-CP пытается отследить все возможные значения и типы, передаваемые параметру функции, чтобы распространять их и выполнять девиртуализацию. ipa-cp-value-list-size — максимальное количество значений и типов, которые он хранит для каждого формального параметра функции.
ipa-cp-eval-threshold
IPA-CP вычисляет собственный рейтинг эвристики рентабельности клонирования и выполняет эти возможности клонирования с оценками, которые превышают ipa-cp-eval-threshold.
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 к баллу рентабельности кандидата.
lto-partitions
Укажите желаемое количество разделов, созданных во время компиляции WHOPR. Количество разделов должно превышать количество ЦП, используемых для компиляции. Значение по умолчанию равно 32.
lto-minpartition
Размер минимального раздела для WHOPR (в оценке инструкций). Это предотвращает затраты на разделение очень маленьких программ на слишком много разделов.
cxx-max-namespaces-for-diagnostic-help
Максимальное количество пространств имен для консультации по предложениям, когда поиск имени C++ для идентификатора терпит неудачу. По умолчанию равно 1000.
sink-frequency-threshold
Максимальная относительная частота выполнения (в процентах) целевого блока относительно исходного блока оператора для разрешения опускания оператора. Более высокие числа приводят к более агрессивному опусканию оператора. Значение по умолчанию равно 75. Для операторов с операндами памяти применяется небольшая положительная корректировка, так как они еще более выгодны для опускания.
max-stores-to-sink
Максимальное количество пар условных сохранений, которые можно опустить. Установлено в 0, если либо векторизация (-ftree-vectorize), либо преобразование if (-ftree-loop-if-convert) отключены. Значение по умолчанию равно 2.
allow-load-data-races
Разрешить оптимизаторам вводить новые гонки данных при загрузках. Установите в 1 для разрешения, в противном случае в 0. Этот параметр включен по умолчанию, если явно не задан параметром -fmemory-model=.
allow-store-data-races
Разрешить оптимизаторам вводить новые гонки данных при сохранениях. Установите в 1 для разрешения, в противном случае в 0. Этот параметр включен по умолчанию, если явно не задан параметром -fmemory-model=.
allow-packed-load-data-races
Разрешить оптимизаторам вводить новые гонки данных при загрузке упакованных данных. Установите в 1 для разрешения, в противном случае в 0. Этот параметр включен по умолчанию, если явно не задан параметром -fmemory-model=.
allow-packed-store-data-races
Разрешить оптимизаторам вносить новые гонки данных в упакованные хранилища данных. Установите в 1, чтобы разрешить, иначе в 0. Этот параметр включен по умолчанию, если не установлен явно параметром -fmemory-model=.
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.
asan-instrumentation-with-call-threshold
Если количество обращений к памяти в инструментируемой функции больше или равно этому числу, используйте обратные вызовы вместо встроенных проверок. Например, чтобы отключить встроенный код, используйте --param asan-instrumentation-with-call-threshold=0.

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

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API