Далее: Параметры программно-аппаратного обеспечения, Предыдущее: Параметры для отладки вашей программы, Вверх: Параметры командной строки GCC [Оглавление][Индекс]

3.11 Параметры, регулирующие оптимизацию ¶

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

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

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

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

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

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

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

-O

-O1

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

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

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

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

-O2

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

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

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

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

-O3

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

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

-O0

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

-Os

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

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

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

-Ofast

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

-Og

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

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

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

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

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

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

-fno-defer-pop

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

-fforward-propagate

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

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

-ffp-contract=style

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

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

-fomit-frame-pointer

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

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

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

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

-foptimize-sibling-calls

Оптимизировать вызовы с братьями и хвостовыми рекурсивными вызовами.

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

-foptimize-strlen

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

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

-fno-inline

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

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

-finline-small-functions

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

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

-findirect-inlining

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

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

-finline-functions

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

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

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

-finline-functions-called-once

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

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

-fearly-inlining

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

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

-fipa-sra

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

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

-finline-limit=n

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

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

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

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

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

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

-fno-keep-inline-dllexport

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

-fkeep-inline-functions

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

-fkeep-static-functions

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

-fkeep-static-consts

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

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

-fmerge-constants

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

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

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

-fmerge-all-constants

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

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

-fmodulo-sched

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

-fmodulo-sched-allow-regmoves

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

-fno-branch-count-reg

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

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

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

-fsplit-wide-types-early

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

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

-fcse-follow-jumps

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

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

-fcse-skip-blocks

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

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

-frerun-cse-after-loop

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

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

-fgcse

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

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

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

-fgcse-lm

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

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

-fgcse-sm

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

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

-fgcse-las

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

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

-fgcse-after-reload

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

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

-faggressive-loop-optimizations

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

-funconstrained-commons

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

-fcrossjumping

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

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

-fauto-inc-dec

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

-fdce

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

-fdse

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

-fif-conversion

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

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

-fif-conversion2

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

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

-fdeclone-ctor-dtor

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

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

-fdelete-null-pointer-checks

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

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

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

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

-fdevirtualize

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

-fdevirtualize-speculatively

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

-fdevirtualize-at-ltrans

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

-fexpensive-optimizations

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

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

-free

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

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

-fno-lifetime-dse

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

-flive-range-shrinkage

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

-fira-algorithm=algorithm

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

-fira-region=region

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

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

-fira-hoist-pressure

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

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

-fira-loop-pressure

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

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

-fno-ira-share-save-slots

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

-fno-ira-share-spill-slots

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

-flra-remat

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

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

-fdelayed-branch

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

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

-fschedule-insns

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

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

-fschedule-insns2

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

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

-fno-sched-interblock

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

-fno-sched-spec

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

-fsched-pressure

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

-fsched-spec-load

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

-fsched-spec-load-dangerous

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

-fsched-stalled-insns

-fsched-stalled-insns=n

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

-fsched-stalled-insns-dep

-fsched-stalled-insns-dep=n

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

-fsched2-use-superblocks

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

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

-fsched-group-heuristic

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

-fsched-critical-path-heuristic

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

-fsched-spec-insn-heuristic

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

-fsched-rank-heuristic

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

-fsched-last-insn-heuristic

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

-fsched-dep-count-heuristic

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

-freschedule-modulo-scheduled-loops

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

-fselective-scheduling

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

-fselective-scheduling2

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

-fsel-sched-pipelining

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

-fsel-sched-pipelining-outer-loops

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

-fsemantic-interposition

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

-fshrink-wrap

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

-fshrink-wrap-separate

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

-fcaller-saves

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

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

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

-fcombine-stack-adjustments

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

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

-fipa-ra

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

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

-fconserve-stack

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

-ftree-reassoc

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

-fcode-hoisting

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

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

-ftree-copy-prop

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

-fipa-pure-const

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

-fipa-reference

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

-fipa-reference-addressable

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

-fipa-stack-alignment

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

-fipa-pta

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

-fipa-profile

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

-fipa-cp

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

-fipa-cp-clone

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

-fipa-bit-cp

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

-fipa-vrp

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

-fipa-icf

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

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

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

-flive-patching=level

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

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

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

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

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

‘inline-clone’

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

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

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

‘inline-only-static’

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

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

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

Когда -flive-patching указан без значения, значение по умолчанию — inline-clone.

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

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

