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

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

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

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

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

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

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

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

-O

-O1

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

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

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

-fauto-inc-dec 
-fbranch-count-reg 
-fcombine-stack-adjustments 
-fcompare-elim 
-fcprop-registers 
-fdce 
-fdefer-pop 
-fdelayed-branch 
-fdse 
-fforward-propagate 
-fguess-branch-probability 
-fif-conversion2 
-fif-conversion 
-finline-functions-called-once 
-fipa-pure-const 
-fipa-profile 
-fipa-reference 
-fmerge-constants 
-fmove-loop-invariants 
-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-sink 
-ftree-slsr 
-ftree-sra 
-ftree-pta 
-ftree-ter 
-funit-at-a-time

-O2

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

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

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

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

-O3

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

-finline-functions 
-funswitch-loops 
-fpredictive-commoning 
-fgcse-after-reload 
-ftree-loop-vectorize 
-ftree-loop-distribution 
-ftree-loop-distribute-patterns 
-floop-interchange 
-floop-unroll-and-jam 
-fsplit-paths 
-ftree-slp-vectorize 
-fvect-cost-model 
-ftree-partial-pre 
-fpeel-loops 
-fipa-cp-clone

-O0

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

-Os

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

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

-falign-functions  -falign-jumps  -falign-loops 
-falign-labels  -fprefetch-loop-arrays

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

-Ofast

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

-Og

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

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

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

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

-fno-defer-pop

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

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

-fforward-propagate

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

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

-ffp-contract=style

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

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

-fomit-frame-pointer

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

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

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

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

-foptimize-sibling-calls

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

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

-foptimize-strlen

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

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

-fno-inline

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

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

-finline-small-functions

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

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

-findirect-inlining

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

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

-finline-functions

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

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

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

-finline-functions-called-once

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

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

-fearly-inlining

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

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

-fipa-sra

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

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

-finline-limit=n

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

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

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

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

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

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

-fno-keep-inline-dllexport

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

-fkeep-inline-functions

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

-fkeep-static-functions

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

-fkeep-static-consts

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

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

-fmerge-constants

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

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

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

-fmerge-all-constants

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

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

-fmodulo-sched

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

-fmodulo-sched-allow-regmoves

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

-fno-branch-count-reg

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

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

Значение по умолчанию — -fbranch-count-reg.

-fno-function-cse

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

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

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

-fno-zero-initialized-in-bss

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

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

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

-fthread-jumps

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

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

-fsplit-wide-types

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

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

-fcse-follow-jumps

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

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

-fcse-skip-blocks

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

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

-frerun-cse-after-loop

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

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

-fgcse

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

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

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

-fgcse-lm

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

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

-fgcse-sm

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

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

-fgcse-las

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

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

-fgcse-after-reload

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

-faggressive-loop-optimizations

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

-funconstrained-commons

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

-fcrossjumping

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

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

-fauto-inc-dec

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

-fdce

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

-fdse

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

-fif-conversion

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

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

-fif-conversion2

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

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

-fdeclone-ctor-dtor

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

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

-fdelete-null-pointer-checks

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

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

Этот параметр включён по умолчанию на большинстве целевых платформ. На Nios II ELF он отключён по умолчанию. На AVR, CR16 и 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

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

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

-fschedule-insns

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

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

-fschedule-insns2

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

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

-fno-sched-interblock

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

-fno-sched-spec

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

-fsched-pressure

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

-fsched-spec-load

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

-fsched-spec-load-dangerous

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

-fsched-stalled-insns

-fsched-stalled-insns=n

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

-fsched-stalled-insns-dep

-fsched-stalled-insns-dep=n

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

-fsched2-use-superblocks

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

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

-fsched-group-heuristic

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

-fsched-critical-path-heuristic

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

-fsched-spec-insn-heuristic

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

-fsched-rank-heuristic

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

-fsched-last-insn-heuristic

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

-fsched-dep-count-heuristic

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

-freschedule-modulo-scheduled-loops

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

-fselective-scheduling

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

-fselective-scheduling2

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

-fsel-sched-pipelining

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

-fsel-sched-pipelining-outer-loops

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

-fsemantic-interposition

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

-fshrink-wrap

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

-fshrink-wrap-separate

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

-fcaller-saves

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

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

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

-fcombine-stack-adjustments

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

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

-fipa-ra

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

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

-fconserve-stack

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

Этот параметр подразумевает установку параметра large-stack-frame в 100 и параметра large-stack-frame-growth в 400.

-ftree-reassoc

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

-fcode-hoisting

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

