3.18.56 Опции x86

Эти опции «-m» определены для семейства компьютеров x86.

-march=cpu-type

Генерировать инструкции для типа машины cpu-type. В отличие от -mtune=cpu-type, которое просто настраивает сгенерированный код для указанного cpu-type, -march=cpu-type позволяет GCC генерировать код, который может вообще не работать на процессорах, отличных от указанного. Указание -march=cpu-type подразумевает -mtune=cpu-type.

Возможные значения для cpu-type:

‘native’: Это выбирает процессор для генерации кода во время компиляции, определяя тип процессора компиляционной машины. Использование -march=native включает все наборы инструкций, поддерживаемые локальной машиной (поэтому результат может не работать на других машинах). Использование -mtune=native генерирует код, оптимизированный для локальной машины при ограничениях выбранного набора инструкций.
‘x86-64’: Общий процессор с 64-битными расширениями.
‘i386’: Оригинальный процессор Intel i386.
‘i486’: Процессор Intel i486. (Планирование не реализовано для этого чипа.)
‘i586’
‘pentium’: Процессор Intel Pentium без поддержки MMX.
‘lakemont’: Микроконтроллер Intel Lakemont, основанный на процессоре Intel Pentium.
‘pentium-mmx’: Процессор Intel Pentium MMX, основанный на ядре Pentium с поддержкой набора инструкций MMX.
‘pentiumpro’: Процессор Intel Pentium Pro.
‘i686’: При использовании с -march, используется набор инструкций Pentium Pro, поэтому код работает на всех чипах семейства i686. При использовании с -mtune, он имеет такое же значение, как ‘generic’.
‘pentium2’: Процессор Intel Pentium II, основанный на ядре Pentium Pro с поддержкой набора инструкций MMX.
‘pentium3’
‘pentium3m’: Процессор Intel Pentium III, основанный на ядре Pentium Pro с поддержкой наборов инструкций MMX и SSE.
‘pentium-m’: Intel Pentium M; экономичная версия процессора Intel Pentium III с поддержкой наборов инструкций MMX, SSE и SSE2. Используется в ноутбуках Centrino.
‘pentium4’
‘pentium4m’: Процессор Intel Pentium 4 с поддержкой наборов инструкций MMX, SSE и SSE2.
‘prescott’: Улучшенная версия процессора Intel Pentium 4 с поддержкой наборов инструкций MMX, SSE, SSE2 и SSE3.
‘nocona’: Улучшенная версия процессора Intel Pentium 4 с 64-битными расширениями, поддержкой наборов инструкций MMX, SSE, SSE2 и SSE3.
‘core2’: Процессор Intel Core 2 с 64-битными расширениями, поддержкой наборов инструкций MMX, SSE, SSE2, SSE3 и SSSE3.
‘nehalem’: Процессор Intel Nehalem с 64-битными расширениями, поддержкой наборов инструкций MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2 и POPCNT.
‘westmere’: Процессор Intel Westmere с 64-битными расширениями, поддержкой наборов инструкций MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, POPCNT, AES и PCLMUL.
‘sandybridge’: Процессор Intel Sandy Bridge с 64-битными расширениями, поддержкой наборов инструкций MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, POPCNT, AVX, AES и PCLMUL.
‘ivybridge’: Процессор Intel Ivy Bridge с 64-битными расширениями, поддержкой наборов инструкций MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, POPCNT, AVX, AES, PCLMUL, FSGSBASE, RDRND и F16C.
‘haswell’: Процессор Intel Haswell с 64-битными расширениями, поддержкой наборов инструкций MOVBE, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, POPCNT, AVX, AVX2, AES, PCLMUL, FSGSBASE, RDRND, FMA, BMI, BMI2 и F16C.
‘broadwell’: Процессор Intel Broadwell с 64-битными расширениями, поддержкой наборов инструкций MOVBE, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, POPCNT, AVX, AVX2, AES, PCLMUL, FSGSBASE, RDRND, FMA, BMI, BMI2, F16C, RDSEED, ADCX и PREFETCHW.
‘skylake’: Процессор Intel Skylake с 64-битными расширениями, поддержкой наборов инструкций MOVBE, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, POPCNT, AVX, AVX2, AES, PCLMUL, FSGSBASE, RDRND, FMA, BMI, BMI2, F16C, RDSEED, ADCX, PREFETCHW, CLFLUSHOPT, XSAVEC и XSAVES.
‘bonnell’: Процессор Intel Bonnell с 64-битными расширениями, поддержкой наборов инструкций MOVBE, MMX, SSE, SSE2, SSE3 и SSSE3.
‘silvermont’: Процессор Intel Silvermont с 64-битными расширениями, поддержкой наборов инструкций MOVBE, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, POPCNT, AES, PCLMUL и RDRND.
‘knl’: Процессор Intel Knight’s Landing с 64-битными расширениями, поддержкой наборов инструкций MOVBE, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, POPCNT, AVX, AVX2, AES, PCLMUL, FSGSBASE, RDRND, FMA, BMI, BMI2, F16C, RDSEED, ADCX, PREFETCHW, AVX512F, AVX512PF, AVX512ER и AVX512CD.
‘knm’: Процессор Intel Knights Mill с 64-битными расширениями, поддержкой наборов инструкций MOVBE, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, POPCNT, AVX, AVX2, AES, PCLMUL, FSGSBASE, RDRND, FMA, BMI, BMI2, F16C, RDSEED, ADCX, PREFETCHW, AVX512F, AVX512PF, AVX512ER, AVX512CD, AVX5124VNNIW, AVX5124FMAPS и AVX512VPOPCNTDQ.
‘skylake-avx512’: Серверный процессор Intel Skylake с 64-битными расширениями, поддержкой наборов инструкций MOVBE, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, POPCNT, PKU, AVX, AVX2, AES, PCLMUL, FSGSBASE, RDRND, FMA, BMI, BMI2, F16C, RDSEED, ADCX, PREFETCHW, CLFLUSHOPT, XSAVEC, XSAVES, AVX512F, CLWB, AVX512VL, AVX512BW, AVX512DQ и AVX512CD.
‘cannonlake’: Серверный процессор Intel Cannonlake с 64-битными расширениями, поддержкой наборов инструкций MOVBE, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, POPCNT, PKU, AVX, AVX2, AES, PCLMUL, FSGSBASE, RDRND, FMA, BMI, BMI2, F16C, RDSEED, ADCX, PREFETCHW, CLFLUSHOPT, XSAVEC, XSAVES, AVX512F, AVX512VL, AVX512BW, AVX512DQ, AVX512CD, AVX512VBMI, AVX512IFMA, SHA и UMIP.
‘icelake-client’: Клиентский процессор Intel Icelake с 64-битными расширениями, поддержкой наборов инструкций MOVBE, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, POPCNT, PKU, AVX, AVX2, AES, PCLMUL, FSGSBASE, RDRND, FMA, BMI, BMI2, F16C, RDSEED, ADCX, PREFETCHW, CLFLUSHOPT, XSAVEC, XSAVES, AVX512F, AVX512VL, AVX512BW, AVX512DQ, AVX512CD, AVX512VBMI, AVX512IFMA, SHA, CLWB, UMIP, RDPID, GFNI, AVX512VBMI2, AVX512VPOPCNTDQ, AVX512BITALG, AVX512VNNI, VPCLMULQDQ и VAES.
‘icelake-server’: Серверный процессор Intel Icelake с 64-битными расширениями, поддержкой наборов инструкций MOVBE, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, POPCNT, PKU, AVX, AVX2, AES, PCLMUL, FSGSBASE, RDRND, FMA, BMI, BMI2, F16C, RDSEED, ADCX, PREFETCHW, CLFLUSHOPT, XSAVEC, XSAVES, AVX512F, AVX512VL, AVX512BW, AVX512DQ, AVX512CD, AVX512VBMI, AVX512IFMA, SHA, CLWB, UMIP, RDPID, GFNI, AVX512VBMI2, AVX512VPOPCNTDQ, AVX512BITALG, AVX512VNNI, VPCLMULQDQ, VAES, PCONFIG и WBNOINVD.
‘k6’: Процессор AMD K6 с поддержкой набора инструкций MMX.
‘k6-2’
‘k6-3’: Улучшенные версии процессоров AMD K6 с поддержкой наборов инструкций MMX и 3DNow!.
‘athlon’
‘athlon-tbird’: Процессор AMD Athlon с поддержкой наборов инструкций MMX, 3dNOW!, enhanced 3DNow! и инструкций префечинга SSE.
‘athlon-4’
‘athlon-xp’
‘athlon-mp’: Улучшенный процессор AMD Athlon с поддержкой наборов инструкций MMX, 3DNow!, enhanced 3DNow! и полным набором инструкций SSE.
‘k8’
‘opteron’
‘athlon64’
‘athlon-fx’: Процессоры, основанные на ядре AMD K8 с поддержкой набора инструкций x86-64, включая процессоры AMD Opteron, Athlon 64 и Athlon 64 FX. (Этот набор включает MMX, SSE, SSE2, 3DNow!, enhanced 3DNow! и расширения набора инструкций для 64-разрядных систем.)
‘k8-sse3’
‘opteron-sse3’
‘athlon64-sse3’: Улучшенные версии ядер AMD K8 с поддержкой набора инструкций SSE3.
‘amdfam10’
‘barcelona’: Процессоры, основанные на ядрах AMD Family 10h с поддержкой набора инструкций x86-64. (Это включает MMX, SSE, SSE2, SSE3, SSE4A, 3DNow!, enhanced 3DNow!, ABM и расширения набора инструкций для 64-разрядных систем.)
‘bdver1’: Процессоры, основанные на ядрах AMD Family 15h с поддержкой набора инструкций x86-64. (Это включает FMA4, AVX, XOP, LWP, AES, PCL_MUL, CX16, MMX, SSE, SSE2, SSE3, SSE4A, SSSE3, SSE4.1, SSE4.2, ABM и расширения набора инструкций для 64-разрядных систем.)
‘bdver2’: Процессоры на базе ядер AMD Family 15h с поддержкой набора инструкций x86-64. (Это включает BMI, TBM, F16C, FMA, FMA4, AVX, XOP, LWP, AES, PCL_MUL, CX16, MMX, SSE, SSE2, SSE3, SSE4A, SSSE3, SSE4.1, SSE4.2, ABM и расширения набора инструкций для 64-разрядных систем.)
‘bdver3’: Процессоры на базе ядер AMD Family 15h с поддержкой набора инструкций x86-64. (Это включает BMI, TBM, F16C, FMA, FMA4, FSGSBASE, AVX, XOP, LWP, AES, PCL_MUL, CX16, MMX, SSE, SSE2, SSE3, SSE4A, SSSE3, SSE4.1, SSE4.2, ABM и расширения набора инструкций для 64-разрядных систем.)
‘bdver4’: Процессоры на базе ядер AMD Family 15h с поддержкой набора инструкций x86-64. (Это включает BMI, BMI2, TBM, F16C, FMA, FMA4, FSGSBASE, AVX, AVX2, XOP, LWP, AES, PCL_MUL, CX16, MOVBE, MMX, SSE, SSE2, SSE3, SSE4A, SSSE3, SSE4.1, SSE4.2, ABM и расширения набора инструкций для 64-разрядных систем.)
‘znver1’: Процессоры на базе ядер AMD Family 17h с поддержкой набора инструкций x86-64. (Это включает BMI, BMI2, F16C, FMA, FSGSBASE, AVX, AVX2, ADCX, RDSEED, MWAITX, SHA, CLZERO, AES, PCL_MUL, CX16, MOVBE, MMX, SSE, SSE2, SSE3, SSE4A, SSSE3, SSE4.1, SSE4.2, ABM, XSAVEC, XSAVES, CLFLUSHOPT, POPCNT и расширения набора инструкций для 64-разрядных систем.)
‘btver1’: Процессоры на базе ядер AMD Family 14h с поддержкой набора инструкций x86-64. (Это включает MMX, SSE, SSE2, SSE3, SSSE3, SSE4A, CX16, ABM и расширения набора инструкций для 64-разрядных систем.)
‘btver2’: Процессоры на базе ядер AMD Family 16h с поддержкой набора инструкций x86-64. Это включает MOVBE, F16C, BMI, AVX, PCL_MUL, AES, SSE4.2, SSE4.1, CX16, ABM, SSE4A, SSSE3, SSE3, SSE2, SSE, MMX и расширения набора инструкций для 64-разрядных систем.
‘winchip-c6’: Процессор IDT WinChip C6 с поддержкой набора инструкций MMX, рассматривается аналогично i486 с дополнительной поддержкой MMX.
‘winchip2’: Процессор IDT WinChip 2 с поддержкой наборов инструкций MMX и 3DNow!, рассматривается аналогично i486 с дополнительной поддержкой MMX и 3DNow!.
‘c3’: Процессор VIA C3 с поддержкой наборов инструкций MMX и 3DNow!. (Планирование не реализовано для этого чипа.)
‘c3-2’: Процессор VIA C3-2 (Nehemiah/C5XL) с поддержкой наборов инструкций MMX и SSE. (Планирование не реализовано для этого чипа.)
‘c7’: Процессор VIA C7 (Esther) с поддержкой наборов инструкций MMX, SSE, SSE2 и SSE3. (Планирование не реализовано для этого чипа.)
‘samuel-2’: Процессор VIA Eden Samuel 2 с поддержкой наборов инструкций MMX и 3DNow!. (Планирование не реализовано для этого чипа.)
‘nehemiah’: Процессор VIA Eden Nehemiah с поддержкой наборов инструкций MMX и SSE. (Планирование не реализовано для этого чипа.)
‘esther’: Процессор VIA Eden Esther с поддержкой наборов инструкций MMX, SSE, SSE2 и SSE3. (Планирование не реализовано для этого чипа.)
‘eden-x2’: Процессор VIA Eden X2 с поддержкой наборов инструкций x86-64, MMX, SSE, SSE2 и SSE3. (Планирование не реализовано для этого чипа.)
‘eden-x4’

