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

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

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

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

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

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

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

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

-O

-O1

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

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

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

-fauto-inc-dec 
-fbranch-count-reg 
-fcombine-stack-adjustments 
-fcompare-elim 
-fcprop-registers 
-fdce 
-fdefer-pop 
-fdelayed-branch 
-fdse 
-fforward-propagate 
-fguess-branch-probability 
-fif-conversion 
-fif-conversion2 
-finline-functions-called-once 
-fipa-modref 
-fipa-profile 
-fipa-pure-const 
-fipa-reference 
-fipa-reference-addressable 
-fmerge-constants 
-fmove-loop-invariants 
-fmove-loop-stores
-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 включает все флаги оптимизации, указанные в -O1. Он также включает следующие флаги оптимизации:

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

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

-O3

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

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

-O0

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

-Os

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

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

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

-Ofast

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

-Og

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

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

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

-Oz

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

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

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

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

-fno-defer-pop

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

-fforward-propagate

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

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

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

-foptimize-sibling-calls

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

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

-foptimize-strlen

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

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

-fno-inline

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

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

-finline-small-functions

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

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

-findirect-inlining

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

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

-finline-functions

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

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

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

-finline-functions-called-once

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

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

-fearly-inlining

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

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

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

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

-fsplit-wide-types

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

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

-fsplit-wide-types-early

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

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

-fcse-follow-jumps

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

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

-fcse-skip-blocks

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

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

-frerun-cse-after-loop

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

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

-fgcse

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

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

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

-fgcse-lm

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

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

-fgcse-sm

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

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

-fgcse-las

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

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

-fgcse-after-reload

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

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

-faggressive-loop-optimizations

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

-funconstrained-commons

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

-fcrossjumping

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

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

-fauto-inc-dec

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

-fdce

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

-fdse

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

-fif-conversion

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

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

-fif-conversion2

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

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

-fdeclone-ctor-dtor

C++ ABI требует нескольких точек входа для конструкторов и деструкторов: одной для базового подобъекта, одной для полного объекта и одной для виртуального деструктора, который затем вызывает operator 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’, что указывает на алгоритм окрашивания Чейтина-Бриггса. Алгоритм окрашивания Чейтина-Бриггса не реализован для всех архитектур, но для тех целей, которые его поддерживают, он является по умолчанию, так как генерирует более эффективный код.

-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

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

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

-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

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

-fcode-hoisting

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

-ftree-pre

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

-ftree-partial-pre

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

-ftree-forwprop

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

-ftree-fre

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

-ftree-phiprop

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

-fhoist-adjacent-loads

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

-ftree-copy-prop

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

-fipa-pure-const

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

-fipa-reference

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

-fipa-reference-addressable

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

-fipa-stack-alignment

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

-fipa-pta

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

-fipa-profile

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

-fipa-modref

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

-fipa-cp

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

-fipa-cp-clone

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

-fipa-bit-cp

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

-fipa-vrp

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

-fipa-icf

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

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

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

-flive-patching=level

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

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

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

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

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

‘inline-clone’

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

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

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

‘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

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

-ftree-bit-ccp

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

-ftree-ccp

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

-fssa-backprop

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

-fssa-phiopt

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

-ftree-switch-conversion

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

-ftree-tail-merge

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

-ftree-dce

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

-ftree-builtin-call-dce

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

-ffinite-loops

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

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

-ftree-dominator-opts

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

-ftree-dse

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

-ftree-ch

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

-ftree-loop-optimize

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

-ftree-loop-linear

-floop-strip-mine

-floop-block

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

-fgraphite-identity

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

-floop-nest-optimize

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

-floop-parallelize-all

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

-ftree-coalesce-vars

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

-ftree-loop-if-convert

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

-ftree-loop-distribution

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

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

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

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

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

-ftree-loop-distribute-patterns

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

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

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

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

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