-fisolate-erroneous-paths-dereference

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

-fisolate-erroneous-paths-attribute

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

-ftree-sink

Выполняет передвижение сохранения в деревьях.

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

-ftree-bit-ccp

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

-ftree-ccp

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

-fssa-backprop

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

Флаг включен по умолчанию при -O и выше.

-fssa-phiopt

Выполняет сопоставление шаблонов с узлами SSA PHI для оптимизации условного кода.

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

-ftree-switch-conversion

Выполняет преобразование простых инициализаций в операторе switch в инициализации из скалярного массива.

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

-ftree-tail-merge

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

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

-ftree-dce

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

-ftree-builtin-call-dce

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

Этот флаг включен по умолчанию при -O2 и выше, если -Os также не указано.

-ffinite-loops

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

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

-ftree-dominator-opts

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

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

-ftree-dse

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

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

-ftree-ch

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

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

-ftree-loop-optimize

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

-ftree-loop-linear

-floop-strip-mine

-floop-block

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

-fgraphite-identity

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

-floop-nest-optimize

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

-floop-parallelize-all

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

-ftree-coalesce-vars

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

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

-ftree-loop-if-convert

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

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

-ftree-loop-distribution

Выполняет распределение циклов.

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

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

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

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

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

-ftree-loop-distribute-patterns

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

Этот флаг включен по умолчанию при -O2 и выше, а также при -fprofile-use и -fauto-profile.

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

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 нулями. Этот флаг включен по умолчанию при -O3. Он также включен при -fprofile-use и -fauto-profile.

-floop-interchange

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

Например, цикл

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

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

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

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

-floop-unroll-and-jam

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

-ftree-loop-im

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

-ftree-loop-ivcanon

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

-ftree-scev-cprop

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

-fivopts

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

-ftree-parallelize-loops=n

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

-ftree-pta

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

-ftree-sra

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

-fstore-merging

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

-ftree-ter

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

-ftree-slsr

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

-ftree-vectorize

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

-ftree-loop-vectorize

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

-ftree-slp-vectorize

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

-fvect-cost-model=model

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

-fsimd-cost-model=model

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

-ftree-vrp

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

-fsplit-paths

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

-fsplit-ivs-in-unroller

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

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

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

-fvariable-expansion-in-unroller

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

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

-fpartial-inlining

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

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

-fpredictive-commoning

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

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

-fprefetch-loop-arrays

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

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

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

-fno-printf-return-value

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

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

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

-fno-peephole

-fno-peephole2

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

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

-fno-guess-branch-probability

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

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

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

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

-freorder-blocks

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

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

-freorder-blocks-algorithm=algorithm

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

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

-freorder-blocks-and-partition

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

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

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

-freorder-functions

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

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

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

-fstrict-aliasing

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

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

union a_union {
  int i;
  double d;
};

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

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

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

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

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

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

-falign-functions

-falign-functions=n

-falign-functions=n:m

-falign-functions=n:m:n2

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

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

Если m не указано, оно по умолчанию равно n.

Примеры: -falign-functions=32 выравнивает функции до ближайшей 32-байтовой границы, -falign-functions=24 выравнивает до ближайшей 32-байтовой границы только если это можно сделать, пропустив 23 байта или меньше, -falign-functions=32:7 выравнивает до ближайшей 32-байтовой границы только если это можно сделать, пропустив 6 байтов или меньше.

Вторая пара значений n2:m2 позволяет указать дополнительное выравнивание: -falign-functions=64:7:32:3 выравнивает до ближайшей 64-байтовой границы, если это можно сделать, пропустив 6 байтов или меньше, в противном случае выравнивает до ближайшей 32-байтовой границы, если это можно сделать, пропустив 2 байта или меньше. Если m2 не указано, оно по умолчанию равно n2.

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

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

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

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

-flimit-function-alignment

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

-falign-labels

-falign-labels=n

-falign-labels=n:m

-falign-labels=n:m:n2

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

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

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

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

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

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

-falign-loops

-falign-loops=n

-falign-loops=n:m

-falign-loops=n:m:n2

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

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

Если -falign-labels больше этого значения, используется его значение.

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

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

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

-falign-jumps

-falign-jumps=n

-falign-jumps=n:m

-falign-jumps=n:m:n2

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

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

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

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

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

-fno-allocation-dce

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