Процессор VIA Eden X4 с набором команд x86-64, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX и AVX2. (Планирование для этого чипа не реализовано.)
‘nano’: Универсальный процессор VIA Nano с набором команд x86-64, MMX, SSE, SSE2, SSE3 и SSSE3. (Планирование для этого чипа не реализовано.)
‘nano-1000’: Процессор VIA Nano 1xxx с набором команд x86-64, MMX, SSE, SSE2, SSE3 и SSSE3. (Планирование для этого чипа не реализовано.)
‘nano-2000’: Процессор VIA Nano 2xxx с набором команд x86-64, MMX, SSE, SSE2, SSE3 и SSSE3. (Планирование для этого чипа не реализовано.)
‘nano-3000’: Процессор VIA Nano 3xxx с набором команд x86-64, MMX, SSE, SSE2, SSE3, SSSE3 и SSE4.1. (Планирование для этого чипа не реализовано.)
‘nano-x2’: Двухъядерный процессор VIA Nano с набором команд x86-64, MMX, SSE, SSE2, SSE3, SSSE3 и SSE4.1. (Планирование для этого чипа не реализовано.)
‘nano-x4’: Четырехъядерный процессор VIA Nano с набором команд x86-64, MMX, SSE, SSE2, SSE3, SSSE3 и SSE4.1. (Планирование для этого чипа не реализовано.)
‘geode’: Встроенный процессор AMD Geode с набором команд MMX и 3DNow!.