-ftree-pre

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

-ftree-partial-pre

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

-ftree-forwprop

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

-ftree-fre

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

-ftree-phiprop

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

-fhoist-adjacent-loads

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

-ftree-copy-prop

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

-fipa-pure-const

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

-fipa-reference

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

-fipa-pta

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

-fipa-profile

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

-fipa-cp

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

-fipa-cp-clone

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

-fipa-bit-cp

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

-fipa-vrp

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

-fipa-icf

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

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

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

-fisolate-erroneous-paths-dereference

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

-fisolate-erroneous-paths-attribute

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

-ftree-sink

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

-ftree-bit-ccp

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

-ftree-ccp

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

-fssa-backprop

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

-fssa-phiopt

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

-ftree-switch-conversion

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

-ftree-tail-merge

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

-ftree-dce

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

-ftree-builtin-call-dce

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

-ftree-dominator-opts

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

-ftree-dse

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

-ftree-ch

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

-ftree-loop-optimize

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

-ftree-loop-linear

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

-ftree-loop-distribute-patterns

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

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

-floop-interchange

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

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.

-floop-unroll-and-jam

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

-ftree-loop-im

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

-ftree-loop-ivcanon

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

-fivopts

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

-ftree-parallelize-loops=n

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

-ftree-pta

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

-ftree-sra

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

-fstore-merging

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

-ftree-ter

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

-ftree-slsr

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

-ftree-vectorize

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

-ftree-loop-vectorize

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

-ftree-slp-vectorize

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

-fvect-cost-model=model

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

-fsimd-cost-model=model

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

-ftree-vrp

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

-fsplit-paths

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

-fsplit-ivs-in-unroller

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

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

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

-fvariable-expansion-in-unroller

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

-fpartial-inlining

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

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

-fpredictive-commoning

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

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

-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

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

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

-fno-guess-branch-probability

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

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

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

-freorder-blocks

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

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

-freorder-blocks-algorithm=algorithm

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

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

-freorder-blocks-and-partition

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

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

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

-freorder-functions

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

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

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

-fstrict-aliasing

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

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

union a_union {
  int i;
  double d;
};

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

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

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

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

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

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

-falign-functions

-falign-functions=n

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

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

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

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

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

-flimit-function-alignment

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

-falign-labels

-falign-labels=n

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

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

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

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

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

-falign-loops

-falign-loops=n

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

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

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

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

-falign-jumps

-falign-jumps=n

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

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

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

-funit-at-a-time

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

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

-fno-toplevel-reorder

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

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

-fweb

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

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

-fwhole-program

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

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

-flto[=n]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-flto-partition=alg

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

-flto-odr-type-merging

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

-flto-compression-level=n

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

-fuse-linker-plugin

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

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

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

-ffat-lto-objects

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

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

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

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

-fcompare-elim

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

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

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

-fcprop-registers

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

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

-fprofile-correction

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

-fprofile-use

-fprofile-use=path

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

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

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

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

-fauto-profile

-fauto-profile=path

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

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

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

Например:

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

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

Например:

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

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

-ffloat-store

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

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

-fexcess-precision=style

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

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

-ffast-math

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

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

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

-fno-math-errno

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

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

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

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

-funsafe-math-optimizations

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

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

-fassociative-math

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

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

-freciprocal-math

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

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

-ffinite-math-only

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

По умолчанию используется -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’s FENV_ACCESS pragma. Этот параметр командной строки будет использоваться для указания стандартного состояния для FENV_ACCESS.

-fsignaling-nans

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

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

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

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

-fno-fp-int-builtin-inexact

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

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

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

-fsingle-precision-constant

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

-fcx-limited-range

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

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

-fcx-fortran-rules

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

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

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

-fbranch-probabilities

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

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

-fprofile-values

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

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

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

-fprofile-reorder-functions

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

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

-fvpt

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

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

-frename-registers

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

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

-fschedule-fusion

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

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

-ftracer

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

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

-funroll-loops

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

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

-funroll-all-loops

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

-fpeel-loops

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

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

-fmove-loop-invariants

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

-fsplit-loops

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

-funswitch-loops

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

-ffunction-sections

-fdata-sections

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

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

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

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

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

-fbranch-target-load-optimize

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

-fbranch-target-load-optimize2

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

-fbtr-bb-exclusive

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

-fstdarg-opt

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

-fsection-anchors

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

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

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

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

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

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

--param name=value

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

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

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

predictable-branch-outcome

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

max-rtl-if-conversion-insns

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

max-rtl-if-conversion-predictable-cost

