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

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

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

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

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

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

Большинство оптимизаций полностью отключены при -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 
-fgcse  -fgcse-lm  
-fhoist-adjacent-loads 
-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 для программ, использующих вычисленные goto.

-O3

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

-fgcse-after-reload 
-finline-functions 
-fipa-cp-clone
-floop-interchange 
-floop-unroll-and-jam 
-fpeel-loops 
-fpredictive-commoning 
-fsplit-paths 
-ftree-loop-distribute-patterns 
-ftree-loop-distribution 
-ftree-loop-vectorize 
-ftree-partial-pre 
-ftree-slp-vectorize 
-funswitch-loops 
-fvect-cost-model 
-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 и специфичные для Fortran -fstack-arrays, если не указан -fmax-stack-var-size, и -fno-protect-parens.

-Og

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

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

-fbranch-count-reg  -fdelayed-branch 
-fif-conversion  -fif-conversion2  
-finline-functions-called-once 
-fmove-loop-invariants  -fssa-phiopt 
-ftree-bit-ccp  -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, то функция обычно не выводится как код ассемблера сама по себе.

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

-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

C++ ABI требует несколько точек входа для конструкторов и деструкторов: одну для базового подобъекта, одну для полного объекта и одну для виртуального деструктора, который вызывает оператор 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

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

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

END_OF_DOCUMENT_MARKER

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

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

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

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

Аргумент 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

Выполнение разрядно-условной константной пропаганды (bit constant propagation) на деревьях и пропагация информации об выравнивании указателей. Этот этап обрабатывает только локальные скалярные переменные и включён по умолчанию при -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.

-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

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

-ftree-loop-ivcanon

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

-ftree-scev-cprop

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

-fivopts

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

-ftree-parallelize-loops=n

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

-ftree-pta

Выполнение локального анализа точек-доступа (points-to analysis) функций в деревьях. Этот флаг включён по умолчанию при -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

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

-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-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 эквивалентны и означают, что циклы не выравниваются.

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

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

-funit-at-a-time

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

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

-fno-toplevel-reorder

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

-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. Вы можете переопределить их на стадии линковки.

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

Если 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 может использоваться для переопределения программы, используемой. Значение по умолчанию для n равно 1.

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

-flto-partition=alg

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

-flto-odr-type-merging

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

-flto-compression-level=n

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

-fuse-linker-plugin

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

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

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

-ffat-lto-objects

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

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

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

-fprofile-use=path

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

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

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

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

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

-fauto-profile

-fauto-profile=path

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

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

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

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

Например:

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

Затем используйте инструмент create_gcov для преобразования сырых данных профиля в формат, который может быть использован GCC. Вам также необходимо предоставить неотредактированный бинарный файл вашей программы этому инструменту. См. 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++, возможно, изменяя результат вычисления. ПРИМЕЧАНИЕ: переупорядочивание может изменить знак нуля, а также проигнорировать NaN и предотвратить или создать переполнение или недополнение (и поэтому не может использоваться в коде, который полагается на поведение округления, например, (x + 2**52) - 2**52). Также может переупорядочить сравнения с плавающей точкой и, следовательно, не может использоваться, когда требуются упорядоченные сравнения. Этот параметр требует, чтобы -fno-signed-zeros и -fno-trapping-math были активны. Кроме того, это не имеет большого смысла с -frounding-math. Для Fortran этот параметр автоматически включается, когда -fno-signed-zeros и -fno-trapping-math активны.

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

-freciprocal-math

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

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

-ffinite-math-only

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

По умолчанию включен -fno-finite-math-only.

-fno-signed-zeros

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

По умолчанию включен -fsigned-zeros.

-fno-trapping-math

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

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

По умолчанию включен -ftrapping-math.

-frounding-math

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

По умолчанию включен -fno-rounding-math.

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

-fsignaling-nans

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

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

По умолчанию включен -fno-signaling-nans.

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

-fno-fp-int-builtin-inexact

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

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

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

-fsingle-precision-constant

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

-fcx-limited-range

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

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

-fcx-fortran-rules

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

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

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

-fbranch-probabilities

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

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

-fbranch-target-load-optimize

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

-fbranch-target-load-optimize2

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

-fbtr-bb-exclusive

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

-fstdarg-opt

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

-fsection-anchors

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

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

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

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

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

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

--param name=value

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

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

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

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

END_OF_DOCUMENT_MARKER

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, в зависимости от того, статически ли определена предсказуемость ветвления. Единицы этого параметра такие же, как и для метрики внутренней seq_cost GCC. Компилятор попытается предоставить разумное значение по умолчанию для этого параметра, используя макрос цели 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 функциями.

max-inline-insns-small

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

max-inline-insns-size

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

uninlined-function-insns

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

uninlined-function-time

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

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

ipcp-unit-growth

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

large-stack-frame

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

large-stack-frame-growth

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

max-inline-insns-recursive

max-inline-insns-recursive-auto

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

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

max-inline-recursive-depth

max-inline-recursive-depth-auto

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

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

min-inline-recursive-probability

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

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

early-inlining-insns

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

max-early-inliner-iterations

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

comdat-sharing-probability

Вероятность (в процентах), что C++ 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

Максимальное количество похожих блоков базовых инструкций (bb) для сравнения 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

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

iv-consider-all-candidates-bound

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

iv-max-considered-uses

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

dse-max-alias-queries-per-store

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