и цикл инициализации преобразуется в вызов memset нулем. Этот флаг включен по умолчанию в -O3. Он также включен в -fprofile-use и -fauto-profile.

-floop-interchange

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

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

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

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

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

-floop-unroll-and-jam

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

-ftree-loop-im

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

-ftree-loop-ivcanon

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

-ftree-scev-cprop

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

-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. Включён по умолчанию при -O1 и выше.

-ftree-slsr

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

-ftree-vectorize

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

-ftree-loop-vectorize

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

-ftree-slp-vectorize

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

-ftrivial-auto-var-init=choice

Инициализировать автоматические переменные либо шаблоном, либо нулями, чтобы повысить безопасность и предсказуемость программы, предотвратив раскрытие и использование неинициализированной памяти. GCC по-прежнему считает автоматическую переменную, у которой нет явной инициализации, неинициализированной. -Wuninitialized и -Wanalyzer-use-of-uninitialized-value по-прежнему будут сообщать сообщения об ошибках для таких автоматических переменных. С этим параметром GCC также инициализирует любое заполнение автоматических переменных, имеющих типы структур или объединений, нулями. Однако текущая реализация не может инициализировать автоматические переменные, которые объявлены между управляющим выражением и первой веткой оператора switch. Используя -Wtrivial-auto-var-init, чтобы сообщить обо всех таких случаях.

Три значения choice:

‘uninitialized’ — не инициализировать автоматические переменные. Это стандартное поведение для C и C++.
‘pattern’ — инициализировать автоматические переменные значениями, которые, вероятно, превратят ошибки логики в сбои, легко распознаются в дампе сбоя и не являются значениями, на которых программисты могут полагаться для полезной семантики программы. Текущее значение — повторяющийся по байтам шаблон с байтом "0xFE". Значения, используемые для инициализации шаблоном, могут быть изменены в будущем.
‘zero’ — инициализировать автоматические переменные нулями.

По умолчанию — ‘uninitialized’.

Вы можете управлять этим поведением для конкретной переменной, используя атрибут переменной uninitialized (см. Атрибуты переменных).

-fvect-cost-model=model

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

Модель затрат по умолчанию зависит от других флагов оптимизации и либо ‘dynamic’, либо ‘cheap’.

-fsimd-cost-model=model

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

-ftree-vrp

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

-fsplit-paths

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

-fsplit-ivs-in-unroller

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

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

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

-fvariable-expansion-in-unroller

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

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

-fpartial-inlining

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

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

-fpredictive-commoning

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

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

-fprefetch-loop-arrays

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

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

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

-fno-printf-return-value

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

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

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

-fno-peephole

-fno-peephole2

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

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

-fno-guess-branch-probability

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

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

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

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

-freorder-blocks

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

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

-freorder-blocks-algorithm=algorithm

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

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

-freorder-blocks-and-partition

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

-fipa-strict-aliasing

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

Опция -fipa-strict-aliasing включена по умолчанию и эффективна только в сочетании с -fstrict-aliasing.

-falign-functions

-falign-functions=n

-falign-functions=n:m

-falign-functions=n:m:n2

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

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

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

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

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

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

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

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

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

-flimit-function-alignment

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

-falign-labels

-falign-labels=n

-falign-labels=n:m

-falign-labels=n:m:n2

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

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

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

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

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

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

-falign-loops

-falign-loops=n

-falign-loops=n:m

-falign-loops=n:m:n2

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

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

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

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

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

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

-falign-jumps

-falign-jumps=n

-falign-jumps=n:m

-falign-jumps=n:m:n2

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

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

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

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

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

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

-fno-allocation-dce

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

-fallow-store-data-races

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

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

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

-funit-at-a-time

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

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

-fno-toplevel-reorder

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

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

-fweb

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

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

-fwhole-program

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

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

-flto[=n]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Следующие параметры -fPIC, -fpic, -fpie и -fPIE объединяются на основе следующей схемы:

-fPIC + -fpic = -fpic
-fPIC + -fno-pic = -fno-pic
-fpic/-fPIC + (no option) = (no option)
-fPIC + -fPIE = -fPIE
-fpic + -fPIE = -fpie
-fPIC/-fpic + -fpie = -fpie

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-flto-partition=alg

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

-flto-compression-level=n

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

-fuse-linker-plugin

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

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

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

-ffat-lto-objects

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

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

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

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

-fcompare-elim

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

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

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

-fcprop-registers

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

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

-fprofile-correction

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

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

-fprofile-partial-training

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

-fprofile-use

-fprofile-use=path

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

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

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

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

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

-funsafe-math-optimizations

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

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

-fassociative-math

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

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

-freciprocal-math

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

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

-ffinite-math-only

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

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

-fno-signed-zeros

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

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

-fno-trapping-math

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

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

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

-frounding-math

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

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

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

-fsignaling-nans

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

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

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

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

-fno-fp-int-builtin-inexact

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

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

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

-fsingle-precision-constant

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

-fcx-limited-range

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

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

-fcx-fortran-rules

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

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

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

-fbranch-probabilities

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

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

-fmove-loop-stores

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

-fsplit-loops

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

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

-funswitch-loops

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

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

-fversion-loops-for-strides

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

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

становится:

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

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

-ffunction-sections

-fdata-sections

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

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

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

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

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

-fstdarg-opt

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

-fsection-anchors

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

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

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

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

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

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

-fzero-call-used-regs=choice

Обнулить используемые при вызове регистры при возвращении из функции, чтобы повысить безопасность программы, либо смягчить атаки Return-Oriented Programming (ROP), либо предотвратить утечку информации через регистры.

Возможные значения choice такие же, как и для атрибута zero_call_used_regs (см. Атрибуты функций). По умолчанию ‘skip’.

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

--param name=value

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

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

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

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

predictable-branch-outcome

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

max-rtl-if-conversion-insns

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

max-rtl-if-conversion-predictable-cost

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

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

max-gcse-insertion-ratio

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

max-pending-list-length

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

max-modulo-backtrack-attempts

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

max-inline-functions-called-once-loop-depth

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

max-inline-functions-called-once-insns

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

max-inline-insns-single

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

max-inline-insns-auto

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

max-inline-insns-small

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

max-inline-insns-size

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

uninlined-function-insns

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

uninlined-function-time

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

inline-heuristics-hint-percent

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

uninlined-thunk-insns

uninlined-thunk-time

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

inline-min-speedup

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

large-function-insns

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

large-function-growth

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

large-unit-insns

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

lazy-modules

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

inline-unit-growth

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

ipa-cp-unit-growth

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

ipa-cp-large-unit-insns

Размер трансляционной единицы, который проход IPA-CP считает большим.

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

modref-max-bases

modref-max-refs

modref-max-accesses

Указывает максимальное количество базовых указателей, ссылок и обращений, хранящихся для одной функции при анализе mod/ref.

modref-max-tests

Указывает максимальное количество тестов, которые может выполнить оракул alias для развязки расположений памяти с использованием информации mod/ref. Этот параметр должен быть больше, чем --param modref-max-bases и --param modref-max-refs.

modref-max-depth

Указывает максимальную глубину обхода DFS, используемого анализом modref escape. Установка в 0 полностью отключает анализ.

modref-max-escape-points

Указывает максимальное количество точек выхода, отслеживаемых modref на имя SSA.

modref-max-adjustments

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

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

Максимальное количество похожих блоков basic block для сравнения с блоком. Это используется для предотвращения квадратичного поведения в объединении хвостов дерева.

max-tail-merge-iterations

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

store-merging-allow-unaligned

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

max-stores-to-merge

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

max-store-chains-to-track

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

max-stores-to-track

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

max-unrolled-insns

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

max-average-unrolled-insns

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

max-unroll-times

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

max-peeled-insns

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