-mtune=cpu-type

Настроить на тип-процессора всё применимое в сгенерированном коде, кроме ABI и набора доступных инструкций. Хотя выбор конкретного типа-процессора правильно планирует вещи для конкретного чипа, компилятор не генерирует код, который не может работать на типе машины по умолчанию, если вы не используете параметр -march=тип-процессора. Например, если GCC сконфигурирован для i686-pc-linux-gnu, то -mtune=pentium4 генерирует код, настроенный для Pentium 4, но он всё ещё работает на машинах i686.

Варианты для тип-процессора такие же, как для -march. Кроме того, -mtune поддерживает 2 дополнительных варианта для тип-процессора:

‘generic’

Сгенерировать код, оптимизированный для наиболее распространённых процессоров IA32/AMD64/EM64T. Если вы знаете процессор, на котором будет выполняться ваш код, то вы должны использовать соответствующий параметр -mtune или -march вместо -mtune=generic. Однако, если вы не знаете точно, какой процессор будут иметь пользователи вашего приложения, то вы должны использовать этот параметр.

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

Нет параметра -march=generic, потому что -march указывает набор инструкций, который может использовать компилятор, а универсального набора инструкций, применимого ко всем процессорам, не существует. В отличие от этого, -mtune указывает процессор (или, в данном случае, набор процессоров), для которого оптимизируется код.

‘intel’

Сгенерировать код, оптимизированный для самых современных процессоров Intel, которые являются Haswell и Silvermont для этой версии GCC. Если вы знаете процессор, на котором будет выполняться ваш код, то вы должны использовать соответствующий параметр -mtune или -march вместо -mtune=intel. Но если вы хотите, чтобы ваше приложение работало лучше как на Haswell, так и на Silvermont, то вы должны использовать этот параметр.

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

Нет параметра -march=intel, потому что -march указывает набор инструкций, который может использовать компилятор, а универсального набора инструкций, применимого ко всем процессорам, не существует. В отличие от этого, -mtune указывает процессор (или, в данном случае, набор процессоров), для которого оптимизируется код.

-mcpu=cpu-type

Устаревший синоним для -mtune.

-mfpmath=unit

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

‘387’

Использовать стандартный сопроцессор с плавающей запятой 387, присутствующий на большинстве чипов и эмулированный в противном случае. Код, скомпилированный с этим параметром, работает практически везде. Временные результаты вычисляются с точностью 80 бит вместо точности, заданной типом, что приводит к немного другим результатам по сравнению с большинством других чипов. См. -ffloat-store для более подробного описания.

Это стандартный выбор для не-Darwin x86-32 целей.

‘sse’

Использовать скалярные инструкции с плавающей запятой, присутствующие в наборе команд SSE. Этот набор инструкций поддерживается процессорами Pentium III и новее, а в линейке AMD — Athlon-4, Athlon XP и Athlon MP. Более ранние версии набора инструкций SSE поддерживают только арифметику одинарной точности, поэтому арифметика двойной и расширенной точности всё ещё выполняется с помощью 387. Более поздняя версия, присутствующая только в процессорах Pentium 4 и AMD x86-64, поддерживает также арифметику двойной точности.