max-rtl-if-conversion-unpredictable-cost

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

max-crossjump-edges

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

min-crossjump-insns

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

max-grow-copy-bb-insns

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

max-goto-duplication-insns

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

max-delay-slot-insn-search

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

max-delay-slot-live-search

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

max-gcse-memory

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

max-gcse-insertion-ratio

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

max-pending-list-length

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

max-modulo-backtrack-attempts

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

max-inline-insns-single

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

max-inline-insns-auto

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

inline-min-speedup

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

large-function-insns

large-function-growth

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

large-unit-insns

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

inline-unit-growth

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

ipcp-unit-growth

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

large-stack-frame

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

large-stack-frame-growth

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

max-inline-insns-recursive

max-inline-insns-recursive-auto

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

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

max-inline-recursive-depth

max-inline-recursive-depth-auto

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

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

min-inline-recursive-probability

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

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

early-inlining-insns

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

max-early-inliner-iterations

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

comdat-sharing-probability

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

profile-func-internal-id

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

min-vect-loop-bound

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

gcse-cost-distance-ratio

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

gcse-unrestricted-cost

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

max-hoist-depth

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

max-tail-merge-comparisons

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

max-tail-merge-iterations

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

store-merging-allow-unaligned

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

max-stores-to-merge

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

max-unrolled-insns

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

max-average-unrolled-insns

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

max-unroll-times

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

max-peeled-insns

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

max-peel-times

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

max-peel-branches

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

max-completely-peeled-insns

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

max-completely-peel-times

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

max-completely-peel-loop-nest-depth

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

max-unswitch-insns

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

max-unswitch-level

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

max-loop-headers-insns

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

lim-expensive

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

iv-consider-all-candidates-bound

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

iv-max-considered-uses

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

iv-always-prune-cand-set-bound

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

avg-loop-niter

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

dse-max-object-size

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

scev-max-expr-size

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

scev-max-expr-complexity

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

max-tree-if-conversion-phi-args

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

vect-max-version-for-alignment-checks

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

vect-max-version-for-alias-checks

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

vect-max-peeling-for-alignment

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

max-iterations-to-track

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

hot-bb-count-ws-permille

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

hot-bb-frequency-fraction

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

max-predicted-iterations

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

builtin-expect-probability

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

align-threshold

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

align-loop-iterations

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

tracer-dynamic-coverage

tracer-dynamic-coverage-feedback

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

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

tracer-max-code-growth

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

tracer-min-branch-ratio

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

tracer-min-branch-probability

tracer-min-branch-probability-feedback

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

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

stack-clash-protection-guard-size

Укажите размер предоставленного ОС защитного стека в виде 2 в степени num байт. Значение по умолчанию равно 12 (4096 байт). Допустимые значения находятся в диапазоне от 12 до 30. Более высокие значения могут уменьшить количество явных зондов, но значение, большее, чем предоставленная ОС защита, оставит код уязвимым для атак типа столкновения стека.

stack-clash-protection-probe-interval

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

max-cse-path-length

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

max-cse-insns

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

ggc-min-expand

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

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

ggc-min-heapsize

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

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

max-reload-search-insns

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

max-cselib-memory-locations

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

max-sched-ready-insns

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

max-sched-region-blocks

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

max-pipeline-region-blocks