max-peel-times

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

max-peel-branches

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

max-completely-peeled-insns

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

max-completely-peel-times

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

max-completely-peel-loop-nest-depth

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

max-unswitch-insns

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

max-unswitch-level

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

lim-expensive

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

min-loop-cond-split-prob

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

iv-consider-all-candidates-bound

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

iv-max-considered-uses

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

iv-always-prune-cand-set-bound

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

avg-loop-niter

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

dse-max-object-size

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

dse-max-alias-queries-per-store

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

scev-max-expr-size

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

vect-max-version-for-alignment-checks

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

max-tree-if-conversion-phi-args

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

vect-max-version-for-alignment-checks

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

vect-max-version-for-alias-checks

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

vect-max-peeling-for-alignment

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

max-iterations-to-track

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

hot-bb-count-fraction

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

hot-bb-count-ws-permille

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

hot-bb-frequency-fraction

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

unlikely-bb-count-fraction

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

max-predicted-iterations

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

builtin-expect-probability

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

builtin-string-cmp-inline-length

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

align-threshold

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

align-loop-iterations

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

tracer-dynamic-coverage

tracer-dynamic-coverage-feedback

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

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

tracer-max-code-growth

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

tracer-min-branch-ratio

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

tracer-min-branch-probability

tracer-min-branch-probability-feedback

Прекратить дальнейший рост, если вероятность лучшего края ниже этого порога.

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

stack-clash-protection-guard-size

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

stack-clash-protection-probe-interval

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

max-cse-path-length

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

max-cse-insns

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

ggc-min-expand

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

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

ggc-min-heapsize

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

По умолчанию это меньшее из значений RAM/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

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

max-pipeline-region-insns

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

min-spec-prob

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

max-sched-extend-regions-iters

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

max-sched-insn-conflict-delay

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

sched-spec-prob-cutoff

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

sched-state-edge-prob-cutoff

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

sched-mem-true-dep-cost

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

selsched-max-lookahead

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

selsched-max-sched-times

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

selsched-insns-to-rename

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

sms-min-sc

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

max-last-value-rtl

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

max-combine-insns

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

integer-share-limit

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

ssp-buffer-size

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

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

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

destructive-interference-size

constructive-interference-size

Значения для переменных C++17 std::hardware_destructive_interference_size и std::hardware_constructive_interference_size. Размер разрушительного интерференции — это минимально рекомендуемое смещение между двумя независимыми одновременно обращёнными объектами; размер конструктивной интерференции — это максимально рекомендуемый размер смежных областей памяти, обращённых вместе. Обычно оба будут размером строки кэша L1 для целевого устройства в байтах. Для общей цели, охватывающей ряд размеров строк кэша L1, обычно размер конструктивной интерференции будет меньше диапазона, а размер разрушительной — больше.

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

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