Для x86-32 компилятора необходимо использовать переключатели -march=тип-процессора, -msse или -msse2, чтобы включить расширения SSE и сделать этот параметр эффективным. Для x86-64 компилятора эти расширения включены по умолчанию.

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

Это стандартный выбор для x86-64 компилятора, целей Darwin x86-32 и стандартный выбор для x86-32 целей с набором инструкций SSE2, когда включен -ffast-math.

‘sse,387’

‘sse+387’

‘both’

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

-masm=dialect

Вывести инструкции ассемблера с использованием выбранного диалекта. Также влияет на диалект, используемый для базовых asm (см. Basic Asm) и расширенных asm (см. Extended Asm). Поддерживаемые варианты (в порядке диалектов) — ‘att’ или ‘intel’. По умолчанию — ‘att’. Darwin не поддерживает ‘intel’.

-mieee-fp

-mno-ieee-fp

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

-m80387

-mhard-float

Генерировать вывод, содержащий инструкции 80387 для плавающей точки.

-mno-80387

-msoft-float

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

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

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

-mno-fp-ret-in-387

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

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

Параметр -mno-fp-ret-in-387 заставляет возвращать такие значения в обычных регистрах процессора вместо этого.

-mno-fancy-math-387

Некоторые эмуляторы 387 не поддерживают инструкции sin, cos и sqrt для 387. Укажите этот параметр, чтобы избежать генерации этих инструкций. Этот параметр является стандартным для OpenBSD и NetBSD. Этот параметр переопределяется, когда -march указывает, что целевой процессор всегда имеет FPU, и поэтому инструкция не требует эмуляции. Эти инструкции не генерируются, если вы также не используете переключатель -funsafe-math-optimizations.

-malign-double

-mno-align-double

Управление тем, выравнивает ли GCC переменные double, long double, и long long на границе двух слов или одном слове. Выравнивание переменных double на границе двух слов создаёт код, который работает немного быстрее на Pentium за счёт большего использования памяти.

В x86-64 -malign-double включено по умолчанию.

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

-m96bit-long-double

-m128bit-long-double

Эти переключатели управляют размером типа long double. Двоичный интерфейс приложения x86-32 определяет размер как 96 бит, поэтому -m96bit-long-double является стандартным в 32-битном режиме.

Современные архитектуры (Pentium и новее) предпочитают, чтобы long double выравнивались на 8- или 16-байтовую границу. В массивах или структурах, соответствующих ABI, это невозможно. Поэтому указание -m128bit-long-double выравнивает long double на 16-байтовую границу, добавив заполнение long double дополнительными 32-битными нулями.

В x86-64 компиляторе -m128bit-long-double — стандартный выбор, так как ABI определяет, что long double выравнивается на 16-байтовую границу.

Обратите внимание, что ни один из этих параметров не увеличивает точность по сравнению со стандартными 80 битами x87 для long double.

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

-mlong-double-64

-mlong-double-80

-mlong-double-128

Эти переключатели управляют размером типа long double. Размер 64 бита делает тип long double эквивалентным типу double. Это значение по умолчанию для 32-битной библиотеки Bionic C. Размер 128 битов делает тип long double эквивалентным типу __float128. Это значение по умолчанию для 64-битной библиотеки Bionic C.

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

-malign-data=type

Управление выравниванием переменных GCC. Поддерживаемые значения для type — ‘compat’ использует увеличенное значение выравнивания, совместимое со значениями GCC 4.8 и более ранними версиями, ‘abi’ использует значение выравнивания, как указано в psABI, а ‘cacheline’ использует увеличенное значение выравнивания для соответствия размеру строки кэша. ‘compat’ — значение по умолчанию.

-mlarge-data-threshold=threshold

Когда указано -mcmodel=medium, объекты данных, больше threshold, размещаются в разделе больших данных. Это значение должно быть одинаковым для всех объектов, связанных в бинарный файл, и по умолчанию равно 65535.

-mrtd

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

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

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

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

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

-mregparm=num

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

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

-msseregparm

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

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

-mvect8-ret-in-mem

Возврат 8-байтовых векторов в память вместо регистров MMX. Это значение по умолчанию для Solaris 8 и 9 и VxWorks для соответствия ABI компиляторов Sun Studio до версии 12. Более поздние версии компилятора (начиная с Studio 12 Update 1) следуют ABI, используемому другими x86 целевыми платформами, что является значением по умолчанию для Solaris 10 и более поздних версий. Только используйте эту опцию, если вам нужно сохранить совместимость с существующим кодом, созданным этими предыдущими версиями компилятора или более старыми версиями GCC.

-mpc32

-mpc64

-mpc80

Установите точность чисел с плавающей точкой 80387 до 32, 64 или 80 бит. При указании -mpc32, значащие разряды результатов операций с плавающей точкой округляются до 24 бит (одинарная точность); -mpc64 округляет значащие разряды результатов операций с плавающей точкой до 53 бит (двойная точность), а -mpc80 округляет значащие разряды результатов операций с плавающей точкой до 64 бит (расширенная двойная точность), что является значением по умолчанию. Когда используется эта опция, операции с плавающей точкой в более высокой точности недоступны программисту без явного установки слова управления FPU.

Установка округления операций с плавающей точкой до значения меньше 80 бит может ускорить некоторые программы на 2% или более. Обратите внимание, что некоторые математические библиотеки предполагают, что операции с плавающей точкой расширенной точности (80 бит) включены по умолчанию; процедуры в таких библиотеках могут понести значительные потери точности, обычно из-за так называемой «катастрофической отмены», когда эта опция используется для установки точности ниже расширенной точности.

-mstackrealign

Перевыравнивание стека при входе. На x86 опция -mstackrealign генерирует альтернативный пролог и эпилог, которые перевыравнивают стек во время выполнения, если это необходимо. Это поддерживает смешивание устаревшего кода, который сохраняет 4-байтовое выравнивание стека, с современным кодом, который сохраняет 16-байтовое выравнивание стека для совместимости SSE. См. также атрибут force_align_arg_pointer, применимый к отдельным функциям.

-mpreferred-stack-boundary=num

Попытка сохранить границу стека, выровненную по границе в 2^num байт. Если -mpreferred-stack-boundary не указан, значение по умолчанию — 4 (16 байт или 128 бит).