avg-loop-niter

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

dse-max-object-size

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

scev-max-expr-size

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

scev-max-expr-complexity

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

max-tree-if-conversion-phi-args

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

vect-max-version-for-alignment-checks

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

vect-max-version-for-alias-checks

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

vect-max-peeling-for-alignment

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

max-iterations-to-track

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

hot-bb-count-ws-permille

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

hot-bb-frequency-fraction

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

max-predicted-iterations

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

builtin-expect-probability

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

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

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

Максимальное количество итераций по графу управления потоком для расширения областей. Значение 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

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

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.

min-nondebug-insn-uid

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

ipa-sra-ptr-growth-factor

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

sra-max-scalarization-size-Osize

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

sra-max-propagations

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

tm-max-aggregate-size

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

graphite-max-nb-scop-params

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

loop-block-tile-size

Преобразования блочного или полосового разбиения циклов, включенные с помощью -floop-block или -floop-strip-mine, разбивают каждый цикл в вложенных циклах на заданное количество итераций. Длина полосы может быть изменена с помощью параметра 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-recursion-penalty

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

ipa-cp-single-call-penalty

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

ipa-max-agg-items

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

ipa-cp-loop-hint-bonus

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

ipa-cp-array-index-hint-bonus

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

ipa-max-aa-steps

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

lto-partitions

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

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) или преобразование условных выражений (-ftree-loop-if-convert).

allow-store-data-races

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

case-values-threshold

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

tree-reassoc-width

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

sched-pressure-algorithm

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

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

max-slsr-cand-scan

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

asan-globals

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

asan-stack

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

asan-instrument-reads

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

asan-instrument-writes

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

asan-memintrin

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

asan-use-after-return

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

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

asan-instrumentation-with-call-threshold

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

use-after-scope-direct-emission-threshold

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

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 в таких функциях, как routines fold. Один уровень рекурсии соответствует слежению по цепочке use-def.

hsa-gen-debug-stores

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

max-speculative-devirt-maydefs

Максимальное количество may-def, которые мы анализируем при поиске 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: Максимальное количество команд в заголовке цикла, дублируемых проходом копирования заголовков циклов.
vect-epilogues-nomask: Включить векторизацию эпилога цикла с использованием меньшего размера вектора.
slp-max-insns-in-bb: Максимальное количество инструкций в базовом блоке, которое должно учитываться для векторизации SLP.
avoid-fma-max-bits: Максимальное количество битов, для которых мы избегаем создания FMAs.
sms-loop-average-count-threshold: Порог по среднему числу итераций цикла, рассматриваемый планировщиком swing modulo.
sms-dfa-history: Количество циклов, рассматриваемых планировщиком swing modulo при проверке конфликтов с использованием DFA.
hot-bb-count-fraction: Выбрать долю максимального количества повторений базового блока в программе, учитывая, что базовый блок должен быть горячим (используется в режиме без LTO).
max-inline-insns-recursive-auto: Максимальное количество инструкций, до которого может увеличиться функция, не использующая встраивание, при рекурсивном встраивании.
graphite-allow-codegen-errors: Должны ли ошибки кодогенерации быть ICE, когда указан -fchecking.
sms-max-ii-factor: Коэффициент для настройки верхней границы, которую планировщик swing modulo использует для планирования цикла.
lra-max-considered-reload-pseudos: Максимальное количество псевдонимов загрузки, которые учитываются при вытеснении не псевдонима загрузки.
max-pow-sqrt-depth: Максимальная глубина цепочек sqrt, используемых при синтезе возведения в степень по вещественному константе.
max-dse-active-local-stores: Максимальное количество активных локальных хранилищ в элиминации мёртвых хранилищ RTL.
asan-instrument-allocas: Включить защиту allocas/VLAs с помощью asan.
max-iterations-computation-cost: Предел стоимости выражения для вычисления числа итераций.
max-isl-operations: Максимальное количество операций isl, 0 означает неограниченное количество.
graphite-max-arrays-per-scop: Максимальное количество массивов на scop.
max-vartrack-reverse-op-size: Максимальный размер списка loc, для которого должны быть добавлены обратные операции.
unlikely-bb-count-fraction: Минимальная доля профильных прогонов, когда счет выполнения базового блока должен быть не низким, чтобы не считаться маловероятным.
tracer-dynamic-coverage-feedback: Процент функции, взвешенной по частоте выполнения, который должен быть покрыт формированием трассы. Используется при наличии обратной связи от профиля.
max-inline-recursive-depth-auto: Максимальная глубина рекурсивного встраивания для функций, не использующих встраивание.
fsm-scale-path-stmts: Коэффициент масштабирования, применяемый к числу операторов в пути потока, при сравнении с количеством (масштабированных) блоков.
fsm-maximum-phi-arguments: Максимальное количество аргументов, которые может иметь PHI, прежде чем планировщик FSM потоков не будет пытаться провести поток через блок.
uninit-control-dep-attempts: Максимальное количество вложенных вызовов для поиска зависимостей управления при анализе неинициализированных переменных.
indir-call-topn-profile: Отслеживать N ведущих целевых адресов в профиле косвенного вызова.
max-once-peeled-insns: Максимальное количество инструкций в отщипнутом цикле, который выполняется только один раз.
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, выполняемых при оптимизации определенных операторов или при определении их корректности перед выдачей диагностики.

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

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