См. также -Winterference-size.

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). Количество доступных регистров, зарезервированных для других целей, задаётся этим параметром. Значение параметра по умолчанию выбрано на основе многочисленных экспериментов.
ira-consider-dup-in-all-alts: Заставить IRA учитывать ограничение соответствия (дублированный номер операнда) в приоритетных альтернативах для предпочтительного класса регистров. Если значение установлено в ноль, это означает, что IRA учитывает ограничение соответствия только в единственной доступной альтернативе с соответствующим классом регистров. В противном случае это означает, что IRA проверит все доступные альтернативы для предпочтительного класса регистров, даже если уже найдено решение с соответствующим классом регистров и учтёт найденное ограничение соответствия.
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: Использовать идентификаторы, начиная с этого параметра, для инструкций, не относящихся к отладке. Диапазон значений ниже параметра зарезервирован исключительно для отладочных инструкций, созданных с помощью -fvar-tracking-assignments, но отладочные инструкции могут получить (непересекающиеся) идентификаторы выше этого значения, если зарезервированный диапазон исчерпан.
ipa-sra-ptr-growth-factor: IPA-SRA заменяет указатель на агрегат одним или несколькими новыми параметрами только тогда, когда их совокупный размер меньше или равен ipa-sra-ptr-growth-factor умноженному на размер исходного параметра указателя.
ipa-sra-max-replacements: Максимальное количество частей агрегата, отслеживаемых IPA-SRA. Следовательно, это также максимальное количество замен формального параметра.
sra-max-scalarization-size-Ospeed
sra-max-scalarization-size-Osize: Два прохода по скалярному сокращению агрегатов (SRA и IPA-SRA) нацелены на замену скалярных частей агрегатов использованием независимых скалярных переменных. Эти параметры управляют максимальным размером агрегата в единицах хранения, который рассматривается для замены при компиляции для скорости (sra-max-scalarization-size-Ospeed) или размера (sra-max-scalarization-size-Osize) соответственно.
sra-max-propagations: Максимальное количество искусственных обращений, которые Scalar Replacement of Aggregates (SRA) будет отслеживать для одной локальной переменной, для облегчения распространения копий.
tm-max-aggregate-size: При создании копий переменных, локальных для потока, в транзакции этот параметр задаёт размер в байтах, после которого переменные сохраняются с помощью функций регистрации вместо пар кода save/restore. Этот параметр применим только при использовании -fgnu-tm.
graphite-max-nb-scop-params: Чтобы избежать экспоненциального эффекта в преобразованиях циклов Graphite, количество параметров в Статической управляющей части (SCoP) ограничено. Значение ноль может быть использовано для снятия ограничения. Переменная, значение которой неизвестно на стадии компиляции и определена вне SCoP, является параметром SCoP.
loop-block-tile-size: Преобразования блокирования циклов или дробления, включенные с помощью -floop-block или -floop-strip-mine, дробят каждый цикл в цикловой вложенности на заданное число итераций. Размер фрагмента может быть изменён с помощью параметра loop-block-tile-size.
ipa-jump-function-lookups: Указывает количество посещённых инструкций при определении смещения функции перехода.
ipa-cp-value-list-size: IPA-CP пытается отследить все возможные значения и типы, передаваемые в параметр функции, чтобы распространить их и выполнить девиртуализацию. ipa-cp-value-list-size — максимальное количество значений и типов, хранимых для каждого формального параметра функции.
ipa-cp-eval-threshold: IPA-CP рассчитывает собственную оценку эвристик клонирования и выполняет те возможности клонирования со значениями, которые превышают ipa-cp-eval-threshold.
ipa-cp-max-recursive-depth: Максимальная глубина рекурсивного клонирования для рекурсивной функции.
ipa-cp-min-recursive-probability: Рекурсивное клонирование только в том случае, если вероятность вызова превышает заданный параметр.
ipa-cp-profile-count-base: При использовании опции -fprofile-use, IPA-CP будет рассматривать измеренное число выполнений ребра графа вызовов в позиции этого процента в их гистограмме в качестве основы для расчета эвристик.
ipa-cp-recursive-freq-factor: Количество раз, когда межпроцедурное распространение копий ожидает, что рекурсивные функции будут вызывать себя.
ipa-cp-recursion-penalty: Процентная пеня, которую получат рекурсивные функции при оценке для клонирования.
ipa-cp-single-call-penalty: Процентная пеня, которую получат функции, содержащие единственный вызов другой функции, при оценке для клонирования.
ipa-max-agg-items: IPA-CP также может распространять количество скалярных значений, переданных в агрегате. ipa-max-agg-items управляет максимальным числом таких значений на один параметр.
ipa-cp-loop-hint-bonus: Когда IPA-CP определяет, что кандидат на клонирование сделает число итераций цикла известным, он добавляет бонус ipa-cp-loop-hint-bonus к баллу рентабельности кандидата.
ipa-max-loop-predicates: Максимальное количество различных предикатов, которые IPA будет использовать для описания того, когда циклы в функции имеют известные свойства.
ipa-max-aa-steps: При анализе тела функции IPA-CP использует анализ алиасов для отслеживания значений, на которые указывают параметры функции. Для того, чтобы не тратить слишком много времени на анализ больших функций, он отказывается и считает всю память переписанной после проверки ipa-max-aa-steps инструкций, изменяющих память.
ipa-max-switch-predicate-bounds: Максимальное количество граничных точек диапазонов случаев оператора switch. Для switch, превышающего этот предел, IPA-CP не будет строить предикат стоимости клонирования, используемый для оценки преимущества клонирования, для случая по умолчанию оператора switch.
ipa-max-param-expr-ops: IPA-CP будет анализировать условные операторы, которые ссылаются на некоторый параметр функции, чтобы оценить выгоду от клонирования при определённом постоянном значении. Но если количество операций в выражении параметра превышает ipa-max-param-expr-ops, выражение считается сложным и не обрабатывается анализом IPA.
lto-partitions: Укажите желаемое количество партиций, генерируемых во время компиляции WHOPR. Количество партиций должно превышать количество используемых процессоров для компиляции.
lto-min-partition: Размер минимальной партиции для WHOPR (в оценённых инструкциях). Это предотвращает затраты на разделение очень маленьких программ на слишком много партиций.
lto-max-partition

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