Предупреждение: При генерации кода для архитектуры x86-64 с отключенными расширениями SSE, -mpreferred-stack-boundary=3 может использоваться для сохранения границы стека, выровненной по 8-байтовой границе. Поскольку x86-64 ABI требует выравнивание стека по 16 байтам, это несовместимо с ABI и предназначено для использования в контролируемой среде, где ограничено пространство стека. Эта опция приводит к неправильному коду, когда функции, скомпилированные с 16-байтовым выравниванием стека (например, функции из стандартной библиотеки), вызываются с неправильно выровненным стеком. В этом случае инструкции SSE могут привести к ошибке доступа к неправильно выровненной памяти. Кроме того, обработка переменных аргументов некорректна для 16-байтовых выровненных объектов (включая x87 long double и __int128), что приводит к неправильным результатам. Вы должны скомпилировать все модули с -mpreferred-stack-boundary=3, включая любые библиотеки. Это включает системные библиотеки и модули загрузки.

-mincoming-stack-boundary=num

Предположить, что входящий стек выровнен по границе в 2^num байт. Если -mincoming-stack-boundary не указан, используется значение, заданное -mpreferred-stack-boundary.

На Pentium и Pentium Pro, значения double и long double должны быть выровнены по 8-байтовой границе (см. -malign-double), иначе это приведет к значительным потерям производительности во время выполнения. На Pentium III тип данных расширения потоковой обработки SIMD (SSE) __m128 может работать неправильно, если он не выровнен по 16 байтам.

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

Это дополнительное выравнивание потребляет дополнительное пространство стека и, как правило, увеличивает размер кода. Код, чувствительный к использованию пространства стека, такой как встроенные системы и ядра операционных систем, может захотеть уменьшить предпочтительное выравнивание до -mpreferred-stack-boundary=2.

-mmmx

-msse

-msse2

-msse3

-mssse3

-msse4

-msse4a

-msse4.1

-msse4.2

-mavx

-mavx2

-mavx512f

-mavx512pf

-mavx512er

-mavx512cd

-mavx512vl

-mavx512bw

-mavx512dq

-mavx512ifma

-mavx512vbmi

-msha

-maes

-mpclmul

-mclflushopt

-mclwb

-mfsgsbase

-mrdrnd

-mf16c

-mfma

-mpconfig

-mwbnoinvd

-mfma4

-mprfchw

-mrdpid

-mprefetchwt1

-mrdseed

-msgx

-mxop

-mlwp

-m3dnow

-m3dnowa

-mpopcnt

-mabm

-madx

-mbmi

-mbmi2

-mlzcnt

-mfxsr

-mxsave

-mxsaveopt

-mxsavec

-mxsaves

-mrtm

-mhle

-mtbm

-mmpx

-mmwaitx

-mclzero

-mpku

-mavx512vbmi2

-mgfni

-mvaes

-mvpclmulqdq

-mavx512bitalg

-mmovdiri

-mmovdir64b

-mavx512vpopcntdq

-mavx5124fmaps

-mavx512vnni

-mavx5124vnniw

Эти переключатели позволяют использовать инструкции набора расширений MMX, SSE, SSE2, SSE3, SSSE3, SSE4, SSE4A, SSE4.1, SSE4.2, AVX, AVX2, AVX512F, AVX512PF, AVX512ER, AVX512CD, AVX512VL, AVX512BW, AVX512DQ, AVX512IFMA, AVX512VBMI, SHA, AES, PCLMUL, CLFLUSHOPT, CLWB, FSGSBASE, RDRND, F16C, FMA, PCONFIG, WBNOINVD, FMA4, PREFETCHW, RDPID, PREFETCHWT1, RDSEED, SGX, XOP, LWP, 3DNow!, расширенный 3DNow!, POPCNT, ABM, ADX, BMI, BMI2, LZCNT, FXSR, XSAVE, XSAVEOPT, XSAVEC, XSAVES, RTM, HLE, TBM, MPX, MWAITX, CLZERO, PKU, AVX512VBMI2, GFNI, VAES, VPCLMULQDQ, AVX512BITALG, MOVDIRI, MOVDIR64B, AVX512VPOPCNTDQ, AVX5124FMAPS, AVX512VNNI или AVX5124VNNIW. Каждый из них имеет соответствующий параметр -mno- для отключения использования этих инструкций.

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

Чтобы автоматически генерировать инструкции SSE/SSE2 из кода с плавающей запятой (в отличие от инструкций 387), см. -mfpmath=sse.

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

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

-mdump-tune-features

Этот параметр инструктирует GCC сгенерировать список названий функций настраиваемой производительности x86 и их значения по умолчанию. Эти имена могут использоваться в -mtune-ctrl=feature-list.

-mtune-ctrl=feature-list

Этот параметр используется для тонкой настройки функций генерации кода x86. feature-list — это список имён feature, разделённых запятыми. См. также -mdump-tune-features. При указании параметр feature включается, если он не предваряется ‘^’, в противном случае он отключается. -mtune-ctrl=feature-list предназначен для разработчиков GCC. Его использование может привести к не покрытым тестированием путям кода и потенциально вызвать сбои компилятора или ошибки во время выполнения.

-mno-default

Этот параметр инструктирует GCC отключить все настраиваемые функции. См. также -mtune-ctrl=feature-list и -mdump-tune-features.

-mcld

Этот параметр инструктирует GCC вставить инструкцию cld в прологе функций, использующих строковые инструкции. Строковые инструкции зависят от флага DF для выбора между режимами автоматического инкремента или автоматического декремента. Хотя ABI определяет, что флаг DF должен быть очищен при входе в функцию, некоторые операционные системы нарушают это условие, не очищая флаг DF в своих обработчиках исключений. Обработчик исключений может быть вызван с установленным флагом DF, что приводит к неправильному направлению при использовании строковых инструкций. Этот параметр можно включить по умолчанию для 32-битных x86 целей, настроив GCC с опцией конфигурации --enable-cld. Генерацию инструкций cld можно подавить с помощью параметра компилятора -mno-cld в этом случае.

-mvzeroupper

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

-mprefer-avx128