-fallow-store-data-races

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

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

-funit-at-a-time

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

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

-fno-toplevel-reorder

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

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

-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. Вы всегда можете переопределить автоматическое решение о выполнении оптимизации на этапе компоновки, передав -fno-lto команде компоновки.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-flto-partition=alg

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

-flto-compression-level=n

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

-fuse-linker-plugin

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

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

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

-ffat-lto-objects

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

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

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

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

-fcompare-elim

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

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

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

-fcprop-registers

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

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

-fprofile-correction

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

Этот параметр включен с -fauto-profile.

-fprofile-partial-training

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

-fprofile-use

-fprofile-use=path

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

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

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

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

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

-fauto-profile

-fauto-profile=path

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

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

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

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

Например:

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

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

Например:

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

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

-ffloat-store

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

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

-fexcess-precision=style

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

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

-ffast-math

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

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

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

-fno-math-errno

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

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

Значение по умолчанию — -fmath-errno.

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

-funsafe-math-optimizations

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

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

-fassociative-math

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

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

-freciprocal-math

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

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

-ffinite-math-only

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

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

-fno-signed-zeros

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

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

-fno-trapping-math

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

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

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

-frounding-math

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

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

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

-fsignaling-nans

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

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

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

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

-fno-fp-int-builtin-inexact

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

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

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

-fsingle-precision-constant

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

-fcx-limited-range

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

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

-fcx-fortran-rules

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

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

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

-fbranch-probabilities

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

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

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

-fprofile-values

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

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

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

-fprofile-reorder-functions

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

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

-fvpt

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

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

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

-frename-registers

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

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

-fschedule-fusion

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

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

-ftracer

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

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

-funroll-loops

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

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

-funroll-all-loops

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

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

-fpeel-loops

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

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

-fmove-loop-invariants

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

-fsplit-loops

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

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

-funswitch-loops

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

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

-fversion-loops-for-strides

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

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

становится:

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

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

-ffunction-sections

-fdata-sections

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

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

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

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

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

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

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

Для получения минимального, максимального и значения по умолчанию параметра можно использовать параметры --help=param -Q.

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

predictable-branch-outcome

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

max-rtl-if-conversion-insns

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

max-rtl-if-conversion-predictable-cost

max-rtl-if-conversion-unpredictable-cost

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

max-crossjump-edges

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

min-crossjump-insns

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

max-grow-copy-bb-insns

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

max-goto-duplication-insns

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

max-delay-slot-insn-search

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

max-delay-slot-live-search

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

max-gcse-memory

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

max-gcse-insertion-ratio

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

max-pending-list-length

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

max-modulo-backtrack-attempts

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

max-inline-insns-single

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

max-inline-insns-auto

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

max-inline-insns-small

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

max-inline-insns-size

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

uninlined-function-insns

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

uninlined-function-time

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

inline-heuristics-hint-percent

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

uninlined-thunk-insns

uninlined-thunk-time

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

inline-min-speedup

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

large-function-insns

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

large-function-growth

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

large-unit-insns

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

inline-unit-growth

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

ipa-cp-unit-growth

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

large-stack-frame

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

large-stack-frame-growth

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

max-inline-insns-recursive

max-inline-insns-recursive-auto

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

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

max-inline-recursive-depth

max-inline-recursive-depth-auto

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

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

min-inline-recursive-probability

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

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

early-inlining-insns

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

max-early-inliner-iterations

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

comdat-sharing-probability

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

profile-func-internal-id

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

min-vect-loop-bound

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

gcse-cost-distance-ratio

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

gcse-unrestricted-cost

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

max-hoist-depth

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

max-tail-merge-comparisons

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

max-tail-merge-iterations

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

store-merging-allow-unaligned

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

max-stores-to-merge

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

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

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

min-loop-cond-split-prob

Когда доступна информация профиля FDO, min-loop-cond-split-prob задаёт минимальный порог вероятности для условия полуинвариантного оператора, который запускает разделение цикла.

iv-consider-all-candidates-bound

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

iv-max-considered-uses

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

iv-always-prune-cand-set-bound

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

avg-loop-niter

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

dse-max-object-size

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

dse-max-alias-queries-per-store

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

scev-max-expr-size

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

scev-max-expr-complexity

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

max-tree-if-conversion-phi-args

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

vect-max-version-for-alignment-checks

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