lto-max-streaming-parallelism

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

cxx-max-namespaces-for-diagnostic-help

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

sink-frequency-threshold

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

max-stores-to-sink

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

case-values-threshold

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

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

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

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

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

tree-reassoc-width

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

sched-pressure-algorithm

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

hwasan-instrument-stack

Включить hwasan инструментирование статически размещенных переменных стека. Этот тип инструментирования включен по умолчанию при использовании -fsanitize=hwaddress и выключен по умолчанию при использовании -fsanitize=kernel-hwaddress. Чтобы отключить инструментирование стека, используйте --param hwasan-instrument-stack=0, а чтобы включить его — --param hwasan-instrument-stack=1.

hwasan-random-frame-tag

При использовании инструментирования стека выбирайте теги для стековых переменных, используя детерминированную последовательность, начинающуюся с случайного тега для каждой рамки. Если этот параметр не задан, теги выбираются с использованием той же последовательности, но начиная с 1. Это включено по умолчанию для -fsanitize=hwaddress и недоступно для -fsanitize=kernel-hwaddress. Чтобы отключить его, используйте --param hwasan-random-frame-tag=0.

hwasan-instrument-allocas

Включить hwasan инструментирование динамически размещенных переменных стека. Этот тип инструментирования включен по умолчанию при использовании -fsanitize=hwaddress и выключен по умолчанию при использовании -fsanitize=kernel-hwaddress. Чтобы отключить инструментирование таких переменных, используйте --param hwasan-instrument-allocas=0, а чтобы включить его — --param hwasan-instrument-allocas=1.

hwasan-instrument-reads

Включить hwasan проверки при чтении из памяти. Инструментирование чтений включено по умолчанию для обоих -fsanitize=hwaddress и -fsanitize=kernel-hwaddress. Чтобы отключить проверку чтений из памяти, используйте --param hwasan-instrument-reads=0.

hwasan-instrument-writes

Включить hwasan проверки при записи в память. Инструментирование записей включено по умолчанию для обоих -fsanitize=hwaddress и -fsanitize=kernel-hwaddress. Чтобы отключить проверку записей в память, используйте --param hwasan-instrument-writes=0.

hwasan-instrument-mem-intrinsics

Включить hwasan инструментирование встроенных функций. Инструментирование этих встроенных функций включено по умолчанию для обоих -fsanitize=hwaddress и -fsanitize=kernel-hwaddress. Чтобы отключить инструментирование встроенных функций, используйте --param hwasan-instrument-mem-intrinsics=0.

use-after-scope-direct-emission-threshold

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