Этот параметр инструктирует GCC использовать 128-битные инструкции AVX вместо 256-битных инструкций AVX в автовекторизаторе.

-mprefer-vector-width=opt

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

‘none’: Не применяются дополнительные ограничения к GCC, кроме определенных выбранной платформой.
‘128’: Предпочитать ширину вектора 128 бит для инструкций.
‘256’: Предпочитать ширину вектора 256 бит для инструкций.
‘512’: Предпочитать ширину вектора 512 бит для инструкций.

-mcx16

Этот параметр позволяет GCC генерировать инструкции CMPXCHG16B в 64-битном коде для реализации операций сравнения и обмена на выровненных по 16 байтам 128-битных объектах. Это полезно для атомных обновлений структур данных, превышающих один машинный слово по размеру. Компилятор использует эту инструкцию для реализации __sync Встроенные функции. Однако для __atomic Встроенные функции, работающих с 128-битными целыми числами, всегда используется вызов библиотеки.

-msahf

Этот параметр позволяет генерировать инструкции SAHF в 64-битном коде. Ранние процессоры Intel Pentium 4 с поддержкой Intel 64, до введения шага Pentium 4 G1 в декабре 2005 года, не имели инструкций LAHF и SAHF, которые поддерживаются AMD64. Это инструкции загрузки и сохранения для определённых флагов состояния. В 64-битном режиме инструкция SAHF используется для оптимизации fmod, drem и remainder встроенных функций; см. Другие встроенные функции для получения подробной информации.

-mmovbe

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

-mshstk

Параметр -mshstk включает встроенные функции теневого стека из технологии x86 Control-flow Enforcement (CET).

-mcrc32

Этот параметр включает встроенные функции __builtin_ia32_crc32qi, __builtin_ia32_crc32hi, __builtin_ia32_crc32si и __builtin_ia32_crc32di для генерации машинной инструкции crc32.

-mrecip

Этот параметр позволяет использовать инструкции RCPSS и RSQRTSS (и их векторизованные варианты RCPPS и RSQRTPS) с дополнительным шагом Ньютона-Рафсона для повышения точности вместо DIVSS и SQRTSS (и их векторизованных вариантов) для аргументов с плавающей запятой одинарной точности. Эти инструкции генерируются только при включении -funsafe-math-optimizations вместе с -ffinite-math-only и -fno-trapping-math. Обратите внимание, что, хотя производительность последовательности выше, чем производительность инструкции без обратного вычисления, точность последовательности может быть уменьшена до 2 ulp (т. е. обратное 1.0 равно 0.99999994).

Обратите внимание, что GCC реализует 1.0f/sqrtf(x) в терминах RSQRTSS (или RSQRTPS) уже с -ffast-math (или с вышеуказанным сочетанием параметров) и не требует -mrecip.

Также обратите внимание, что GCC генерирует вышеуказанную последовательность с дополнительным шагом Ньютона-Рафсона для векторизованного деления с плавающей запятой одинарной точности и векторизованного sqrtf(x) уже с -ffast-math (или с вышеуказанным сочетанием параметров) и не требует -mrecip.

-mrecip=opt

Этот параметр управляет тем, какие инструкции оценки обратного вычисления могут быть использованы. opt — это список параметров, разделённых запятыми, которые могут быть предваряться ‘!’ для инвертирования параметра:

‘all’: Включить все инструкции оценки.
‘default’: Включить инструкции по умолчанию, эквивалентные -mrecip.
‘none’: Отключить все инструкции оценки, эквивалентные -mno-recip.
‘div’: Включить приближение для скалярного деления.
‘vec-div’: Включить приближение для векторизованного деления.
‘sqrt’: Включить приближение для скалярного квадратного корня.
‘vec-sqrt’: Включить приближение для векторизованного квадратного корня.

Например, -mrecip=all,!sqrt включает все приближения обратного вычисления, за исключением квадратного корня.

-mveclibabi=type

Указывает тип ABI, который следует использовать для векторизации встроенных функций с использованием внешней библиотеки. Поддерживаемые значения для type — ‘svml’ для библиотеки Intel short vector math и ‘acml’ для библиотеки AMD math core. Чтобы использовать этот параметр, необходимо включить как -ftree-vectorize, так и -funsafe-math-optimizations, а также указать совместимую с ABI SVML или ACML библиотеку во время компоновки.

В настоящее время GCC генерирует вызовы vmldExp2, vmldLn2, vmldLog102, vmldPow2, vmldTanh2, vmldTan2, vmldAtan2, vmldAtanh2, vmldCbrt2, vmldSinh2, vmldSin2, vmldAsinh2, vmldAsin2, vmldCosh2, vmldCos2, vmldAcosh2, vmldAcos2, vmlsExp4, vmlsLn4, vmlsLog104, vmlsPow4, vmlsTanh4, vmlsTan4, vmlsAtan4, vmlsAtanh4, vmlsCbrt4, vmlsSinh4, vmlsSin4, vmlsAsinh4, vmlsAsin4, vmlsCosh4, vmlsCos4, vmlsAcosh4 и vmlsAcos4 для соответствующего типа функции при использовании -mveclibabi=svml, и __vrd2_sin, __vrd2_cos, __vrd2_exp, __vrd2_log, __vrd2_log2, __vrd2_log10, __vrs4_sinf, __vrs4_cosf, __vrs4_expf, __vrs4_logf, __vrs4_log2f, __vrs4_log10f и __vrs4_powf для соответствующего типа функции при использовании -mveclibabi=acml.

-mabi=name

Генерирует код для указанного соглашения вызова. Допустимые значения — ‘sysv’ для ABI, используемого в GNU/Linux и других системах, и ‘ms’ для Microsoft ABI. По умолчанию используется Microsoft ABI при нацеливании на Microsoft Windows и SysV ABI во всех остальных системах. Вы можете управлять этим поведением для отдельных функций, используя атрибуты функций ms_abi и sysv_abi. См. Атрибуты функций.

-mforce-indirect-call

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

-mcall-ms2sysv-xlogues

Из-за различий в 64-битных ABI любые функции Microsoft ABI, которые вызывают функцию System V ABI, должны учитывать RSI, RDI и XMM6-15 как затронутые. По умолчанию код сохранения и восстановления этих регистров генерируется встраиваемо, что приводит к довольно длинным прологам и эпилогам. Использование -mcall-ms2sysv-xlogues генерирует прологи и эпилоги, которые используют подпрограммы в статической части libgcc для выполнения этих сохранений и восстановлений, тем самым уменьшая размер функции за счёт нескольких дополнительных инструкций.