vect-max-version-for-alias-checks

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

vect-max-peeling-for-alignment

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

max-iterations-to-track

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

hot-bb-count-fraction

Знаменатель n дроби 1/n максимального количества выполнений основного блока во всей программе, которое основной блок должен иметь как минимум, чтобы считаться горячим. По умолчанию 10000, что означает, что основной блок считается горячим, если его количество выполнений больше, чем 1/10000 от максимального количества выполнений. 0 означает, что он никогда не считается горячим. Используется в режиме без LTO.

hot-bb-count-ws-permille

Число самых часто выполняемых промилле, изменяющихся от 0 до 1000, профилированного выполнения всей программы, к которому должно относиться количество выполнений основного блока, чтобы он считался горячим. По умолчанию 990, что означает, что основной блок считается горячим, если его количество выполнений вносит вклад в верхние 990 промилле, или 99,0%, профилированного выполнения всей программы. 0 означает, что он никогда не считается горячим. Используется в режиме LTO.

hot-bb-frequency-fraction

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

unlikely-bb-count-fraction

Знаменатель n дроби 1/n количества профилированных запусков всей программы, ниже которого должно находиться количество выполнений основного блока, чтобы основной блок считался маловероятным для выполнения. По умолчанию 20, что означает, что основной блок считается маловероятным для выполнения, если он выполняется меньше, чем 1/20, или 5%, от запусков программы. 0 означает, что он всегда считается маловероятным для выполнения.

max-predicted-iterations

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

builtin-expect-probability

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

builtin-string-cmp-inline-length

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

align-threshold

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

align-loop-iterations

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

tracer-dynamic-coverage

tracer-dynamic-coverage-feedback

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

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

tracer-max-code-growth

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

tracer-min-branch-ratio

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

tracer-min-branch-probability

tracer-min-branch-probability-feedback

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

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

stack-clash-protection-guard-size

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

stack-clash-protection-probe-interval

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

max-cse-path-length

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

max-cse-insns

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

ggc-min-expand

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

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

ggc-min-heapsize

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

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

max-reload-search-insns

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

max-cselib-memory-locations

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

max-sched-ready-insns

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

max-sched-region-blocks

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

max-pipeline-region-blocks

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

max-sched-region-insns

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

max-pipeline-region-insns

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

min-spec-prob

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

max-sched-extend-regions-iters

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

max-sched-insn-conflict-delay

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

sched-spec-prob-cutoff

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

sched-state-edge-prob-cutoff

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

sched-mem-true-dep-cost

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

selsched-max-lookahead

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

selsched-max-sched-times

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

selsched-insns-to-rename

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

sms-min-sc

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

max-last-value-rtl

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

max-combine-insns

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

integer-share-limit

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

ssp-buffer-size

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

min-size-for-stack-sharing

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

max-jump-thread-duplication-stmts

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

max-fields-for-field-sensitive

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

prefetch-latency

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

simultaneous-prefetches

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

l1-cache-line-size

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

l1-cache-size

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

l2-cache-size

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

prefetch-dynamic-strides

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

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

prefetch-minimum-stride

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

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

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

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

loop-interchange-max-num-stmts

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

loop-interchange-stride-ratio

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

min-insn-to-prefetch-ratio

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

prefetch-min-insn-to-mem-ratio

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

use-canonical-types

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

switch-conversion-max-branch-ratio

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

max-partial-antic-length

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

rpo-vn-max-loop-depth

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

sccvn-max-alias-queries-per-access

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

ira-max-loops-num

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

ira-max-conflict-table-size

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

ira-loop-reserved-regs

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

lra-inheritance-ebb-probability-cutoff

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

loop-invariant-max-bbs-in-loop

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

loop-max-datarefs-for-datadeps

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

max-vartrack-size

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

max-vartrack-expr-depth

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

max-debug-marker-count

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

max-debug-marker-count

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

ipa-sra-ptr-growth-factor

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

ipa-sra-max-replacements

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

sra-max-scalarization-size-Ospeed

sra-max-scalarization-size-Osize

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

sra-max-propagations

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

tm-max-aggregate-size

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

graphite-max-nb-scop-params

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

loop-block-tile-size

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

ipa-cp-value-list-size

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

ipa-cp-eval-threshold

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

ipa-cp-max-recursive-depth

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

ipa-cp-min-recursive-probability

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

ipa-cp-recursion-penalty

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