tsan-distinguish-volatile

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

tsan-instrument-func-entry-exit

Выводить вызовы инструментирования __tsan_func_entry() и __tsan_func_exit().

max-fsm-thread-path-insns

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

max-fsm-thread-length

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

threader-debug

threader-debug=[none|all] Включает подробную выгрузку решателя потоков.

parloops-chunk-size

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

parloops-schedule

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

parloops-min-per-thread

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

max-ssa-name-query-depth

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

max-speculative-devirt-maydefs

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

max-vrp-switch-assertions

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

evrp-sparse-threshold

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

evrp-mode

Определяет режим работы Early VRP.

vrp1-mode

Определяет режим работы VRP прохода 1.

vrp2-mode

Определяет режим работы VRP прохода 2.

ranger-debug

Определяет тип выдаваемого отладочного вывода для диапазонов.

evrp-switch-limit

Определяет максимальное количество случаев switch, прежде чем EVRP проигнорирует оператор switch.

unroll-jam-min-percent

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

unroll-jam-max-unroll

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

max-rtl-if-conversion-unpredictable-cost

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

max-variable-expansions-in-unroller

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

partial-inlining-entry-probability

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

max-tracked-strlens

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

gcse-after-reload-partial-fraction

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

gcse-after-reload-critical-fraction

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

max-loop-header-insns

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

vect-epilogues-nomask

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

vect-partial-vector-usage

