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

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

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

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

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

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

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

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

-O

-O1

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

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

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

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

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

-O2

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

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

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

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

-O3

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

-O0

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

-Os

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

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

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

-Ofast

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

-Og

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

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

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

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

-fno-defer-pop

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

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

-fforward-propagate

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

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

-ffp-contract=style

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

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

-fomit-frame-pointer

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

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

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

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

-foptimize-sibling-calls

Оптимизировать вызовы-сёстры (sibling calls) и вызовы по хвостовой рекурсии.

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

-foptimize-strlen

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

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

-fno-inline

Не раскладывать функции встраиванием (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

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

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

-fkeep-static-consts

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

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

-fmerge-constants

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

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

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

-fmerge-all-constants

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

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

-fmodulo-sched

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

-fmodulo-sched-allow-regmoves

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

-fno-branch-count-reg

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

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

По умолчанию используется -fbranch-count-reg.

-fno-function-cse

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

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

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

-fno-zero-initialized-in-bss

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

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

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

-fthread-jumps

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

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

-fsplit-wide-types

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

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

-fcse-follow-jumps

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

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

-fcse-skip-blocks

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

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

-frerun-cse-after-loop

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

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

-fgcse

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

Примечание: При компиляции программы с вычисляемыми переходами (расширение 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, компилятор предупредит вас, если найдёт такой цикл.

-funconstrained-commons

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

-fcrossjumping

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

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

-fauto-inc-dec

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

-fdce

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

-fdse

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

-fif-conversion

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

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

-fif-conversion2

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

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

-fdeclone-ctor-dtor

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

Включено -Os.

-fdelete-null-pointer-checks

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

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

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

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

-fdevirtualize

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

-fdevirtualize-speculatively

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

-fdevirtualize-at-ltrans

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

-fexpensive-optimizations

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

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

-free

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

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

-fno-lifetime-dse

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

-flive-range-shrinkage

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

-fira-algorithm=algorithm

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

-fira-region=region

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

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

-fira-hoist-pressure

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

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

-fira-loop-pressure

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

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

-fno-ira-share-save-slots

-fno-ira-share-spill-slots

-flra-remat

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

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

-fdelayed-branch

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

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

-fschedule-insns

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

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

-fschedule-insns2

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

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

-fno-sched-interblock

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

-fno-sched-spec

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

-fsched-pressure

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

-fsched-spec-load

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

-fsched-spec-load-dangerous

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

-fsched-stalled-insns

-fsched-stalled-insns=n

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

-fsched-stalled-insns-dep

-fsched-stalled-insns-dep=n

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

-fsched2-use-superblocks

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

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

-fsched-group-heuristic

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

-fsched-critical-path-heuristic

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

-fsched-spec-insn-heuristic

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

-fsched-rank-heuristic

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

-fsched-last-insn-heuristic

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

-fsched-dep-count-heuristic

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

-freschedule-modulo-scheduled-loops

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

-fselective-scheduling

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

-fselective-scheduling2

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

-fsel-sched-pipelining

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

-fsel-sched-pipelining-outer-loops

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

-fsemantic-interposition

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

-fshrink-wrap

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

-fcaller-saves

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

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

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

-fcombine-stack-adjustments

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

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

-fipa-ra

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

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

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

-fipa-cp-alignment

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

Этот флаг включен по умолчанию при -O2 и -Os. Требуется, чтобы был включен -fipa-cp.

-fipa-icf

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

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

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

-fisolate-erroneous-paths-dereference

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

-fisolate-erroneous-paths-attribute

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

-ftree-sink

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

-ftree-bit-ccp

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

-ftree-ccp

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

-fssa-backprop

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

-fssa-phiopt

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

-ftree-switch-conversion

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

-ftree-tail-merge

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

-ftree-dce

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

-ftree-builtin-call-dce

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

-ftree-dominator-opts

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

-ftree-dse

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

-ftree-ch

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

-ftree-loop-optimize

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

-ftree-loop-linear

-floop-interchange

-floop-strip-mine

-floop-block

-floop-unroll-and-jam

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

-fgraphite-identity

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

-floop-nest-optimize

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

-floop-parallelize-all

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

-ftree-coalesce-vars

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

-ftree-loop-if-convert

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

-ftree-loop-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 (вызовы функций, операции, которые расширяются до нетривиальных последовательностей insns). С -funswitch-loops он также перемещает операнды условий, которые являются инвариантами, за пределы цикла, так что мы можем использовать только тривиальный анализ инвариантности в циклах unswitching. Этап также включает перемещение записей.

-ftree-loop-ivcanon

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

-fivopts

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

-ftree-parallelize-loops=n

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

-ftree-pta

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

-ftree-sra

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

-ftree-ter

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

-ftree-slsr

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

-ftree-vectorize

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

-ftree-loop-vectorize

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

-ftree-slp-vectorize

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

-fvect-cost-model=model

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

-fsimd-cost-model=model

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

-ftree-vrp

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

-fsplit-paths

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

-fsplit-ivs-in-unroller

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

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

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

-fvariable-expansion-in-unroller

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

-fpartial-inlining

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

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

-fpredictive-commoning

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

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

-fprefetch-loop-arrays

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

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

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

-fno-peephole

-fno-peephole2

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

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

-fno-guess-branch-probability

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

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

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

-freorder-blocks

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

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

-freorder-blocks-algorithm=algorithm

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

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

-freorder-blocks-and-partition

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

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

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

-freorder-functions

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

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

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

-fstrict-aliasing

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

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

union a_union {
  int i;
  double d;
};

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

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

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

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

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

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

-fstrict-overflow

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

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

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

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

-falign-functions

-falign-functions=n

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

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

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

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

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

-falign-labels

-falign-labels=n

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

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

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

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

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

-falign-loops

-falign-loops=n

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

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

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

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

-falign-jumps

-falign-jumps=n

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

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

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

-funit-at-a-time

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

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

-fno-toplevel-reorder

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

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

-fweb

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

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

-fwhole-program

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

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

-flto[=n]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-flto-partition=alg

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

-flto-odr-type-merging

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

-flto-compression-level=n

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

-fuse-linker-plugin

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

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

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

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

-fcompare-elim

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

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

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

-fcprop-registers

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

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

-fprofile-correction

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

-fprofile-use

-fprofile-use=path

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

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

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

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

-fauto-profile

-fauto-profile=path

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

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

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

Например:

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

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

Например:

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

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

-ffloat-store

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

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

-fexcess-precision=style

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

-funsafe-math-optimizations

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

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

-fassociative-math

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

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

-freciprocal-math

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

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

-ffinite-math-only

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

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

-fno-signed-zeros

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

Значение по умолчанию — -fsigned-zeros.

-fno-trapping-math

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

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

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

-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 (см. Параметры инструментирования), вы можете скомпилировать её второй раз с использованием -fbranch-probabilities, чтобы улучшить оптимизации, основанные на количестве пройденных ветвлений. При выходе программы, скомпилированной с -fprofile-arcs, она сохраняет количество выполнений дуг в файл, который называется имя_исходного_файла.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.

-fschedule-fusion

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

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

-ftracer

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

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

-funroll-loops

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

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

-funroll-all-loops

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

-fpeel-loops

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

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

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

-fstdarg-opt

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

-fsection-anchors

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

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

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

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

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

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

--param name=value

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

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

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

predictable-branch-outcome

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

max-rtl-if-conversion-insns

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

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

inline-unit-growth

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

ipcp-unit-growth

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

large-stack-frame

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

large-stack-frame-growth

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

max-inline-insns-recursive

max-inline-insns-recursive-auto

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

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

max-inline-recursive-depth

max-inline-recursive-depth-auto

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

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

min-inline-recursive-probability

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

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

early-inlining-insns

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

max-early-inliner-iterations

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

comdat-sharing-probability

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

profile-func-internal-id

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

min-vect-loop-bound

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

gcse-cost-distance-ratio

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

gcse-unrestricted-cost

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

max-hoist-depth

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

max-tail-merge-comparisons

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

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

vect-max-version-for-alignment-checks

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

vect-max-version-for-alias-checks

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

vect-max-peeling-for-alignment

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

max-iterations-to-track

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

hot-bb-count-ws-permille

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

hot-bb-frequency-fraction

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

max-predicted-iterations

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

builtin-expect-probability

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

align-threshold

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

align-loop-iterations

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

tracer-dynamic-coverage

tracer-dynamic-coverage-feedback

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

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

tracer-max-code-growth

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

tracer-min-branch-ratio

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

tracer-min-branch-probability

tracer-min-branch-probability-feedback

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

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

max-cse-path-length

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

max-cse-insns

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

ggc-min-expand

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

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

ggc-min-heapsize

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

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

max-reload-search-insns

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

max-cselib-memory-locations

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

max-sched-ready-insns

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

max-sched-region-blocks

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

max-pipeline-region-blocks

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

max-sched-region-insns

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

max-pipeline-region-insns

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

min-spec-prob

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

max-sched-extend-regions-iters

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

max-sched-insn-conflict-delay

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

sched-spec-prob-cutoff

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

sched-state-edge-prob-cutoff

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

sched-mem-true-dep-cost

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

selsched-max-lookahead

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

selsched-max-sched-times

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

selsched-insns-to-rename

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

sms-min-sc

Минимальное значение количества стадий, которые генерирует планировщик по модулю. Значение по умолчанию — 2.

max-last-value-rtl

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

max-combine-insns

Максимальное количество инструкций, которые объединитель RTL пытается объединить. Значение по умолчанию — 2 при -Og и 4 в противном случае.

integer-share-limit

Малые целочисленные константы могут использовать общую структуру данных, уменьшая использование памяти компилятором и увеличивая его скорость. Это устанавливает максимальное значение общей целочисленной константы. Значение по умолчанию равно 256.
ssp-buffer-size: Минимальный размер буферов (т.е. массивов), которые получают защиту от переполнения стека, когда используется -fstack-protection.
min-size-for-stack-sharing: Минимальный размер переменных, участвующих в совместном использовании слотов стека, когда оптимизация не включена. Значение по умолчанию равно 32.
max-jump-thread-duplication-stmts: Максимальное количество операторов, разрешенных в блоке, который нужно дублировать при выполнении прыжков между потоками.
max-fields-for-field-sensitive: Максимальное количество полей в структуре, обрабатываемой с учетом чувствительности к полям во время анализа указателей. Значение по умолчанию равно нулю для -O0 и -O1, и 100 для -Os, -O2 и -O3.
prefetch-latency: Приблизительное среднее количество инструкций, которые выполняются до завершения предварительной выборки. Расстояние, предварительно выбранное вперед, пропорционально этой константе. Увеличение этого числа может также привести к уменьшению количества потоков, подлежащих предварительной выборке (см. simultaneous-prefetches).
simultaneous-prefetches: Максимальное количество предварительных выборок, которые могут выполняться одновременно.
l1-cache-line-size: Размер строки кэша в кэше L1 в байтах.
l1-cache-size: Размер кэша L1 в килобайтах.
l2-cache-size: Размер кэша L2 в килобайтах.
min-insn-to-prefetch-ratio: Минимальное отношение между количеством инструкций и количеством предварительных выборок для включения предварительной выборки в цикле.
prefetch-min-insn-to-mem-ratio: Минимальное отношение между количеством инструкций и количеством обращений к памяти для включения предварительной выборки в цикле.
use-canonical-types: Нужно ли компилятору использовать «каноническую» систему типов. По умолчанию это всегда должно быть 1, что использует более эффективный внутренний механизм для сравнения типов в C++ и Objective-C++. Однако, если ошибки в канонической системе типов вызывают сбои компиляции, установите это значение в 0, чтобы отключить канонические типы.
switch-conversion-max-branch-ratio: Инициализация переключателя конвертации отказывается создавать массивы, которые больше, чем switch-conversion-max-branch-ratio умноженное на количество ветвей в переключателе.
max-partial-antic-length: Максимальная длина частичного антимножества, вычисленного во время оптимизации частичной избыточности дерева (-ftree-pre), при оптимизации -O3 и выше. Для некоторых видов исходного кода усовершенствованная оптимизация частичной избыточности может потреблять всю доступную память на хост-машине. Этот параметр устанавливает ограничение на длину вычисляемых множеств, предотвращая такое поведение. Установка значения 0 для этого параметра позволяет неограниченную длину множества.
sccvn-max-scc-size: Максимальный размер сильно связной компоненты (ССК) во время обработки 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, что является минимальным количеством регистров, необходимых для типичных инструкций. Это значение является лучшим, полученным из многочисленных экспериментов.
lra-inheritance-ebb-probability-cutoff: LRA пытается повторно использовать значения, перезагруженные в регистрах в последующих инструкциях. Эта оптимизация называется наследованием. EBB используется в качестве области для выполнения этой оптимизации. Параметр определяет минимальную вероятность прохождения перехода в процентах, используемую для добавления BB к наследованию EBB в LRA. Значение параметра по умолчанию равно 40. Значение было выбрано из многочисленных запусков SPEC2000 на x86-64.
loop-invariant-max-bbs-in-loop: Перемещение инвариантов цикла может быть очень дорогостоящим, как по времени компиляции, так и по объему требуемой памяти во время компиляции, с очень большими циклами. Циклы с большим количеством базовых блоков, чем этот параметр, не будут оптимизированы с помощью перемещения инвариантов цикла. Значение параметра по умолчанию равно 1000 для -O1 и 10000 для -O2 и выше.
loop-max-datarefs-for-datadeps: Построение зависимостей данных дорого для очень больших циклов. Этот параметр ограничивает количество ссылок на данные в циклах, которые рассматриваются для анализа зависимостей данных. Эти большие циклы не обрабатываются оптимизациями, использующими зависимости данных цикла.
max-vartrack-size: Устанавливает максимальное количество слотов таблицы хеширования, используемых во время анализа потока данных отслеживания переменных для любой функции. Если это ограничение превышено при включенном отслеживании переменных в присваиваниях, анализ для этой функции повторяется без него после удаления всех отладочных инструкций из функции. Если ограничение превышено даже без отладочных инструкций, анализ отслеживания переменных полностью отключается для функции. Установка параметра в ноль делает его неограниченным.
max-vartrack-expr-depth: Устанавливает максимальное количество уровней рекурсии при попытке сопоставить имена переменных или временные отладочные переменные с выражениями значений. Это позволяет уменьшить время компиляции в обмен на более полную информацию об отладке. Если это значение слишком мало, доступные выражения значений, которые можно было бы представить в отладочной информации, могут не использоваться; увеличение этого значения может позволить компилятору найти более сложные выражения отладки, но время компиляции и использование памяти могут увеличиться. Значение по умолчанию равно 12.
min-nondebug-insn-uid: Использовать идентификаторы, начиная с этого параметра, для инструкций, не связанных с отладкой. Диапазон значений ниже параметра зарезервирован исключительно для отладочных инструкций, созданных -fvar-tracking-assignments, но отладочные инструкции могут получить (непересекающиеся) идентификаторы выше, если зарезервированный диапазон исчерпан.
ipa-sra-ptr-growth-factor: IPA-SRA заменяет указатель на агрегат одним или несколькими новыми параметрами только тогда, когда их суммарный размер меньше или равен ipa-sra-ptr-growth-factor умноженному на размер исходного параметра-указателя.
sra-max-scalarization-size-Osize: Два прохода редукции скаляров агрегатов (SRA и IPA-SRA) стремятся заменить скалярные части агрегатов с использованием независимых скалярных переменных. Эти параметры контролируют максимальный размер агрегата в единицах хранения, который рассматривается для замены при компиляции на скорость (sra-max-scalarization-size-Ospeed) или размер (sra-max-scalarization-size-Osize) соответственно.
tm-max-aggregate-size: При создании копий локальных переменных потока в транзакции этот параметр указывает размер в байтах, после которого переменные сохраняются с помощью функций регистрации вместо пар кода сохранения/восстановления. Этот параметр применим только при использовании -fgnu-tm.
graphite-max-nb-scop-params: Для предотвращения экспоненциальных эффектов в преобразованиях Graphite циклов, количество параметров в статической управляющей части (SCoP) ограничено. Значение по умолчанию равно 10 параметрам. Переменная, значение которой неизвестно во время компиляции и определена вне SCoP, является параметром SCoP.
graphite-max-bbs-per-function: Для предотвращения экспоненциальных эффектов в обнаружении SCoP, размер функций, анализируемых Graphite, ограничен. Значение по умолчанию равно 100 базовым блокам.
loop-block-tile-size: Преобразования блокирования циклов или стрип-майнинга, включенные с помощью -floop-block или -floop-strip-mine, выполняют стрип-майнинг каждого цикла в цикловом вложенном цикле на заданное количество итераций. Длину полосы можно изменить, используя параметр loop-block-tile-size. Значение по умолчанию равно 51 итерации.
loop-unroll-jam-size: Укажите коэффициент разворачивания для опции -floop-unroll-and-jam. Значение по умолчанию равно 4.
loop-unroll-jam-depth: Укажите размерность, которая будет развернута (считая с самого внутреннего цикла) для -floop-unroll-and-jam. Значение по умолчанию равно 2.
ipa-cp-value-list-size: IPA-CP пытается отслеживать все возможные значения и типы, передаваемые параметру функции, чтобы распространить их и выполнить девиртуализацию. ipa-cp-value-list-size — максимальное количество значений и типов, хранимых им для одного формального параметра функции.
ipa-cp-eval-threshold: IPA-CP рассчитывает собственный рейтинг эвристики клонирования по прибыльности и выполняет эти возможности клонирования с рейтингами, которые превышают ipa-cp-eval-threshold.
ipa-cp-recursion-penalty: Процент штрафа, который получат рекурсивные функции, когда они оцениваются на клонирование.
ipa-cp-single-call-penalty: Процент штрафа, который получат функции, содержащие единственный вызов другой функции, когда они оцениваются на клонирование.
ipa-max-agg-items: IPA-CP также может распространять ряд скалярных значений, переданных в агрегате. ipa-max-agg-items контролирует максимальное количество таких значений на один параметр.
ipa-cp-loop-hint-bonus: Когда IPA-CP определяет, что кандидат на клонирование сделает известным количество итераций цикла, он добавляет бонус ipa-cp-loop-hint-bonus к рейтингу доходности кандидата.
ipa-cp-array-index-hint-bonus: Когда IPA-CP определяет, что кандидат на клонирование сделает известным индекс доступа к массиву, он добавляет бонус ipa-cp-array-index-hint-bonus к рейтингу доходности кандидата.
ipa-max-aa-steps: Во время анализа тела функции IPA-CP использует анализ алиасов, чтобы отслеживать значения, на которые указывают параметры функции. Чтобы не тратить слишком много времени на анализ огромных функций, он отказывается и рассматривает всю память как переписанную после проверки ipa-max-aa-steps инструкций, изменяющих память.
lto-partitions

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

lto-min-partition

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

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-store-data-races

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

case-values-threshold

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

tree-reassoc-width

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

sched-pressure-algorithm

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

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

max-slsr-cand-scan

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

asan-globals

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

asan-stack

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

asan-instrument-reads

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

asan-instrument-writes

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

asan-memintrin

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

asan-use-after-return

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

asan-instrumentation-with-call-threshold

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

chkp-max-ctor-size

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

max-fsm-thread-path-insns

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

max-fsm-thread-length

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

max-fsm-thread-paths

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

parloops-chunk-size

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

parloops-schedule

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

max-ssa-name-query-depth

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

hsa-gen-debug-stores

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

max-speculative-devirt-maydefs

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

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

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