Максимальное количество блоков в регионе, рассматриваемых для конвейеризации в селективном планировщике. Значение по умолчанию равно 15.
max-sched-region-insns: Максимальное количество инструкций в регионе, рассматриваемых для межблочного планирования. Значение по умолчанию равно 100.
max-pipeline-region-insns: Максимальное количество инструкций в регионе, рассматриваемых для конвейеризации в селективном планировщике. Значение по умолчанию равно 200.
min-spec-prob: Минимальная вероятность (в процентах) достижения исходного блока для межблочного упреждающего планирования. Значение по умолчанию равно 40.
max-sched-extend-regions-iters: Максимальное количество итераций по графу потока управления для расширения регионов. Значение 0 (по умолчанию) отключает расширение регионов.
max-sched-insn-conflict-delay: Максимальная задержка конфликта для инструкции, рассматриваемой для упреждающего перемещения. Значение по умолчанию равно 3.
sched-spec-prob-cutoff: Минимальная вероятность успеха упреждения (в процентах), чтобы упреждающие инструкции были запланированы. Значение по умолчанию равно 40.
sched-state-edge-prob-cutoff: Минимальная вероятность, которую должен иметь край, чтобы планировщик сохранял свое состояние через него. Значение по умолчанию равно 10.
selsched-max-lookahead: Максимальный размер окна прогнозирования селективного планирования. Это глубина поиска доступных инструкций. Значение по умолчанию равно 50.
selsched-max-sched-times: Максимальное количество раз, когда инструкция планируется во время селективного планирования. Это ограничение на количество итераций, через которые инструкция может быть конвейеризирована. Значение по умолчанию равно 2.
selsched-insns-to-rename: Максимальное количество лучших инструкций в списке готовности, которые рассматриваются для переименования в селективном планировщике. Значение по умолчанию равно 2.
sms-min-sc: Минимальное значение количества стадий, генерируемых планировщиком с модулем колебаний. Значение по умолчанию равно 2.
max-last-value-rtl: Максимальный размер, измеряемый как количество RTL, которые могут быть записаны в выражении в комбинирующем элементе для псевдорегистра в качестве последнего известного значения этого регистра. По умолчанию 10000.
max-combine-insns: Максимальное количество инструкций, которые комбинирующий элемент RTL пытается объединить. Значение по умолчанию равно 2 при -Og и 4 в противном случае.
integer-share-limit: Малые целочисленные константы могут использовать общую структуру данных, что уменьшает использование памяти компилятором и увеличивает его скорость. Это задает максимальное значение общей целочисленной константы. Значение по умолчанию равно 256.
ssp-buffer-size: Минимальный размер буферов (т.е. массивов), которые получают защиту от переполнения стека, когда используется -fstack-protection.
min-size-for-stack-sharing: Минимальный размер переменных, участвующих в совместном использовании слотов стека при отсутствии оптимизации. Значение по умолчанию равно 32.
max-jump-thread-duplication-stmts: Максимальное количество операторов в блоке, которые необходимо дублировать при многопоточном переходе.
max-fields-for-field-sensitive: Максимальное количество полей в структуре, обрабатываемых с учетом поля при анализе указателей. По умолчанию равно нулю для -O0 и -O1, и 100 для -Os, -O2 и -O3.
prefetch-latency: Оценка среднего количества инструкций, которые выполняются до завершения предварительной выборки. Расстояние, предварительно выбранное вперед, пропорционально этой константе. Увеличение этого числа также может привести к меньшему количеству потоков, подлежащих предварительной выборке (см. simultaneous-prefetches).
simultaneous-prefetches: Максимальное количество предварительных выборок, которые могут выполняться одновременно.
l1-cache-line-size: Размер строки кэша в кэше L1 в байтах.
l1-cache-size: Размер кэша L1 в килобайтах.
l2-cache-size: Размер кэша L2 в килобайтах.
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 для этого параметра разрешает неограниченную длину набора.
sccvn-max-scc-size: Максимальный размер сильно связанного компонента (SCC) во время обработки SCCVN. Если это ограничение достигнуто, обработка SCCVN для всей функции не выполняется, и оптимизации, зависящие от неё, отключаются. По умолчанию максимальный размер SCC равен 10000.
sccvn-max-alias-queries-per-access: Максимальное количество запросов к oracle алиасов, которые мы выполняем при поиске избыточностей для загрузок и хранений. Если это ограничение достигнуто, поиск прерывается, и загрузка или хранение не считаются избыточными. Количество запросов алгоритмически ограничено количеством хранений на всех путях от загрузки до входа в функцию. По умолчанию максимальное количество запросов равно 1000.
ira-max-loops-num: IRA по умолчанию использует региональное распределение регистров. Если функция содержит больше циклов, чем указанное число этим параметром, только указанное количество наиболее часто выполняемых циклов образует регионы для регионального распределения регистров. Значение параметра по умолчанию равно 100.
ira-max-conflict-table-size: Хотя IRA использует сложный алгоритм для сжатия таблицы конфликтов, таблица все еще может требовать чрезмерного количества памяти для огромных функций. Если таблица конфликтов для функции могла бы превысить размер в МБ, заданный этим параметром, планировщик регистров вместо этого использует более быстрый, упрощенный и менее качественный алгоритм, который не требует построения таблицы конфликтов псевдорегистров. Значение параметра по умолчанию равно 2000.
ira-loop-reserved-regs: IRA можно использовать для оценки более точного давления на регистры в циклах для принятия решений о перемещении инвариантов цикла (см. -O3). Количество доступных регистров, зарезервированных для других целей, задается этим параметром. Значение параметра по умолчанию равно 2, что является минимальным числом регистров, необходимых для типичных инструкций. Это значение является лучшим найденным из многочисленных экспериментов.
lra-inheritance-ebb-probability-cutoff: LRA пытается повторно использовать значения, загруженные в регистры в последующих инструкциях. Эта оптимизация называется наследованием. Для выполнения этой оптимизации используется EBB (Basic Block). Параметр определяет минимальную вероятность прохождения по краю без перехода в процентах, используемую для добавления BB в наследуемый EBB в LRA. Значение параметра по умолчанию равно 40. Значение было выбрано по результатам многочисленных запусков SPEC2000 на x86-64.
loop-max-datarefs-for-datadeps: Построение зависимостей данных является дорогостоящим для очень больших циклов. Этот параметр ограничивает количество ссылок на данные в циклах, которые рассматриваются для анализа зависимостей данных. Эти большие циклы не обрабатываются оптимизациями, использующими зависимости данных цикла. Значение по умолчанию равно 1000.
max-vartrack-size: Устанавливает максимальное количество слотов таблицы хеширования для использования во время анализа потока данных отслеживания переменных любой функции. Если это ограничение превышено при включенном отслеживании переменных при назначениях, анализ для этой функции повторяется без него после удаления всех инструкций отладки из функции. Если ограничение превышено даже без инструкций отладки, анализ отслеживания переменных полностью отключается для функции. Установка параметра в ноль делает его неограниченным.
max-vartrack-expr-depth: Устанавливает максимальное количество уровней рекурсии при попытке сопоставить имена переменных или временные переменные отладки с выражениями значений. Это позволяет обменять время компиляции на более полную информацию отладки. Если это значение установлено слишком низким, выражения значений, которые доступны и могли бы быть представлены в информации отладки, в конечном итоге могут не использоваться; установка этого значения выше может позволить компилятору находить более сложные выражения отладки, но время компиляции и использование памяти могут увеличиться. По умолчанию 12.
max-debug-marker-count: Устанавливает порог на количество маркеров отладки (например, маркеров начала оператора) для предотвращения взрыва сложности при встраивании или расширении до RTL. Если в функции таких операторов gimple больше, чем установленное ограничение, такие операторы будут удалены из встроенной копии функции и из ее расширения RTL. По умолчанию 100000.
min-nondebug-insn-uid: Использовать идентификаторы, начиная с этого параметра, для инструкций, не относящихся к отладке. Диапазон ниже параметра зарезервирован исключительно для инструкций отладки, созданных с помощью -fvar-tracking-assignments, но инструкции отладки могут получить (непересекающиеся) идентификаторы выше него, если зарезервированный диапазон исчерпан.
ipa-sra-ptr-growth-factor: IPA-SRA заменяет указатель на агрегат одним или несколькими новыми параметрами только тогда, когда их суммарный размер меньше или равен ipa-sra-ptr-growth-factor умноженному на размер исходного параметра указателя.
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

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