-mtls-dialect=type

Генерирует код для доступа к хранилищу потоко-локального хранения с использованием соглашений ‘gnu’ или ‘gnu2’. ‘gnu’ — консервативный вариант по умолчанию; ‘gnu2’ более эффективен, но может добавить требования к компиляции и выполнению, которые не могут быть удовлетворены на всех системах.

-mpush-args

-mno-push-args

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

-maccumulate-outgoing-args

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

-mthreads

Поддержка потокобезопасной обработки исключений в MinGW. Программы, которые полагаются на потокобезопасную обработку исключений, должны скомпилировать и связать весь код с опцией -mthreads. При компиляции -mthreads определяет -D_MT; при компоновке он связывает специальную библиотеку помощника потоков -lmingwthrd, которая очищает данные обработки исключений на уровне каждого потока.

-mms-bitfields

-mno-ms-bitfields

Включает/отключает макет полей битов, совместимый с родным компилятором Microsoft Windows.

Если packed используется в структуре или если используются поля битов, то может быть, что Microsoft ABI выстраивает структуру иначе, чем обычно делает GCC. Особенно при перемещении упакованных данных между функциями, скомпилированными с GCC и родным компилятором Microsoft (либо через вызов функции, либо как данные в файле), может потребоваться доступ к обоим форматам.

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

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

Члены структуры хранятся последовательно в том порядке, в котором они объявлены: первый член имеет наименьший адрес памяти, а последний член — наибольший.
Каждый объект данных имеет требования к выравниванию. Требование к выравниванию для всех данных, кроме структур, объединений и массивов, равно либо размеру объекта, либо текущему размеру упаковки (указывается либо атрибутом aligned, либо директивой pack), что из них меньше. Для структур, объединений и массивов требование к выравниванию — это наибольшее требование к выравниванию его членов. Каждый объект выделяет смещение так, чтобы:
```
offset % alignment_requirement == 0
```
Смежные поля битов упаковываются в один, два или четыре байта, если целочисленные типы имеют одинаковый размер и если следующее поле бита помещается в текущую единицу выделения без пересечения границы, наложенной общими требованиями к выравниванию полей битов.

MSVC интерпретирует поля битов нулевой длины следующим образом:

Если поле бита нулевой длины вставлено между двумя полями битов, которые обычно сливаются, поля битов не сливаются.
Например:
```
struct
 {
   unsigned long bf_1 : 12;
   unsigned long : 0;
   unsigned long bf_2 : 12;
 } t1;
```
Размер t1 составляет 8 байт с полем бита нулевой длины. Если поле бита нулевой длины удалить, размер t1 будет 4 байта.
Если поле бита нулевой длины вставлено после поля бита, foo, и выравнивание поля бита нулевой длины больше, чем члена, который следует за ним, bar, bar выравнивается как тип поля бита нулевой длины.
Например:
```
struct
 {
   char foo : 4;
   short : 0;
   char bar;
 } t2;

struct
 {
   char foo : 4;
   short : 0;
   double bar;
 } t3;
```
Для t2, bar размещается по смещению 2, а не по смещению 1. Соответственно, размер t2 равен 4. Для t3, поле бита нулевой длины не влияет на выравнивание bar или, как следствие, на размер структуры.

С учётом этого важно отметить следующее:
1. Если поле бита нулевой длины следует за обычным полем бита, тип поля бита нулевой длины может повлиять на выравнивание всей структуры. Например, t2 имеет размер 4 байта, поскольку поле бита нулевой длины следует за обычным полем бита и является типа short.
2. Даже если поле бита нулевой длины не следует за обычным членом, оно всё равно может повлиять на выравнивание структуры:
```
struct
 {
   char foo : 6;
   long : 0;
 } t4;
```
  Здесь t4 занимает 4 байта.
Поля битов нулевой длины, следующие за членами, не являющимися полями битов, игнорируются:
```
struct
 {
   char foo;
   long : 0;
   char bar;
 } t5;
```
Здесь t5 занимает 2 байта.

-mno-align-stringops

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

-minline-all-stringops

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

-minline-stringops-dynamically

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

-mstringop-strategy=alg

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

‘rep_byte’
‘rep_4byte’
‘rep_8byte’: Расширяет с использованием i386 rep префикса указанного размера.
‘byte_loop’
‘loop’
‘unrolled_loop’: Расширяется в цикл встраивания.
‘libcall’: Всегда используйте вызов библиотеки.

-mmemcpy-strategy=strategy

Переопределяет внутреннюю эвристику принятия решения о том, следует ли встраивать __builtin_memcpy и какой использовать алгоритм встраивания, когда ожидаемый размер операции копирования известен. strategy — это список alg:max_size:dest_align троек, разделённых запятыми. alg указан в -mstringop-strategy, max_size указывает максимальный размер байтов, с которым алгоритм встраивания alg разрешается. Для последней тройки max_size должно быть -1. max_size троек в списке должны быть указаны в порядке возрастания. Минимальный размер байта для alg составляет 0 для первой тройки и max_size + 1 предыдущего диапазона.

-mmemset-strategy=strategy

Эта опция похожа на -mmemcpy-strategy=, за исключением того, что она контролирует __builtin_memset расширение.

-momit-leaf-frame-pointer

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

-mtls-direct-seg-refs

-mno-tls-direct-seg-refs

Управляет тем, могут ли переменные TLS быть обработаны с помощью смещений от регистра сегмента TLS (%gs для 32-битных, %fs для 64-битных), или ли должна быть добавлена основа потока. Действительность зависит от операционной системы и того, отображает ли она сегмент для покрытия всего TLS-региона.

Для систем, которые используют GNU C Library, по умолчанию включено.

-msse2avx

-mno-sse2avx

Указывает ассемблеру кодировать инструкции SSE с префиксом VEX. Опция -mavx включает это по умолчанию.

-mfentry

-mno-fentry

Если профилирование активно (-pg), поместите вызов счётчика профилирования перед прологом. Примечание: на архитектурах x86 атрибут ms_hook_prologue в настоящее время невозможен для -mfentry и -pg.