ipa-cp-single-call-penalty

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

ipa-max-agg-items

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

ipa-cp-loop-hint-bonus

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

ipa-max-aa-steps

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

ipa-max-switch-predicate-bounds

Максимальное число граничных точек диапазонов значений оператора switch. Для операторов switch, превышающих этот предел, IPA-CP не будет строить предикат стоимости клонирования, используемый для оценки выгоды от клонирования, для оператора default оператора switch.

ipa-max-param-expr-ops

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

lto-partitions

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

lto-min-partition

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

lto-max-partition

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

lto-max-streaming-parallelism

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

cxx-max-namespaces-for-diagnostic-help

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

sink-frequency-threshold

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

max-stores-to-sink

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

case-values-threshold

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

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

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

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

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

tree-reassoc-width

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

sched-pressure-algorithm

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

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

max-slsr-cand-scan

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

asan-globals

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

asan-stack

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

asan-instrument-reads

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

asan-instrument-writes

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

asan-memintrin

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

asan-use-after-return

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

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

asan-instrumentation-with-call-threshold

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

use-after-scope-direct-emission-threshold

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

max-fsm-thread-path-insns

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

max-fsm-thread-length

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

max-fsm-thread-paths

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

parloops-chunk-size

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

parloops-schedule

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

parloops-min-per-thread

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

max-ssa-name-query-depth

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

hsa-gen-debug-stores

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

max-speculative-devirt-maydefs

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

max-vrp-switch-assertions

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

unroll-jam-min-percent

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

unroll-jam-max-unroll

Максимальное количество раз, которое внешний цикл должен быть развёрнут преобразованием unroll-and-jam.

max-rtl-if-conversion-unpredictable-cost

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

max-variable-expansions-in-unroller

Если используется -fvariable-expansion-in-unroller, максимальное количество раз, которое отдельная переменная будет расширена во время развёртывания цикла.

tracer-min-branch-probability-feedback

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

partial-inlining-entry-probability

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

max-tracked-strlens

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

gcse-after-reload-partial-fraction

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

gcse-after-reload-critical-fraction

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

max-loop-header-insns

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

vect-epilogues-nomask

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

slp-max-insns-in-bb

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

avoid-fma-max-bits

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

sms-loop-average-count-threshold

Порог среднего количества итераций цикла, рассматриваемого модулем планирования swing.

sms-dfa-history

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

max-inline-insns-recursive-auto

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

graphite-allow-codegen-errors

Должны ли ошибки кодогенерации быть ICE при -fchecking.

sms-max-ii-factor

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

lra-max-considered-reload-pseudos

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

max-pow-sqrt-depth

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

max-dse-active-local-stores

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

asan-instrument-allocas

Включить защиту allocas/VLAs asan.

max-iterations-computation-cost

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

max-isl-operations

Максимальное количество операций isl, 0 означает неограниченное.

graphite-max-arrays-per-scop

Максимальное количество массивов на scop.

max-vartrack-reverse-op-size

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

tracer-dynamic-coverage-feedback

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

max-inline-recursive-depth-auto

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

fsm-scale-path-stmts

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

fsm-maximum-phi-arguments

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

uninit-control-dep-attempts

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

sra-max-scalarization-size-Osize

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

fsm-scale-path-blocks

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

sched-autopref-queue-depth

Флаг управления моделью планировщика аппаратного автопрефечера. Количество циклов предвидения, на которые смотрит модель; при « ’» включить только эвристику сортировки инструкций.

loop-versioning-max-inner-insns

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

loop-versioning-max-outer-insns

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

ssa-name-def-chain-limit

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

store-merging-max-size

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

hash-table-verification-limit

Количество элементов, для которых выполняется проверка хеш-таблицы для каждого искомого элемента.

max-find-base-term-values

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

analyzer-max-enodes-per-program-point

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

analyzer-min-snodes-for-call-summary

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

analyzer-max-recursion-depth

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

gimple-fe-computed-hot-bb-threshold

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

analyzer-bb-explosion-factor

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

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

aarch64-sve-compare-costs

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

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

aarch64-float-recp-precision

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

aarch64-double-recp-precision

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

aarch64-autovec-preference

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

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

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

Далее: Параметры инструментирования программы, Предыдущее: Параметры отладки программы, Вверх: Параметры команды GCC [Оглавление][Индекс]

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