tm-max-aggregate-size

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

graphite-max-nb-scop-params

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

loop-block-tile-size

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

loop-unroll-jam-size

Укажите множитель размотки для опции -floop-unroll-and-jam. Значение по умолчанию равно 4.

loop-unroll-jam-depth

Укажите размерность для размотки (считая с самого внутреннего цикла) для -floop-unroll-and-jam. Значение по умолчанию равно 2.

ipa-cp-value-list-size

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

ipa-cp-eval-threshold

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

ipa-cp-recursion-penalty

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

ipa-cp-single-call-penalty

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

ipa-max-agg-items

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

ipa-cp-loop-hint-bonus

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

ipa-cp-array-index-hint-bonus

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

ipa-max-aa-steps

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

lto-partitions

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

lto-min-partition

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

lto-max-partition

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

cxx-max-namespaces-for-diagnostic-help

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

sink-frequency-threshold

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

max-stores-to-sink

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

allow-store-data-races

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

case-values-threshold

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

tree-reassoc-width

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

sched-pressure-algorithm

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

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

max-slsr-cand-scan

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

asan-globals

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

asan-stack

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

asan-instrument-reads

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

asan-instrument-writes

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

asan-memintrin

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

asan-use-after-return

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

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

asan-instrumentation-with-call-threshold

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

use-after-scope-direct-emission-threshold

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

chkp-max-ctor-size

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

max-fsm-thread-path-insns

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

max-fsm-thread-length

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

max-fsm-thread-paths

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

parloops-chunk-size

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

parloops-schedule

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

parloops-min-per-thread

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

max-ssa-name-query-depth

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

hsa-gen-debug-stores

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

max-speculative-devirt-maydefs

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

max-vrp-switch-assertions

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

unroll-jam-min-percent

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

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

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