-mrecord-mcount

-mno-record-mcount

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

-mnop-mcount

-mno-nop-mcount

Если профилирование включено (-pg), генерировать вызовы функций профилирования как NOP. Это полезно, когда они должны быть запатчены позже динамически. Скорее всего, это будет полезно только вместе с -mrecord-mcount.

-mskip-rax-setup

-mno-skip-rax-setup

При генерации кода для архитектуры x86-64 с отключёнными расширениями SSE, -mskip-rax-setup может использоваться для пропуска настройки регистра RAX, когда нет переменных аргументов, передаваемых в регистрах векторов.

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

-m8bit-idiv

-mno-8bit-idiv

На некоторых процессорах, таких как Intel Atom, деление 8-битных беззнаковых целых чисел намного быстрее, чем деление 32/64-битных целых чисел. Этот параметр генерирует проверку во время выполнения. Если и делимое, и делитель находятся в диапазоне от 0 до 255, используется деление 8-битных беззнаковых целых чисел вместо 32/64-битного деления.

-mavx256-split-unaligned-load

-mavx256-split-unaligned-store

Разделение 32-байтового невыровненного загрузки и сохранения AVX.

-mstack-protector-guard=guard

-mstack-protector-guard-reg=reg

-mstack-protector-guard-offset=offset

Генерировать код защиты стека с использованием канделяря в guard. Поддерживаемые расположения — ‘global’ для глобального канделяря или ‘tls’ для канделяря на нить в блоке TLS (по умолчанию). Этот параметр имеет эффект только при указании -fstack-protector или -fstack-protector-all.

С последним выбором параметры -mstack-protector-guard-reg=reg и -mstack-protector-guard-offset=offset дополнительно указывают, какой сегментный регистр (%fs или %gs) использовать в качестве базового регистра для чтения канделяря, и с какого смещения от этого базового регистра. По умолчанию они задаются как указано в соответствующем ABI.

-mmitigate-rop

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

-mgeneral-regs-only

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

-mindirect-branch=choice

Преобразовать косвенный вызов и переход с помощью choice. По умолчанию — ‘keep’, что сохраняет косвенный вызов и переход неизменными. ‘thunk’ преобразует косвенный вызов и переход в вызов и возврат thunk. ‘thunk-inline’ преобразует косвенный вызов и переход во встроенный вызов и возврат thunk. ‘thunk-extern’ преобразует косвенный вызов и переход во внешний вызов и возврат thunk, предоставленный в отдельном объектом файле. Вы можете управлять этим поведением для конкретной функции, используя атрибут функции indirect_branch. См. Атрибуты функций.

Обратите внимание, что -mcmodel=large несовместим с -mindirect-branch=thunk и -mindirect-branch=thunk-extern, так как функция thunk может быть недоступна в модели большого кода.

Обратите внимание, что -mindirect-branch=thunk-extern несовместим с -fcf-protection=branch и -fcheck-pointer-bounds, так как внешняя функция thunk не может быть изменена для отключения проверки потока управления.

-mfunction-return=choice

Преобразовать возврат функции с помощью choice. По умолчанию — ‘keep’, что сохраняет возврат функции неизменным. ‘thunk’ преобразует возврат функции в вызов и возврат thunk. ‘thunk-inline’ преобразует возврат функции во встроенный вызов и возврат thunk. ‘thunk-extern’ преобразует возврат функции во внешний вызов и возврат thunk, предоставленный в отдельном объектом файле. Вы можете управлять этим поведением для конкретной функции, используя атрибут функции function_return. См. Атрибуты функций.

Обратите внимание, что -mcmodel=large несовместим с -mfunction-return=thunk и -mfunction-return=thunk-extern, так как функция thunk может быть недоступна в модели большого кода.

-mindirect-branch-register

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

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

-m32

-m64

-mx32

-m16

-miamcu

Генерировать код для 16-битной, 32-битной или 64-битной среды. Параметр -m32 устанавливает int, long, и типы указателей на 32 бита и генерирует код, работающий на любом i386 системе.

Параметр -m64 устанавливает int на 32 бита и long и типы указателей на 64 бита, и генерирует код для архитектуры x86-64. Только для Darwin, параметр -m64 также отключает параметры -fno-pic и -mdynamic-no-pic.

Параметр -mx32 устанавливает int, long, и типы указателей на 32 бита, и генерирует код для архитектуры x86-64.

Параметр -m16 такой же, как -m32, за исключением того, что он выводит директиву .code16gcc в начале вывода ассемблерного кода, чтобы бинарный файл мог работать в 16-битном режиме.

Параметр -miamcu генерирует код, соответствующий psABI Intel MCU. Он требует, чтобы параметр -m32 был включён.

-mno-red-zone

Не использовать так называемую «красную зону» для кода x86-64. Красная зона предписана x86-64 ABI; это область размером 128 байт за местоположением указателя стека, которая не изменяется обработчиками сигналов или прерываний и, следовательно, может использоваться для временных данных без корректировки указателя стека. Флаг -mno-red-zone отключает эту красную зону.

-mcmodel=small

Генерировать код для модели малого кода: программа и её символы должны быть связаны в нижних 2 ГБ адресного пространства. Указатели — 64 бита. Программы могут быть статически или динамически связаны. Это модель кода по умолчанию.

-mcmodel=kernel

Генерировать код для модели кода ядра. Ядро работает в отрицательных 2 ГБ адресного пространства. Эта модель должна использоваться для кода ядра Linux.

-mcmodel=medium

Генерировать код для модели среднего размера: программа связывается в нижних 2 ГБ адресного пространства. Маленькие символы также помещаются туда. Символы размером больше -mlarge-data-threshold помещаются в секции данных или BSS большого размера и могут располагаться выше 2 ГБ. Программы могут быть статически или динамически связаны.

-mcmodel=large

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

-maddress-mode=long

Генерировать код для режима длинного адреса. Это поддерживается только для 64-битных и x32 сред. Это режим адреса по умолчанию для 64-битных сред.

-maddress-mode=short

Генерировать код для режима короткого адреса. Это поддерживается только для 32-битных и x32 сред. Это режим адреса по умолчанию для 32-битных и x32 сред.

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

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