Управляет тем, когда векторизатор циклов рассматривает использование частичных векторных загрузки и сохранения как альтернативу возврату к скалярному коду. 0 запрещает векторизатору использовать частичные векторные загрузки и сохранения. 1 позволяет частичные векторные загрузки и сохранения, если векторизация устраняет необходимость итерации кода. 2 позволяет частичные векторные загрузки и сохранения во всех циклах. Параметр оказывает влияние только на целевые платформы, поддерживающие частичные векторные загрузки и сохранения.
vect-inner-loop-cost-factor: Максимальный коэффициент, который векторизатор циклов применяет к стоимости операторов во внутреннем цикле относительно векторизуемого цикла. Применяемый коэффициент — это максимальное значение из оценки числа итераций внутреннего цикла и этого параметра. Значение по умолчанию для этого параметра равно 50.
vect-induction-float: Включить векторизацию циклов для индукций с плавающей точкой.
sms-max-ii-factor: Коэффициент для настройки верхней границы, которую использует модульный планировщик сдвига для планирования цикла.
avoid-fma-max-bits: Максимальное количество битов, для которых мы избегаем создания FMAs.
sms-loop-average-count-threshold: Порог среднего количества итераций цикла, рассматриваемого планировщиком сдвига по модулю.
sms-dfa-history: Количество циклов, которое планировщик сдвига по модулю рассматривает при проверке конфликтов с использованием DFA.
graphite-allow-codegen-errors: Должны ли ошибки кодогенерации быть ICE, когда -fchecking.
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, для которого должны быть добавлены обратные операции.
fsm-scale-path-stmts: Коэффициент масштабирования, применяемый к количеству операторов в пути потоковой обработки при сравнении с количеством (масштабированных) блоков.
uninit-control-dep-attempts: Максимальное количество вложенных вызовов для поиска зависимостей управления во время анализа неинициализированных переменных.
fsm-scale-path-blocks: Коэффициент масштабирования, применяемый к количеству блоков в пути потоковой обработки при сравнении с количеством (масштабированных) операторов.
sched-autopref-queue-depth: Флаг управления моделью планировщика аппаратного автопрефечера. Количество циклов опережения, в которые заглядывает модель; при ‘ ’ включить только эвристику сортировки инструкций.
loop-versioning-max-inner-insns: Максимальное количество инструкций, которое может содержать внутренний цикл, прежде чем проход векторизации циклов посчитает его слишком большим для копирования.
loop-versioning-max-outer-insns: Максимальное количество инструкций, которое может содержать внешний цикл, прежде чем проход векторизации циклов посчитает его слишком большим для копирования, не учитывая инструкции во внутренних циклах, которые напрямую выигрывают от векторизации.
ssa-name-def-chain-limit: Максимальное количество назначений SSA_NAME для отслеживания при определении свойства переменной, например, её значения. Это ограничивает число итераций или рекурсивных вызовов GCC при оптимизации определённых операторов или при определении их корректности перед выводом диагностики.
store-merging-max-size: Максимальный размер одной области объединения сохранений в байтах.
hash-table-verification-limit: Количество элементов, для которых выполняется проверка хеш-таблицы для каждого искомого элемента.
max-find-base-term-values: Максимальное количество VALUE, обрабатываемых во время одного вызова find_base_term.
analyzer-max-enodes-per-program-point: Максимальное количество взрывных узлов на точку программы внутри анализатора, прежде чем завершать анализ этой точки.
analyzer-max-constraints: Максимальное количество ограничений на состояние.
analyzer-min-snodes-for-call-summary: Минимальное количество суперузлов внутри функции для анализатора, чтобы рассмотреть возможность обобщения его эффектов в местах вызова.
analyzer-max-enodes-for-full-dump: Максимальная глубина взрывных узлов, которые должны появиться в дампе dot, прежде чем перейти к менее подробному формату.
analyzer-max-recursion-depth: Максимальное количество раз, когда место вызова может появиться в стеке вызовов внутри анализатора, прежде чем завершать анализ вызова, который будет выполняться глубже.
analyzer-max-svalue-depth: Максимальная глубина символьного значения, прежде чем приблизить значение как неизвестное.
analyzer-max-infeasible-edges: Максимальное количество неосуществимых рёбер для отклонения перед объявлением диагностики неосуществимой.
gimple-fe-computed-hot-bb-threshold: Количество выполнений базового блока, которое считается горячим. Параметр используется только в GIMPLE FE.
analyzer-bb-explosion-factor: Максимальное количество взрывных узлов ‘после суперузла’ внутри анализатора на один суперузел, прежде чем завершить анализ.
ranger-logical-depth: Максимальная глубина вычисления логического выражения, в которую будет заглядывать диапазон при оценке исходящих диапазонов рёбер.
relation-block-limit: Максимальное количество соотношений, которые будет регистрировать оракул в базовом блоке.
min-pagesize: Минимальный размер страницы для предупреждений.
openacc-kernels: Указать режим обработки конструкций OpenACC «kernels». С --param=openacc-kernels=decompose, конструкции OpenACC «kernels» декомпозируются на части, последовательность вычислительных конструкций, каждая из которых затем обрабатывается индивидуально. Это работа в процессе. С --param=openacc-kernels=parloops, конструкции OpenACC «kernels» обрабатываются проходом «parloops», в целом. Это текущий стандарт.
openacc-privatization: Указать режим диагностики приватизации OpenACC для -fopt-info-omp-note и соответствующих -fdump-tree-*-details. С --param=openacc-privatization=quiet, не диагностировать. Это текущий стандарт. С --param=openacc-privatization=noisy, диагностировать.

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

aarch64-sve-compare-costs

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

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

aarch64-float-recp-precision

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

aarch64-double-recp-precision

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

aarch64-autovec-preference

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

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

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

aarch64-loop-vect-issue-rate-niters

Настройка для некоторых процессоров AArch64 пытается учитывать как задержки, так и скорости выпуска при решении, следует ли векторизировать цикл с использованием SVE, векторизировать с помощью Advanced SIMD или не векторизировать вовсе. Если этот параметр установлен на n, GCC не будет использовать эту эвристику для циклов, которые, как известно, выполняются меньше чем n итераций Advanced SIMD.

aarch64-vect-unroll-limit

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

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

x86-stlf-window-ninsns: Число инструкций, превышение которого компенсирует штраф за задержку STFL.

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

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