1 Опции печати помощи

--help
Печатать этот текст

--help-raw
Печатать этот текст в форматированном виде для автоматической обработки

2 Опции управления процессом компиляции

-c
Компилировать или ассемблировать исходные файлы, но не линковать. Стадия линковки просто не выполняется. Конечный вывод происходит в форме объектного файла для каждого исходного файла.

По умолчанию, имя объектного файла делается из имени исходного файла заменой суффикса «.c», «.i», «.s», и.т.д. на «.o».

При подаче на вход не распознанного файла (включая случаи, когда подается не распознанный и распознанный файл вместе) компилятор выдает следующее сообщение об ошибке: «lcc: ошибка: <имя не распознанного файла>: файл неизвестного типа передан для компиляции». При этом объектный файл не создается.

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

По умолчанию, имя файла с ассемблерным кодом делается из имени исходного файла заменой суффикса «.c», «.i», и.т.д. на «.s».

При подаче на вход не распознанного файла (включая случаи, когда подается не распознанный и распознанный файл вместе) компилятор выдает следующее сообщение об ошибке: «lcc: ошибка: <имя не распознанного файла>: файл неизвестного типа передан для компиляции». При этом файл с ассемблерным кодом не создается.

-o<file> (-o <file>)
Поместить вывод в файл «<file>». Эта опция применяется вне зависимости от вида порождаемого файла, есть ли это исполняемый файл, объектный файл, ассемблерный файл или препроцессированный C код.

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

Если -o не указано, по умолчанию исполняемый файл помещается в «a.out», объектный файл для «исходный.суффикс» - в «исходный.o», его ассемблерный код в «исходный.s» и все препроцессированные C файлы - в стандартный вывод.

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

-vs
Выводить только строки запуска компонент

--tempdir <dir>
Установить директорию для временных файлов

-save-temps
Создавать временные файлы в текущей директории и не удалять их

-pthread (-pthread)
Подключить потоковые библиотеки и макросы

-ww
Подавлять все предупреждения, не относящиеся к исходному тексту программы

3 Опции режима компиляции целевой архитектуры

-mtune=<cpu>
Формировать код для процессора «<cpu>». Параметр опции может принимать следующие значения: elbrus-2c+, elbrus-4c, elbrus-8c, elbrus-1c+, elbrus-8c2, elbrus-12c, elbrus-16c, elbrus-2c3. При одновременном наличии в командной строке опций -mtune и -march, во внимание принимается только опция -mtune, а опция -march игнорируется

-mtune=elbrus-2c+ - компилировать программу для процессора "Эльбрус-2C+" (работающего на системе команд v2). Программы, скомпилированные в таком режиме, работают более эффективно на процессоре "Эльбрус-2C+", но могут вызывать проблемы при исполнении на других процессорах. Поэтому при помощи специального маркера в бинарном файле такие программы защищаются от исполнения на других процессорах

-mtune=elbrus-4c - компилировать программу для процессора "Эльбрус-4C" (работающего на системе команд v3). Программы, скомпилированные в таком режиме, работают более эффективно на процессоре "Эльбрус-4C", но могут вызывать проблемы при исполнении на других процессорах. Поэтому при помощи специального маркера в бинарном файле такие программы защищаются от исполнения на других процессорах

-mtune=elbrus-8c - компилировать программу для процессора "Эльбрус-8C" (работающего на системе команд v4). Программы, скомпилированные в таком режиме, работают более эффективно на процессоре "Эльбрус-8C", но могут вызывать проблемы при исполнении на других процессорах. Поэтому при помощи специального маркера в бинарном файле такие программы защищаются от исполнения на других процессорах

-mtune=elbrus-1c+ - компилировать программу для процессора "Эльбрус-1C+" (работающего на системе команд v4). Программы, скомпилированные в таком режиме, работают более эффективно на процессоре "Эльбрус-1C+", но могут вызывать проблемы при исполнении на других процессорах. Поэтому при помощи специального маркера в бинарном файле такие программы защищаются от исполнения на других процессорах

-mtune=elbrus-8c2 - компилировать программу для процессора "Эльбрус-8C2" (работающего на системе команд v5). Программы, скомпилированные в таком режиме, работают более эффективно на процессоре "Эльбрус-8C2", но могут вызывать проблемы при исполнении на других процессорах. Поэтому при помощи специального маркера в бинарном файле такие программы защищаются от исполнения на других процессорах

-mtune=elbrus-12c - компилировать программу для процессора "Эльбрус-12C" (работающего на системе команд v6). Программы, скомпилированные в таком режиме, работают более эффективно на процессоре "Эльбрус-12C", но могут вызывать проблемы при исполнении на других процессорах. Поэтому при помощи специального маркера в бинарном файле такие программы защищаются от исполнения на других процессорах

-mtune=elbrus-16c - компилировать программу для процессора "Эльбрус-16C" (работающего на системе команд v6). Программы, скомпилированные в таком режиме, работают более эффективно на процессоре "Эльбрус-16C", но могут вызывать проблемы при исполнении на других процессорах. Поэтому при помощи специального маркера в бинарном файле такие программы защищаются от исполнения на других процессорах

-mtune=elbrus-2c3 - компилировать программу для процессора "Эльбрус-2C3" (работающего на системе команд v6). Программы, скомпилированные в таком режиме, работают более эффективно на процессоре "Эльбрус-2C3", но могут вызывать проблемы при исполнении на других процессорах. Поэтому при помощи специального маркера в бинарном файле такие программы защищаются от исполнения на других процессорах

-mtune=native - для native-компилятора включить режим -mtune со значением, соответствующим модели процессора, на котором в настоящий момент запускается компилятор. Для cross-компилятора включить режим компилятора по умолчанию в отношении настройки target-процессора

-march=<arch>
Формировать код для системы команд «<arch>». Параметр опции может принимать следующие значения: elbrus-v2, elbrus-v3, elbrus-v4, elbrus-v5, elbrus-v6, elbrus-v7. При одновременном наличии в командной строке опций -march и -mtune, опция -march игнорируется

Системы команд процессоров семейства "Эльбрус" с точки зрения совместимости можно выстроить в следующем порядке: "система команд v2" - "система команд v3" - "система команд v4" - "система команд v5" - "система команд v6" - "система команд v7". Программы, скомпилированные в более ранней системе команд (согласно этой линейке слева направо), смогут исполняться на процессорах с более поздней системой команд. Программы, скомпилированные в более поздней системе команд, НЕ смогут исполняться на процессорах с более ранней системой команд (операционная система не позволит эти программы запустить). Новые процессоры, которые могут появиться в будущем, в цепочку становятся с правой стороны

-march=elbrus-v2 - компилировать программу под систему команд v2. Программа сможет исполняться на процессорах с системой команд v2 и выше

-march=elbrus-v3 - компилировать программу под систему команд v3. Программа сможет исполняться на процессорах с системой команд v3 и выше

-march=elbrus-v4 - компилировать программу под систему команд v4. Программа сможет исполняться на процессорах с системой команд v4 и выше

-march=elbrus-v5 - компилировать программу под систему команд v5. Программа сможет исполняться на процессорах с системой команд v5 и выше

-march=elbrus-v6 - компилировать программу под систему команд v6. Программа сможет исполняться на процессорах с системой команд v6 и выше

-march=elbrus-v7 - компилировать программу под систему команд v7. Программа сможет исполняться на процессорах с системой команд v7 и выше

-march=native - для native-компилятора включить режим -march со значением, соответствующим модели процессора, на котором в настоящий момент запускается компилятор. Для cross-компилятора включить режим компилятора по умолчанию в отношении настройки target-процессора

-mptr32 (-m32)
Компилировать в режиме 32 бит

-mptr64 (-m64)
Компилировать в режиме 64 бит

-mptr128 (-m128)
Компилировать в защищённом режиме

-mptr128-64
Компилировать в защищённом режиме до объектного файла, который затем можно подать в линковку в режиме -mptr64 (экспериментальная поддержка)

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

В режимах для процессоров версии elbrus-v5 и выше опция игнорируется, поскольку в библиотеках для elbrus-v5 и выше есть невыровненные обращения к памяти. Кроме того, компилятор в режиме компиляции для elbrus-v5 и выше может создавать невыровненные обращения к памяти. Из-за этого коды, собранные с этой опцией для более ранних версий архитектуры не будут работать на elbrus-v5 и выше в режиме с динамическими библиотеками, собранными в кодах elbrus-v5 и выше (подробнее см. описание опции -faligned). Таким образом, программы, собранные с данной опцией, могут быть несовместимы с более новыми версиями архитектуры. Полноценная реализация опции с обеспечением обратной совместимости требует больших накладных расходов (нужно либо использовать две версии библиотек, либо заводить дополнительные биты в связующей информации), поэтому от неё решено было отказаться.

4 Опции управления языковыми настройками

-std=<standard>
Использовать стандарт C/C++/Fortran «<standard>»

В режиме языка C параметр может принимать значения: c89, gnu89, c90, iso9899:1990, iso9899:199409, gnu90, c9x, gnu9x, c99, iso9899:1999, gnu99, c1x, gnu1x, c11, iso9899:2011, gnu11, c17, c18, iso9899:2017, iso9899:2018, gnu17, gnu18. По умолчанию установлен режим -std=gnu18

В режиме языка C++ параметр может принимать значения: c++98, gnu++98, c++03, gnu++03, c++0x, gnu++0x, c++11, gnu++11, c++1y, gnu++1y, c++14, gnu++14, c++1z, gnu++1z, c++17, gnu++17, c++2a, gnu++2a, c++20, gnu++20. По умолчанию установлен режим -std=gnu++14. Для языков C++17 и C++20 поддержка экспериментальная

В режиме языка Fortran параметр может принимать значения: f95, f2003, f2008, gnu, legacy, f2008ts, f2018. По умолчанию установлен режим -std=gnu

-ansi
В режиме языка C эквивалентно -std=c89, в режиме языка C++ эквивалентно -std=c++98

-gcc-version <version>
Настроить lcc/l++ на совместимость с gcc версии <version> в отношении входного языка

-fopenmp (-fno-openmp)
Поддерживать директивы OpenMP

-fopenmp-simd (-fno-openmp-simd)
Включить поддержку SIMD директив OpenMP. Другие директивы игнорируются

5 Опции управления языковыми настройками C/C++

-fanachronisms
Разрешать устаревшие конструкции C++

-fpermissive
Некоторые ошибки по части устаревших конструкций C++ трактовать, как предупреждения

-fexceptions (-fno-exceptions)
Включить (выключить) поддержку обработки исключительных ситуаций

-fhandle-exceptions (-fno-handle-exceptions)
Эквивалентно -fexceptions (-fno-exceptions)

-funwind-tables (-fno-unwind-tables)
В режиме -fexceptions включить (выключить) построение информации о раскрутке стека

-fasynchronous-unwind-tables (-fno-asynchronous-unwind-tables)
Эквивалентно -funwind-tables (-fno-unwind-tables)

-feh-personality=<name>
Изменить название personality-функции

-frtti (-fno-rtti)
Включить (выключить) поддержку Run-Time Type Information

-ffor-scope (-fno-for-scope)
Ограничивать (не ограничивать) видимость переменных, объявленных внутри блока инициализации for, самим циклом for

-foperator-names (-fno-operator-names)
В режиме C++ поддерживать (не поддерживать) ключевые слова and, and_eq, bitand, bitor, compl, not, not_eq, or, or_eq, xor, xor_eq

-ftemplate-depth=<num> (-ftemplate-depth-<num>)
Установить допустимую глубину вложенности шаблонов C++

-ftemplate-backtrace-limit=<num>
Установить глубину выдачи стека инстанциирования шаблонов C++ в случае выдачи ошибки в исходнике. Значение 0 соответствует неограниченной выдаче

-fconstexpr-depth=<num>
Установить допустимую глубину рекурсии constexpr-выражений C++

-fconstexpr-loop-limit=<num>
Игнорируется

-fconstexpr-ops-limit=<num>
Установить допустимую вычислительную сложность constexpr-выражений C++, измеряется в количестве операций вызовов и количестве итераций циклов

-fbuilding-runtime
Опция используется для компиляции библиотеки поддержки C++ времени исполнения

-fbuilding-libgcc
Опция используется для компиляции библиотеки поддержки libgcc

-funsigned-char (-fsigned-char)
Каждая машина имеет настройки по умолчанию - каким должен быть char: таким, как unsigned char или таким, как signed char.

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

Тип char всегда отличен и от signed char, и от unsigned char (и это критично для C++), хотя его поведение всегда такое же, как у одного из этих двух типов.

-fgnu89-inline (-fno-gnu89-inline)
В режиме C99 и выше трактовать модификатор inline в терминах языка GNU C89

-flax-vector-conversions
Разрешать неявное преобразование типов для векторных типов с одинаковымы размерами, но разными базовыми типами

-traditional (-traditional-cpp)
В режиме препроцессирования использовать старый стиль препроцессирования

-trigraphs
Поддерживаются трехсимвольные последовательности ANSI C. Опция -ansi включает -trigraphs

-fno-gnu-keywords
В режиме C++ с использованием gnu-расширений не рассматривать typeof как ключевое слово

-fsized-deallocation (-fno-sized-deallocation)
В режиме C++ включить (выключить) встроенные описания
    void operator delete (void *, std::size_t) noexcept;
    void operator delete[] (void *, std::size_t) noexcept;
    
Эти описания появились в стандарте C++14, где они поддерживаются по умолчанию, но по опции поддержку можно включить и при использовании более ранних стандартов

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

-faligned-new (-fno-aligned-new)
В режиме C++ включить (выключить) поддержку over-aligned allocation. Это свойство появилось в стандарте C++17, где оно поддерживается по умолчанию, но по опции поддержку можно включить и при использовании более ранних стандартов

Обычные операторы new выделяют память по адресам, кратным выравниванию типа std::maxalign_t. Если нужно выделить память под тип, который выровнен ещё больше (например, выравнивание типа задано с помощью спецификатора alignof), то компилятор построит вызов перегруженного (placement) оператора new, у которого вторым аргументом идёт величина выравнивания

-fchar8_t (-fno-char8_t)
В режиме C++ включить (выключить) поддержку базового типа char8_t. Это свойство появилось в стандарте C++20, где оно поддерживается по умолчанию, но по опции поддержку можно включить и при использовании более ранних стандартов

-fextended-identifiers (-fno-extended-identifiers)
В режиме C/C++ включить (выключить) поддержку universal character names в идентификаторах

6 Опции управления языковыми настройками Фортрана

-fstack-arrays (-fno-stack-arrays)
Распределять автоматические массивы неизвестного размера в стеке (в куче)

В режиме -fstack-arrays массивы неизвестного размера (Variable Length Arrays - VLA) размещаются в стеке, в режиме -fno-stack-arrays - в куче. По умолчанию для языков C/C++ включен режим -fstack-arrays, для Фортрана -fno-stack-arrays

В защищённом режиме для всех языков по умолчанию включен режим -fno-stack-arrays

-fno-strict-f77
В режиме Фортрана 77 указать, что программа не соблюдает стандарт Фортран 77

-funconstrained-commons (-fno-unconstrained-commons)
Указать компилятору, что при работе с массивами, расположенными в common-блоках, реальный размер может оказаться больше, чем указано в исходнике

-fall-intrinsics
Разрешить использование всех встроенных функций независимо от указанного стандарта

-fallow-argument-mismatch (-fno-allow-argument-mismatch)
Выдавать предупреждение, а не ошибку, если вызов внешней процедуры не соответствует определению данной процедуры

-fallow-invalid-boz
Выдавать предупреждение, а не ошибку, если boz литерал используется в нарушении правил стандарта языка Fortran

-fallow-leading-underscore
Разрешить использование подчерка в начале идентификатора

-fautomatic (-fno-automatic)
Не разрешать трактовать локальные переменные нерекурсивных процедур как SAVE

-fbackslash
Интерпретировать символ "\" как символ "escape"

-fcray-pointer
Разрешить использование Cray Pointers

-fd-lines-as-code
Игнорировать символ "D" в первой колонке

-fd-lines-as-comments
Интерпретировать символ "D" в первой колонке как знак комментария

-fdec (-fno-dec)
Разрешить синтаксис DEC, включает все опции, которые начинаются на -fdec

-fdec-blank-format-item (-fno-dec-blank-format-item)
Разрешить использовать пробел в конце строки спецификации формата

-fdec-char-conversions (-fno-dec-char-conversions)
Разрешить использование символьных литералов в целочисленных присваиваниях

-fdec-format-defaults (-fno-dec-format-defaults)
Разрешить не указывать ширину при использовании спецификаторов формата F, G, I

-fdec-intrinsic-ints (-fno-dec-intrinsic-ints)
Разрешить дополнительные встроенные функции с использованием разновидности целого

-fdec-math (-fno-dec-math)
Разрешить дополнительные встроенные математические функции

-fdec-static (-fno-dec-static)
Разрешить атрибуты AUTOMATIC и STATIC - то же самое, что атрибут SAVE

-fdec-structure (-fno-dec-structure)
Разрешить запись DEC структур и записей - то же самое, что и производный тип, но другой синтаксис

-fdefault-double-8
Установить размер типа double precision в 8 по умолчанию

-fdefault-integer-8
Установить размер типов integer и logical в 8 по умолчанию

-fdefault-real-8
Установить размер типа real в 8 по умолчанию

-fdefault-real-10
Установить размер типа real в 10 по умолчанию

-fdefault-real-16
Установить размер типа real в 16 по умолчанию

-fdiagnostics-show-caret (-fno-diagnostics-show-caret)
Показывать позиции в строке исходного текста с помощью специального знака

-fdiagnostics-show-location=<val>
Показывать номер строки текста, если диагностическое сообщение содержит несколько строк. Допустимые значения <val>: once, every-line

-fdiagnostics-show-option (-fno-diagnostics-show-option)
Печатать в диагностическом сообщении опцию, в результате действия которой это сообщение появилось

-fdollar-ok
Разрешить символ "$" в идентификаторе в качестве не первого символа

-fno-f2c
Игнорируется

-ffixed-form
Установить форму исходного файла фиксированной, независимо от расширения

-ffixed-line-length-<val>
Установить размер строки в <val> для фиксированной формы файла

-ffixed-line-length-none
Разрешить произвольный размер строки для свободной формы файла

-ffree-form
Установить форму исходного файла свободной, независимо от расширения

-ffree-line-length-<val>
Установить позицию в строке, после которой символы игнорируются

-ffree-line-length-none
Разрешить произвольный размер строки для свободной формы файла

-fimplicit-none
Отменить умолчания типа для идентификаторов в зависимости от первой буквы

-finteger-4-integer-8
Интерпретировать переменные, описанные с типом INTEGER(4) как INTEGER(8)

-fintrinsic-modules-path=<path>
Установить директорию для поиска встроенных модулей

-fmax-identifier-length=<val>
Установить максимально допустимый размер идентификатора

-fmodule-private
Установить доступ PRIVATE ко всем объектам модулей по умолчанию

-fprotect-parens (-fno-protect-parens)
Не разрешать изменять порядок вычислений в выражении (порядок определяется скобками)

-frange-check (-fno-range-check)
Выводить сообщения об ошибках в процессе константных вычислений при компиляции

-freal-4-real-8
Интерпретировать переменные, описанные с типом REAL(4) как REAL(8)

-freal-4-real-10
Интерпретировать переменные, описанные с типом REAL(4) как REAL(10)

-freal-4-real-16
Интерпретировать переменные, описанные с типом REAL(4) как REAL(16)

-freal-8-real-4
Интерпретировать переменные, описанные с типом REAL(8) как REAL(4)

-freal-8-real-10
Интерпретировать переменные, описанные с типом REAL(8) как REAL(10)

-freal-8-real-16
Интерпретировать переменные, описанные с типом REAL(8) как REAL(16)

-frealloc-lhs (-fno-realloc-lhs)
Разрешить переразмещение Allocatable левой части присваивания

7 Опции управления языковыми настройками Фортрана, влияющими на генерацию кода

-faggressive-function-elimination
Игнорировать функции с одинаковым списком аргументов внутри оператора, независимо от того, объявлены они как PURE или нет

-falign-commons (-fno-align-commons)
Разрешить (запретить) выравнивание в COMMON блоках

-fbacktrace (-fno-backtrace)
Выдавать стек при получении сигнала завершения

-ffortran-init-ieee (-fno-fortran-init-ieee)
Разрешить (запретить) чистку и восстановление флагов floating-point прерываний при работе с фортрановскими модулями вещественной арифметики

-ffortran-check-internal-func (-fno-fortran-check-internal-func)
Выдавать пользовательскую ошибку при встрече вложенной процедуры в качестве аргумента другой процедуры

-fbounds-check
Эквивалентно -fcheck=bounds

-fcheck-array-temporaries
Эквивалентно -fcheck=array-temps

-fcheck=<val>
Выдавать предупреждения во время исполнения. Значения <val> следующие: bounds (выход за границы массива, секции, строки), array-temps (создание временного массива в качестве аргумента процедуры), recursion (рекурсивный вызов нерекурсивной процедуры), do (неверные значения переменных цикла DO), pointer (использование неразмещённых переменных или неассоциированных указателей в качестве аргумента), mem (использование неразмещённой переменной в левой части присваивания)

-fcoarray=<val>
Установить способ работы с co-массивами. Значения <val> следующие: none (в программе не должно быть co-массивов), single (co-массивы в программе допускаются, но параллелизма нет), lib (указывается имя библиотеки, где реализован параллелизм)

-fconvert=<val>
Установить порядок байтов в представлении числа. Значения <val> следующие: big-endian (порядок байтов от старшего к младшему), little-endian (порядок байтов от младшего к старшему), native (значение по умолчанию), swap (обратное значению по умолчанию)

-ffpe-summary=<val>
Определить список floating-point прерываний для вывода. Допустимые значения <val>: all (все), none (никакие), либо, через запятую, любая комбинация из invalid, denormal, zero, overflow, underflow, inexact, precision

-ffpe-trap=<val>
Определить список floating-point прерываний для вывода и прервать исполнение программы при возникновения указанного прерывания исполнение программы. Допустимые значения <val> те же, что и в -ffpe-summary

-ffrontend-optimize (-fno-frontend-optimize)
Выполнять оптимизацию фронтенда во время обработки дерева разбора. Опция автоматически включается по любой опции оптимизации уровня -O1 и выше

-finit-character=<val>
Установить неявную инициализацию значением <val> для строковых переменных

-finit-derived
Установить неявную инициализацию компонент производного типа в соответствиим с другими опциями, которые начанаются на -finit

-finit-integer=<val>
Установить неявную инициализацию значением <val> для целочисленных переменных

-finit-local-zero
Установить неявную инициализацию нулём для всех локалов

-finit-logical=<val>
Установить неявную инициализацию значением <val> для логических переменных. Допустимые значения <val>: true, false

-finit-real=<val>
Установить неявную инициализацию значением <val> для вещественных переменных. Допустимые значения <val>: zero, snan, nan, inf, -inf

-finline-matmul-limit=<val>
Установить максимальный размер матрицы, при котором функцию matmul можно сделать inline

-fmax-array-constructor=<val>
Установить максимально допустимое количество элементов в конструкторе массива

-fmax-stack-var-size=<val>
Установить максимальный размер (в байтах) массива, который можно разместить на стеке

-fmax-subrecord-length=<val>
Установить максимальную длину subrecord (для ввода-вывода)

-frecord-marker=<val>
Установить размер маркера длины записи для неформатированных файлов. Допустимые значения <val>: 4, 8

-frecursive
Размещать локальные переменные на стеке, чтобы разрешить рекурсию

-fsecond-underscore (-fno-second-underscore)
Добавлять второй подчерк в имя функции, если уже есть один

-fsign-zero (-fno-sign-zero)
Добавлять знак при выводе отрицательного нулевого вещественного числа

-ftmp-stack-array-size=<val>
Распределять временные массивы на стеке, если их размер не более <val> байт, иначе в памяти

-funderscoring (-fno-underscoring)
Добавлять для внешних имён в конце подчерк

-fstrict-loop-counter
Включить строгое соблюдение стандарта при построении счётчика цикла.

По умолчанию компилятор в режиме языка Fortran строит счётчик цикла в виде знакового целого. За счёт этого к циклу без дополнительных преобразований могут применяться цикловые оптимизации с аппаратной поддержкой, такие как конвейеризация цикла с наложением итераций, аппаратная предподкачка массивов, раскрутка цикла. Однако, в таком режиме цикл может работать некорректно, если верхняя граница цикла равна максимальному значению знакового целого (2^31 - 1).

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

По умолчанию опция выключена.

8 Опции, влияющие на программные соглашения

-fshort-wchar
В режиме C/C++ использовать тип unsigned short int для настройки типа wchar_t.

ВНИМАНИЕ! По этой опции генерируется код, бинарно НЕ совместимый с кодом, построенным без этой опции

-fshort-enums
В режиме C/C++ выделять минимально необходимое количество памяти для хранения enum'ов

ВНИМАНИЕ! По этой опции генерируется код, бинарно НЕ совместимый с кодом, построенным без этой опции

9 Опции управления препроцессированием

-I <dir> (-I<dir>)
Добавить директорию <dir> к списку директорий для поиска заголовочных файлов

-J<dir>
Указать директорию для сохранения и использования информации о модуле Фортрана

-iquote <dir> (-iquote<dir>)
Добавить директорию <dir> к списку директорий для поиска заголовочных файлов, подключаемых только через #include "..."

-isystem <dir> (-isystem<dir>)
Добавить директорию <dir> к списку директорий для поиска системных заголовочных файлов

-idirafter <dir> (-idirafter<dir>)
Добавить директорию <dir> в конец списка директорий для поиска заголовочных файлов

-include <file> (--include <file>, -include<file>)
Включить файл <file> в самое начало компилируемой программы

-imacros <file> (--imacros <file>, -imacros<file>)
Опция аналогичная -include, но из файла <file> берутся только макроопределения

-D <name[=value]> (-D<name[=value]>)
Задать макроопределение для препроцессора

-U <name> (-U<name>)
Отменить макроопределение для препроцессора

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

При подаче на вход нераспознанного файла (включая случаи, когда подается нераспознанный и распознанный файл вместе) компилятор выдает следующее сообщение об ошибке: «lcc: ошибка: <имя нераспознанного файла>: файл неизвестного типа передан для компиляции».

-P
В режиме -E: не генерировать директивы #line

-C
В режиме -E: сохранять комментарии

-dM
В режиме -E: вместо препроцессирования печатать список макроопределений, полученных к концу компиляции

-dI
В режиме -E: включать в препроцессорную выдачу директивы #include

-dEE
В режиме -E: использовать расширенный вариант препроцессирования. В расширенном варианте препроцессирования первый символ каждой строки выходного текста является информационным со следующим смыслом:

N (normal): оригинальная строка исходника
X (expand): следует только за строками N в случаях, когда оригинальная строка исходного текста была изменена в процессе препроцессорных подстановок
S (skip): строка, пропускаемая за счёт условных препроцессорных директив типа #if
L (line): изменение файла и номера строки за счёт подстановки файла директивой #include
R (remark), W (warning), E (error), C (catastrofic error): индикация замечания, предупреждения, ошибки или катастрофической ошибки

-cpp (-nocpp)
Включить (выключить) предварительное препроцессирование для исходного текста на Фортране

-M
Генерировать список зависимостей для программы make и печатать их на экран, компиляцию не запускать

-MD
Генерировать список зависимостей для программы make и сохранять их в файл

-MM
Опция аналогична -M, но не формировать зависимости от системных файлов

-MMD
Опция аналогична -MD, но не формировать зависимости от системных файлов

-MT <name> (-MT<name>)
При использовании опции -M, -MM, -MD или -MMD: использовать имя цели <name>

-MQ <name> (-MQ<name>)
Аналогично -MT <name>, но при печати <name> экранировать символы, которые специальным образом трактуются программой make

-MF <file> (-MF<file>)
При использовании опции -MD или -MMD: сохранять зависимости в файле <file>

-MP
При использовании опции -M, -MM, -MD или -MMD: генерировать специальные цели на случай удаления требуемых файлов

-H
Печатать имена подключаемых заголовочных файлов

-undef
Не создавать дополнительных предопределенных макроопределений

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

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

-finput-charset=
Установить кодировку входного текста программы

-fexec-charset=
Установить кодировку исполнения для ordinary строковых и символьных литералов

-fwide-exec-charset=
Установить кодировку исполнения для wide строковых и символьных литералов

-verbose-modules
Печатать имена подключаемых модулей Фортрана

10 Опции управления режимом компиляции

-fbuiltin (-fno-builtin)
Разрешить (запретить) замену вызовов некоторых стандартных функций на соответствующие builtin'ы.

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

На текущий момент опция влияет на функции: abs, labs, llabs, imaxabs, cabs, cabsf, cabsl, cimag, cimagf, cimagl, conj, conjf, conjl, copysign, copysignf, copysignl, cos, cosf, cosl, creal, crealf, creall, fabs, fabsf, fabsl, ffs, ffsl, ffsll, isinf, isinff, isinfl, isnan, isnanf, isnanl, lrint, lrintf, lrintl, llrint, llrintf, llrintl, memcpy, memset, printf, fprintf, pow, powf, powl, rint, rintf, rintl, sin, sinf, sinl, strcmp, strncmp, strcpy, strncpy, strlen, sqrt, sqrtf, sqrtl,

Опция включена по умолчанию

-fno-builtin-<func>
Запретить замену стандартной функции <func> на соответствующий builtin

-fcommon (-fno-common)
Разрешить (запретить) распределение переменных в секцию .common

-fsyntax-only
Только проверять синтаксис, не компилировать

-fPIC (-fno-PIC)
Генерировать позиционно-независимый код

-fpic (-fno-pic)
Аналогично -fPIC (-fno-PIC)

-fPIE (-fno-PIE)
Генерировать позиционно-независимый код, подходящий только для исполняемых файлов

-fpie (-fno-pie)
Аналогично -fPIE (-fno-PIE)

-frename-statics
Добавить имя файла к именам статических переменных и функций

-pg
Генерировать код программы для получения профиля для дальнейшего его использования программой gprof

-fprofile-arcs
Создавать в процессе компиляции файлы с информацией о дугах для программы gcov

-ftest-coverage
Создавать в процессе компиляции файлы с информацией о базовых блоках для программы gcov

--coverage
Эквивалентно комбинации опций -fprofile-arcs, -ftest-coverage

11 Архитектурно-зависимые опции

-ffixed-<reg>
Запретить компилятору использовать регистр «<reg>» для распределения. Данная опция распространяется только на те случаи, когда компилятор сам выбирает регистры из списка доступных. Опция НЕ влияет на случаи, когда регистр используется в соответствии с программными соглашениями (например, опция не влияет на распределение параметров функции). Опция используется, например, в случаях, когда значения между ассемблерными вставками передаются напрямую через регистры (а не через языковые переменные). Такие ситуации могут возникнуть, например, в системном софте, когда реализация "по-человечески" оказывается слишком сложной или неэффективной.

Допустимые значения параметра «<reg>»: g0, ..., g31, r0, ..., r63, pred0, ..., pred31

Опция является полным аналогом соответствующей опции gcc

-fcall-used-<reg>
Отметить регистр «<reg>» как портящийся при вызовах.

Компилятор при построении операций вызова будет сохранять значение данного регистра, а после операции вызова восстанавливать. Опция используется, например, в системном софте, когда операция вызова происходит нестандартными методами (без переключения регистрового окна и т.п.). Допустимые значения параметра «<reg>» аналогичны опции -ffixed-<reg>

Опция является полным аналогом соответствующей опции gcc

-masm-inline (-mno-asm-inline)
Разрешить (запретить) inline-подстановку gnu ассемблерных вставок (только в режиме с оптимизациями)

-masm-check (-mno-asm-check)
Разрешить (запретить) контроль правильности написания gnu ассемблерных вставок (только в режиме с оптимизациями)

-mdmodel=<dmodel>
Использовать модель данных «<dmodel>». Данная опция допустима только для режима -mptr64. Параметр опции может принимать следующие значения: medium, large, huge

В режиме -mdmodel=medium компилятор предполагает, что ни статический (грубо говоря, языковая переменная), ни динамический (грубо говоря, результат вызова функции malloc) объект не может иметь размер, превышающий 4 Гб. Данный режим установлен по умолчанию

В режиме -mdmodel=large компилятор предполагает, что ограничения на размер в 4 Гб есть только у статических объектов. Динамические объекты могут иметь произвольные размеры

В режиме -mdmodel=huge как статические, так и динамические объекты могут иметь произвольные размеры. Режим экспериментальный

-mfunction-to-section=<section>:<function1>,<function2>,...
Функции <function1>, <function2>, ... принудительно распределить в секцию <section>

-mno-quad-memory-atomic
Запретить использование аппаратной поддержки при построении 16-байтных атомарных операций

-mno-unaligned-type-atomic
Запретить использование аппаратной поддержки при построении атомарных операций над типами, не имеющими по языку достаточное выравнивание

-mstrict-align (-mno-strict-align)
Запретить (разрешить) генерацию невыровненных обращений к памяти. Режим по умолчанию зависит от наличия в целевой архитектуре эффективной поддержки невыровненных обращений. В архитектурах до elbrus-v4 включительно режимом по умолчанию является -mstrict-align, поскольку там нет эффективной аппаратной поддержки невыровненных обращений к памяти. Начиная с elbrus-v5 режим по умолчанию -mno-strict-align.

Режим -mstrict-align включается опциями -fkernel и -fsysware.

Опция -mno-strict-align игнорируется при компиляции для архитектур без эффективной поддержки невыровненных обращений к памяти. По сути, она нужна только для отмены режима -mstrict-align, неявно включаемого другими опциями, например: -march=elbrus-v5 -fkernel -mno-strict-align.

В компиляторе есть похожая по смыслу опция -fpermit-unaligned, которая работает полностью независимым образом. Опция -fpermit-unaligned влияет на построение обращений к памяти, невыровненность которых явно следует из языка, и не влияет напрямую на работу оптимизаций. Опции -mstrict-align и -mno-strict-align влияют только на работу оптимизаций.

-fpermit-unaligned
Разрешить строить невыровненные обращения в память в случаях, где невыровненное обращение явно вытекает из языка

12 Опции отладочной информации

-g0
Отключить генерацию отладочной информации

-gline
Генерировать информацию о номерах строк для дизассемблера

Опция используется для того, чтобы при дизассемблировании кода через дизассемблер «ldis» можно было видеть привязку операций к исходному тексту программы. Дизассемблер из утилиты «objdump» этого не умеет, поэтому о нём речи не идёт. Для обеспечения такой возможности компилятор строит дополнительные метаданные, которые затем дешифрует дизассемблер при печати кода. Эти метаданные построены с использованием секций отладочной информации в формате DWARF-2. Проблемой является то, что для работы дизассемблера данные в формате DWARF-2 нужно настраивать НЕ так, как это нужно для работы отладчика «gdb». Это приводит к тому, что если программа собрана с использованием опции -gline, то с ней будет практически невозможна привычная работа из-под отладчика

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

-g
Генерировать отладочную информацию

-g1, -g2, -g3, -gdwarf-2, -gstabs, -ggdb, -ggdb1, -ggdb2, -ggdb3, -gno-as-loc-support
Эквивалентно опции -g (для совместимости с gcc)

-gline-tables-only
Генерировать отладочную информацию в объёме соответстветсвия кода и текста

--dwarf2-64bit (--no-dwarf2-64bit)
При построении отладочной информации в формате DWARF-2 использовать формат "64-bit", являющийся частью формата DWARF-3

-grecord-gcc-switches (-gno-record-gcc-switches)
При построении отладочной информации в формате DWARF-2 сохранять (не сохранять) опции командной строки

-gvect
Генерировать информацию для дизассемблера о числе малоформатных операций в векторных операциях

-fverbose-asm (-fno-verbose-asm)
Добавить дополнительные отладочные печати в ассемблерный файл

-fident (-fno-ident)
Строить в коде информацию для идентификации компилятора

-frecord-gcc-switches (-fno-record-gcc-switches)
Строить в коде информацию об исходной строке запуска компилятора

13 Опции, управляющие спекулятивным режимом исполнения

-fsemi-spec-ld (-fno-semi-spec-ld)
Разрешить (запретить) снимать предикат с операций чтения из памяти и ставить их в полуспекулятивный режим исполнения. Полуспекулятивный режим отличается от спекулятивного тем, что может вызывать прерывание в случае, когда адресуемая страница вытеснена из физической памяти. Таким образом, полуспекулятивное чтение по валидному адресу гарантированно прочитает значение из памяти (при этом в случае необходимости соответствующая страница автоматически подкачается в память из файла подкачки средствами ОС), в то время как спекулятивное чтение может вернуть диагностическое значение (если соответствующая страница отсутствует в физической памяти). При включение любого из этих видов спекулятивности, чтение вернёт диагностическое значение в случае невалидного адреса.

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

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

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

На практике режим -fno-semi-spec-ld используется в основном для сборки очень специфичных программ, в которых лишние прерывания недопустимы (ядро и загрузчик операционной системы, драйвера и т.п.).

Режим по умолчанию: -fsemi-spec-ld

-fsemi-spec-ld-glob (-fno-semi-spec-ld-glob)
Разрешить (запретить) снимать предикат с операций чтения глобальных переменных и ставить их в полуспекулятивный режим исполнения. Данная опция частично отменяет действие опции -fno-semi-spec-ld. Её использование имеет смысл только совместно с -fno-semi-spec-ld или -fkernel.

-fsemi-spec-ld-stack (-fno-semi-spec-ld-stack)
Разрешить (запретить) снимать предикат с операций чтения переменных в стеке и ставить их в полуспекулятивный режим исполнения. Данная опция частично отменяет действие опции -fno-semi-spec-ld. Её использование имеет смысл только совместно с -fno-semi-spec-ld или -fkernel.

-fsemi-spec-ld-greg (-fno-semi-spec-ld-greg)
Разрешить (запретить) снимать предикат с операций чтения по указателям из глобальных регистров и ставить их в полуспекулятивный режим исполнения. Данная опция частично отменяет действие опции -fno-semi-spec-ld. Её использование имеет смысл только совместно с -fno-semi-spec-ld или -fkernel.

-fsemi-spec-lintel (-fno-semi-spec-lintel)
Ограничить снятие предиката и постановку чтений и записей в полуспекулятивный режим для сборки двоичного транслятора. В режиме -mptr32 разрешается ставить в полуспекулятивный режим только операции ldgdb,ldgdh,ldgdw,ldgdd,ldgdqp. В режиме -mptr64 разрешается ставить в полуспекулятивный режим только операции ldb,ldh,ldw,ldd,ldqp. Запрещается ставить в спекулятивный режим сегментные операции записи.

Режим -fsemi-spec-lintel включается опцией -fsysware.

Режим по умолчанию -fno-semi-spec-lintel

-fspec-ld (-fno-spec-ld)
Разрешить (запретить) снимать предикат с операций чтения из памяти и ставить их в спекулятивный режим исполнения с созданием компенсирующего кода. Полуспекулятивный режим отличается от спекулятивного тем, что может вызывать прерывание в случае, когда адресуемая страница вытеснена из физической памяти. Таким образом, полуспекулятивное чтение по валидному адресу гарантированно прочитает значение из памяти (при этом в случае необходимости соответствующая страница автоматически подкачается в память из файла подкачки средствами ОС), в то время как спекулятивное чтение может вернуть диагностическое значение (если соответствующая страница отсутствует в физической памяти). Именно поэтому в режиме -fspec-ld для снятия предиката необходимо строить компенсирующий код, в котором неспекулятивное чтение перечитывает нужное значение из памяти; переход на этот компенсирующий код выполняется под предикатом исходного чтения.

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

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

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

Режим по умолчанию: -fspec-ld

-fspec-fp (-fno-spec-fp)
Разрешить (запретить) снимать предикат с вещественных операций и ставить их в спекулятивный режим исполнения.

Экспериментальный режим.

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

Режим по умолчанию -fspec-fp

-fspec-ctp (-fno-spec-ctp)
Разрешить (запретить) выносить из-под условия и исполнять спекулятивно операции подготовки перехода.

Режим по умолчанию -fspec-ctp

14 Дополнительные опции

-faligned (-fno-aligned)
Разрешить оптимизации, рассчитывающие исключительно на выровненные обращения в память.

Смысл опции заключается в том, что программист как бы говорит компилятору "я обязуюсь, что в исходнике программы все обращения в память являются выровненными на свой формат", в результате чего компилятор может более эффективно выполнять некоторые оптимизации. Такими оптимизациями являются: apb (аппаратная подкачка массивов) и arracc (аппаратная поддержка доступа к массивам) для архитектур до elbrus-v4 включительно, автоматическая векторизация (в небольшой степени) и crp_opt (динамический разрыв зависимостей между чтениями и записями в память).

Необходимость в данной опции вызвана аппаратными особенностями Эльбруса. В архитектурах до elbrus-v5 включительно невыровненные обращения в память работают значительно медленнее выровненных. В архитектурах до elbrus-v4 включительно аппаратная подкачка массивов не умеет работать по невыровненным адресам; в elbrus-v5 это ограничение снято для всех операций, кроме 16-байтных; начиная с elbrus-v6 ограничение снято полностью. Таким образом, для elbrus-v6 и выше опция -faligned имеет смысл только для оптимизации crp_opt.

Использование опции -faligned при компиляции программы, содержащей невыровненные обращения в память, может привести к некорректному поведению программы. Для проверки выровненности обращений в память можно использовать опцию -faligned-check

По умолчанию для языков C/C++ включен режим -fno-aligned, для Фортрана -faligned

-fexclude-ctpr2
Отключить использование регистра %ctpr2 для подготовки переходов (необходим в режиме сборки ядра ОС Linux)

-fsysware
Задать режим сборки системного программного обеспечения (драйверов, Х-серверов и т.п.). Включает опции: -fsemi-spec-lintel, -fno-spec-ld, -fno-global-regs, -mstrict-align, -fno-loop-apb, -fno-inline-part, -fno-lcv, -fno-ipo-array-padding

-fkernel
Задать режим сборки ядра ОС Linux. Подразумевается режим запрета прерываний при обработке системных регистров. Подразумевается нестандартное API в части глобальных регистров. Включает опции: -fno-semi-spec-ld, -fsemi-spec-ld-glob, -fsemi-spec-ld-stack, -fsemi-spec-ld-greg, -fforce-inline, -fprefetch, -fcache-opt, -fno-global-regs, -fno-loop-peeling, -fno-inline-part, -fno-lcv, -fno-use-memcpy, -mstrict-align.

-fforbid-fp
Запретить плавающие операции.

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

-finline (-fno-inline)
Включить подстановку функций (включается по опции -O2)

-finline-functions
Включить более агрессивную подстановку функций (включается по опции -O3)

-finline-part (-fno-inline-part)
Включить частичную подстановку функций (включается по опции -O3)

-finline-to-small-functions (-fno-inline-to-small-functions)
Включить агрессивную подстановку функций в маленькие функции с единстенным вызовом.

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

-finline-static-functions (-fno-inline-static-functions)
Включить агрессивную подстановку static функций в не-static функции

-finline-functions-called-once (-fno-inline-functions-called-once)
Включить агрессивную подстановку static функций с единственным вызовом

-finline-incomplete-profile
Учесть неполную профильную информацию при подстановке функций

-fno-error-always-inline
Не выдавать ошибку в случае невозможности inline-подстановки функции с атрибутом always_inline.

Компилятор обязан подставить функции с атрибутом always_inline во все точки вызова. При этом у компилятора есть свои технические ограничения на inline-подстановку, например, по размеру кода, профильной информации, различию режимов сборки функций при межмодульной оптимизации, некоторых языковых особенностей и т.д.. Если компилятор не может подставить функцию с атрибутом always_inline, то он по умолчанию выдаёт ошибку. По опции -fno-error-always-inline такие ошибки игнорируются и компиляция продолжается, несмотря на то, что часть функций с атрибутом always_inline не была подставлена. Т.е. опция влияет лишь на выдачу ошибки, но не влияет на inline-подстановку. В большинстве случаев игнорирование атрибута always_inline не является фатальным и приводит только к замедлению кода. Однако в редких случаях игнорирование может приводить к ошибке, если речь идёт о специфических кодах системного уровня, где наличие операции вызова функции приводит к недопустимому изменению контекста при работе аппаратуры (характерно для ядра операционной системы, драйверов и т.п.).

Стоит отметить, что подобные ошибки могут быть вызваны не только техническими ограничениями самого компилятора, но и некорректными действиями пользователя. Например, навешиванием атрибута always_inline на рекурсивную функцию или подачу опции -fforce-inline при компиляции большого исходника на языке C++.

-fsemantic-interposition (-fno-semantic-interposition)
В межпроцедурных оптимизациях учитывать возможный interposing of symbols при построении кода динамических библиотек

-ffreestanding
Задать режим компиляции вне стандартного окружения. Дополнительно включает -Wno-main, -Wno-builtin-functions-redefined, -fno-stdlib, -fno-builtin, -fno-use-memcpy, -fno-use-memset, -fno-malloc-opt

-fhosted
Задать режим компиляции в стандартном окружении

-fstdlib (-fno-stdlib)
Подразумевать, что стандартные C функции имеют обычную реализацию

-fno-use-memcpy
Не использовать вызов функции memcpy для копирования структур и __builtin_memcpy

-fno-use-memset
Не использовать вызов функции memset для __builtin_memset

-finhibit-size-directive
Не использовать директивы .size для функций в выходном ассемблерном тексте

-fvisibility=<visibility>
Задать значение __attribute__((visibility)) для переменных и функций без атрибута

-fvisibility-inlines-hidden (-fno-visibility-inlines-hidden)
Неявно задать __attribute__((visibility("hidden"))) для нешаблонных inline-методов класса, у которых нет явно описанного __attribute__((visibility))

-ftls-model=<model>
Задать минимальное ограничение по модели tls, назначаемой компилятором переменным без явно заданного __attribute__((tls_model))

-fstrict-aliasing (-fno-strict-aliasing)
Включить (выключить) анализ указателей на основе типов

-fext-strict-aliasing (-fno-ext-strict-aliasing)
Включить (выключить) расширенный анализ указателей на основе типов

-funsafe-strict-aliasing
Выключить анализ нарушений правил strict aliasing в анализе указателей на основе типов

-fipa-attrs (-fno-ipa-attrs)
Включить (выключить) межпроцедурный анализ функций

-fskip-path-in-file-macro
При раскрытии макроса __FILE__ пропустить путь до файла и оставить только имя файла

-falign-functions (-fno-align-functions)
Выранивать большие функции на величину instruction cache line

-falign-functions=<val>
Выранивать большие функции на величину <val>, которая должна быть степенью двойки

-falign-jumps (-fno-align-jumps)
Выранивать инструкции, на которые можно попасть только переходом, на величину instruction cache line

-falign-jumps=<val>
Выранивать инструкции, на которые можно попасть только переходом, на величину <val>

-fdevirtualize
Включить преобразование вызовов виртуальных функций в вызовы функций по имени

-fno-tls-opt
Запретить применение оптимизации TLS

-fno-tls-list=<proc1,proc2,...>
Запретить применение оптимизации TLS для указанных процедур. В данной опции можно указывать как манглированные, так и неманглированные имена процедур.

-fasm-entries-first
Конструкции asm entry печатать в начале ассемблерного файла, а не в конце

-fdata-sections (-fno-data-sections)
Размещать каждую глобальную переменную в отдельную секцию

-ffunction-sections (-fno-function-sections)
Размещать каждую функцию в отдельную секцию

-fno-optimize-sibling-calls
Запретить применение оптимизаций Tail Calls и Tail Recursion

-fno-tail-calls
Запретить применение оптимизации Tail Calls

-fdelete-null-pointer-checks (-fno-delete-null-pointer-checks)
Удаление проверок на 0 после обращения к полю объекта

-fno-delete-null-pointer-checks
Запретить удаление проверок на 0 после обращения к полю объекта

-fno-gnu-unique
Запретить построение символов STB_GNU_UNIQUE

-fstruct-to-reg ( -fno-struct-to-reg)
Разрешить размещение структур на регистрах (включена по умолчанию, начиная с уровня -O1).

-funsafe-struct-to-reg
Разрешить размещение структур на регистрах в защищенном режиме. В остальных режимах исполнения опция игнорируется.

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

-ffortran-extern-commons (-fno-fortran-extern-commons)
Сделать фортрановские common'ы видимыми за пределами текущего модуля. В языке C это соответствует простановке __attribute__((externally_visible)).

Данная опция отменяет понижение области видимости common переменных в режиме -fwhole. Её необходимо подавать в режиме -fwhole в случае, когда в программе есть обращения к библиотечным переменным, описанным как common.

Режим по умолчанию -fno-fortran-extern-commons

-finit-locals-zero
Инициализировать нулём автоматические локальные переменные: целые, вещественные, указатели, структуры и union'ы. Массивы по этой опции не инициализируются.

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

В режиме -mptr128 компилятор по умолчанию не инициализирует переменные. Поэтому программы, в которых есть использование неинициализированных данных (а это грубая ошибка в программе), могут успешно исполняться в режиме -mptr64 и ломаться в режиме -mptr128 из-за более строгого аппаратного контроля за неинициализированными данными. Таким образом, опция -finit-locals-zero позволяет облегчить портирование программ, написанных с ошибками, для режима -mptr128. При этом нужно понимать, что эта опция не исправляет ошибки, а лишь маскирует их.

Следует различать опции -finit-local-zero и -finit-locals-zero. Первая управляет поведением фронтенда языка Фортран, вторая управляет поведением оптимизирующего бэкенда для всех языков. По смыслу эти опции близки друг к другу.

Опция -finit-locals-zero игнорируется в режиме -fsanitize=*

15 Опции форматирования выдачи компилятора

-fmessage-length=<num>
Задать ограничение в «<num>» символов на ширину выдаваемых сообщений. Если выдаваемое сообщение не влезает в данное ограничение, то оно разбивается на несколько строк. Если значение «<num>» равно «, то ограничение на ширину отсутствует. На текущий момент все остальные значения параметра трактуются как ограничение ширины сообщений по умолчанию (80 символов).

-fdiagnostics-color
Эквивалентно -fdiagnostics-color=always

-fno-diagnostics-color
Эквивалентно -fdiagnostics-color=never

-fdiagnostics-color=<val>
Установить режим подкраски диагностических сообщений. Допустимые значения <val>: never, always, auto

16 Опции настройки выдачи ошибок

-Wfatal-errors (-Wno-fatal-errors)
Прервать работу после вывода первой ошибки

-fmax-errors=<n>
Прервать работу после вывода <n> ошибок

17 Опции предупреждений

-Wabi
Игнорируется

-Wabi=2
Игнорируется

-Waddress
Игнорируется

-Waggregate-return
Игнорируется

-Waliasing
Для языка Фортран предупреждать о возможных совмещениях имён формальных аргументов

-Walign-commons
Для языка Фортран предупреждать о выравниваниях в COMMON блоках

-Waligned-new
Игнорируется

-Waligned-new=all
Игнорируется

-Waligned-new=global
Игнорируется

-Waligned-new=none
Игнорируется

-Walignment-reduction-ignored
Предупреждать об игнорировании __attribute__((aligned)), вызывающего уменьшение выравнивания типа

-Walignof-incomplete-type
Предупреждать об использовании оператора __alignof__, применённого к незавершённому типу

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

Для языков C/C++ эквивалентно комбинации опций -Waddress, -Warray-bounds, -Wc++11-compat, -Wc++14-compat, -Wchar-subscripts, -Wcomment, -Wenum-compare, -Wimplicit-int, -Wimplicit-function-declaration, -Wformat, -Wmain (только в режиме языка C), -Wmaybe-return-local-addr, -Wmaybe-uninitialized, -Wnonnull, -Wparentheses, -Wpointer-sign, -Wreorder, -Wreturn-type, -Wreturn-local-addr, -Wsequence-point, -Wsign-compare (только в режиме языка C++), -Wsigned-one-bit-field, -Wstrict-aliasing, -Wstrict-overflow=1, -Wtrigraphs, -Wtrigraphs, -Wuninitialized, -Wunused-but-set-variable, -Wunused-function, -Wunused-label, -Wunused-local-typedefs, -Wunused-value, -Wunused-variable, -Wvolatile-register-var.

Для языка Фортран эквивалентно комбинации опций -Waliasing, -Wampersand, -Wc-binding-type, -Wconversion, -Winteger-division, -Wintrinsic-shadow, -Wintrinsics-std, -Wline-truncation, -Wmaybe-uninitialized, -Wreal-q-constant, -Wreturn-type, -Wsurprising, -Wtabs, -Wtarget-lifetime, -Wundefined-do-loop, -Wuninitialized, -Wunused, -Wzerotrip.

В данном случае слово "all" НЕ означает, что будут выдаваться все предупреждения (опция унаследована от gcc с тем же смыслом, что и в gcc). Для получения всех возможных предупреждений пользуйтесь опцией -Wall-warnings

-Wall-protected
Эквивалентно комбинации опций -Warray-bounds, -Wint32-to-pointer-cast-protected, -Wint64-to-pointer-cast-protected, -Wint128-to-pointer-cast-protected, -Wpointer-to-int32-cast-protected, -Wpointer-to-int64-cast-protected, -Wpointer-to-int128-cast-protected, -Wuninitialized-extra, -Wmaybe-uninitialized-extra

-Walloc-size-check
Предупреждать о недопустимом размере выделяемой памяти в модели данных -mdmodel=medium

-Walloc-zero
Игнорируется

-Walloca
Игнорируется

-Wampersand
Для языка Фортран предупреждать об отсутствующем символе "&" в продолжении строковой константы

-Warg-mismatch
Предупреждать о несовместимости типов формальных и фактических параметров в режиме -fwhole

-Wargument-mismatch
Для языка Фортран предупреждать о различии типа или размерности у формальных и фактических аргументов

-Warray-bounds
Предупреждать о выходе за границу массива (начиная с уровня -O2)

Пример кода, вызывающего данное предупреждение:

    void func (void)
    {
      int x[5];
    
      x[6] = 0;
    }
    

Исключением являются выходы за границу для одномерных массивов размером в 1 элемент, расположенных в самом конце объекта и находящихся внутри структуры (которая может быть вложенной), в случаях, когда доступ к такому массиву идёт через указатель на структуру. Сделано это из тех соображений, что статистически значимым является технический приём по выделению памяти под структуру, при этом размер выделяемой памяти может быть большим, чем размер структуры. Пример кода, в котором формально есть выход за границу массива, но предупреждение НЕ выдаётся:

    struct s
    {
      int n;
      int a[1];
    };
    
    void func (void)
    {
      struct s *p;
      int n = 3;
    
      p = malloc (sizeof (struct s) + (n - 1) * sizeof (int));
      p->n = n;
      p->a[0] = 10;
      p->a[1] = 20;
      p->a[2] = 30;
    }
    

-Warray-bounds=1
Игнорируется

-Warray-bounds=2
Игнорируется

-Warray-bounds-all
Аналогично -Warray-bounds, но без исключений. Включает в себя -Warray-bounds

-Warray-temporaries
Для языка Фортран предупреждать о создании временных массивов

-Wassign-where-compare-meant
Предупреждать о предположительно ошибочном использовании "=" вместо "=="

-Wattribute-alias
Игнорируется

-Wattribute-alias=1
Игнорируется

-Wattribute-alias=2
Игнорируется

-Wattributes
Предупреждать о некорректном имени атрибута или неприменимости данного атрибута. Включает в себя -Wignored-attribute-cleanup, -Wincorrect-attribute-fallthrough

-Wbad-function-cast
Игнорируется

-Wbad-initializer-type
Предупреждать об инициализаторе несоответствующего типа

-Wbad-macro-redef
Предупреждать об переопределении макроса другим содержимым

-Wbad-return-value-type
Предупреждать об возврате значения несоответствующего типа

-Wbuiltin-declaration-mismatch
Предупреждать об объявлении функций, совпадающих по имени с builtin'ом, но отличающихся прототипом

-Wbuiltin-functions-redefined
Предупреждать о наличии собственных реализаций библиотечных функций, которые должны раскрываться в режиме -fbuiltin

-Wc-binding-type
Для языка Фортран предупреждать о типе переменной, несовместимом с языком C

-Wc11-c2x-compat
Игнорируется

-Wc90-c99-compat
Игнорируется

-Wc99-c11-compat
Игнорируется

-Wc++-compat
Игнорируется

-Wc++11-compat
Игнорируется

-Wc++0x-compat
Эквивалентно -Wc++11-compat

-Wc++14-compat
Игнорируется

-Wc++20-extensions
Предупреждать о конструкциях, которые появились только в стандарте C++20, но в реальности поддерживаются и в режимах с более ранней версией стандарта C++

-Wcast-align
Игнорируется

-Wcast-align=strict
Игнорируется

-Wcast-function-type
Игнорируется

-Wcast-qual
Игнорируется

-Wchar-subscripts
Игнорируется

-Wcharacter-truncation
Для языка Фортран предупреждать об обрубании символьных выражений

-Wclobbered
Игнорируется

-Wcomment
Предупреждать о вложенных комментариях

-Wcomments
Эквивалентно -Wcomment

-Wcompare-reals
Для языка Фортран предупреждать о сравнении на равенство (неравенство) вещественных или комплексных

-Wconditionally-supported
Игнорируется

-Wconstant-evaluated-nonconstexpr
Предупреждать об использовании __builtin_is_constant_evaluated в не-constexpr контекстах (только в режиме языка C++)

-Wconstant-var-in-c-const-expr
Предупреждать об использовании const переменных в местах, где допустимы только const выражения (только в режиме языка C)

-Wconstant-pointer-condition
Предупреждать об управляющих условных выражениях, являющихся константами

-Wconstexpr-return-not-constant
Предупреждать о constexpr выражениях, которые не могут быть свёрнуты в константу

-Wconversion
Предупреждать об операциях неявного преобразования типов, которые могут изменить значение. Включает в себя -Wfloat-conversion, -Winteger-sign-change

-Wconversion-extra
Для языка Фортран предупреждать о неявных преобразованиях (не для всех преобразований)

-Wconversion-function-not-usable
Для языка Си++ предупреждать о том, что пользовательский оператор преобразования типа не будет использован

-Wconversion-null
Игнорируется

-Wcoverage-mismatch
В режиме -fprofile-use предупреждать о несоответствии между профилем и исходным текстом

-Wctor-dtor-privacy
Игнорируется

-Wdangling-else
Игнорируется

-Wdate-time
Игнорируется

-Wdeclaration-after-statement
Игнорируется

-Wdeclaration-hides-builtin
Эквивалентно -Wbuiltin-declaration-mismatch

-Wdelete-incomplete
Для языка C++ предупреждать об использовании указателя незавершённого типа в операторе delete

-Wdelete-non-virtual-dtor
Игнорируется

-Wdeprecated
Предупреждать о deprecated конструкциях

-Wdeprecated-copy
Игнорируется

-Wdeprecated-copy-dtor
Игнорируется

-Wdeprecated-declarations
Предупреждать об использовании переменной, функции или типа с __attribute__((deprecated))

-Wdesignated-init
Предупреждать о позиционной инициализации структуры, объявленной с __attribute__((designated_init))

-Wdiscarded-qualifiers
Предупреждать о неявном преобразовании типа между указателями, при котором теряются квалификаторы (только в режиме языка C, в языке Си++ такие преобразования запрещены)

-Wdiv-by-zero
Предупреждать о целочисленном делении на ноль (начиная с уровня -O1)

-Wdisabled-optimization
Игнорируется

-Wdouble-promotion
Игнорируется

-Wduplicated-branches
Игнорируется

-Wduplicate-clobber
Предупреждать о дублирующих описаниях clobber'ов ассемблерной вставки

-Wduplicated-cond
Игнорируется

-Wduplicate-specifier
Предупреждать о дублирующих спецификаторах

-Wduplicate-type-qualifier
Предупреждать о дублирующих квалификаторах типов

-Weffc++
Игнорируется

-Wempty-body
Предупреждать о пустой последней альтернативе оператора if

-Wempty-throw-specification
Предупреждать об использовании пустой throw-спецификации в режиме языка C++20 и выше

-Wendif-labels
Предупреждать о лишнем тексте после препроцессорных директив

-Wenum-compare
Предупреждать о сравнении величин различных enum-типов

-Weof-newline
Предупреждать об отсутствии перевода строки в конце файла

-Wextern-inline-functions-redefined
Предупреждать о переопределении функций extern inline в режиме GNU C

-Wextra
Включить дополнительные предупреждения, не включаемые через -Wall.

Для языков C/C++ эквивалентно комбинации опций -Wclobbered, -Wempty-body, -Wignored-qualifiers, -Wmissing-parameter-type, -Wold-style-declaration, -Wsign-compare, -Wtype-limits, -Wuninitialized, -Wmaybe-uninitialized, -Wunused-parameter.

Для языка Фортран эквивалентно комбинации опций -Wcompare-reals, -Wunused-parameter, -Wuninitialized.

-Wextra-semi
Игнорируется

-Wextra-semicolon
Предупреждать о лишних символах ';'

-Wfloat-conversion
Игнорируется

-Wfloat-equal
Игнорируется

-Wfloat-equals
Игнорируется

-Wformat
Проверять аргументы вызова некоторых стандартных функций, работающих с форматной строкой. Включает в себя -Wformat-extra-args, -Wnonnull

-Wformat=1
Эквивалентно -Wformat

-Wformat-extra-args
Предупреждать о наличии лишних параметров в вызовах функций с форматной строкой типа printf и scanf

-Wformat-nonliteral
Игнорируется

-Wformat-overflow
Игнорируется

-Wformat-overflow=1
Игнорируется

-Wformat-overflow=2
Игнорируется

-Wformat-security
Игнорируется

-Wformat-signedness
Игнорируется

-Wformat-truncation
Игнорируется

-Wformat-truncation=0
Игнорируется

-Wformat-truncation=1
Игнорируется

-Wformat-truncation=2
Игнорируется

-Wformat-y2k
Игнорируется

-Wformat-zero-length
Игнорируется

-Wformat=2
Эквивалентно комбинации опций -Wformat, -Wformat-nonliteral, -Wformat-security, -Wformat-y2k

-Wfree-nonheap-object
Игнорируется

-Wfunc-prototypes
Предупреждать о вызове функции, не имеющей прототипа в данном модуле в случае если это может привести к ошибке (начиная с уровня -O1). Работает только в режиме -fwhole

-Wfunction-elimination
Для языка Фортран предупреждать о игнорировании вызова функции

-Whsa
Игнорируется

-Wignored-attribute-cleanup
Предупреждать об игнорировании __attribute__((cleanup)) в режиме C++

-Wignored-pragmas
Предупреждать об известных директивах #pragma, которые игнорируются в текущем режиме компиляции

-Wignored-qualifiers
Предупреждать об игнорируемых квалификаторах

-Wimplicit
Эквивалентно комбинации опций -Wimplicit-int, -Wimplicit-function-declaration

-Wimplicit-fallthrough
Игнорируется

-Wimplicit-fallthrough=0
Игнорируется

-Wimplicit-fallthrough=1
Игнорируется

-Wimplicit-fallthrough=2
Игнорируется

-Wimplicit-fallthrough=3
Игнорируется

-Wimplicit-fallthrough=4
Игнорируется

-Wimplicit-fallthrough=5
Игнорируется

-Wimplicit-function-declaration
Предупреждать о неявных определениях функций (только в режиме языка C)

-Wimplicit-int
Предупреждать о неявном типе int для декларации функции без описания результата (только в режиме языка C)

Пример кода, вызывающего данное предупреждение:

    func (void)
    {
      return 1;
    }
    

-Wimplicit-interface
Для языка Фортран предупреждать о вызовах функций с неявным интерфейсом

-Wimplicit-procedure
Для языка Фортран предупреждать о вызовах процедур, у которых нет явного описания

-Wimplicit-vector-conversion
Предупреждать о неявном преобразовании типов для векторных типов с одинаковымы размерами, но разными базовыми типами

-Wincompatible-pointer-types
Предупреждать о неявном преобразовании типа из указателя в указатель несовместимого типа (только в режиме языка C, в языке Си++ такие преобразования запрещены)

-Wincompatible-types-conditional-operator
Предупреждать о несовместимых типах аргументов тернарного условного оператора

-Wincorrect-attribute-fallthrough
Для языков C/C++ предупреждать о случаях неправильного использования __attribute__((fallthrough)) внутри оператора switch

-Wincorrect-no-math-errno
Предупреждать о процедурах, для которых была применена опция -fno-math-errno, однако запись в переменную errno по факту производится в данной функции или в вызываемых ею функциях.

-Winit-self
Игнорируется

-Winline
Предупреждать о невозможности inline-подстановки функций (начиная с уровня -O2)

-Winline-noinline-conflict
Предупреждать о конфликтах между inline и noinline

-Wint-conversion
Предупреждать о неявном преобразовании типа из целого в указатель и из указателя в целое (только в режиме языка C, в языке Си++ такие преобразования запрещены)

-Wint-to-pointer-cast
Предупреждать о явном преобразовании типа из целого в указатель с отличающимся размером. В защищённом режиме опция игнорируется

-Wint-to-pointer-cast-same-size
Предупреждать о явном преобразовании типа из целого в указатель с совпадающим размером. В защищённом режиме опция игнорируется

-Wint32-to-pointer-cast-protected
В защищённом режиме предупреждать о явном преобразовании типа из целого размером 32 бита и меньше в указатель

-Wint64-to-pointer-cast-protected
В защищённом режиме предупреждать о явном преобразовании типа из целого размером 64 бита в указатель

-Wint128-to-pointer-cast-protected
В защищённом режиме предупреждать о явном преобразовании типа из целого размером 128 бит в указатель

-Winteger-division
Для языка Фортран предупреждать о делении целых констант с обрубанием результата

-Wintrinsic-shadow
Для языка Фортран предупреждать о совпадении имён пользовательской и встроенной процедур

-Wintrinsics-std
Для языка Фортран предупреждать о встроенной функции, которая не входит в указанный стандарт

-Winteger-sign-change
Предупреждать о преобразовании типа, приводящего к изменению знака целого

-Winvalid-builtin-arg
Предупреждать о некорректных параметрах некоторых builtin-функций (начиная с уровня -O1)

-Winvalid-memory-model
Предупреждать о некорректных параметрах, соответствующих модели памяти в атомарных builtin'ах

-Winvalid-pch
Игнорируется

-Winvalid-pragma-parameter
Предупреждать о некорректных параметрах известных директив #pragma

-Winvalid-offsetof
Предупреждать о некорректном использовании offsetof и __builtin_offsetof (только в режиме языка C++)

-Wjump-misses-init
Предупреждать о переходе через инициализацию

-Wline-truncation
Для языка Фортран предупреждать об обрубании строк исходного текста

-Wlogical-op
Игнорируется

-Wlong-long
Игнорируется

-Wlto-type-mismatch
Игнорируется

-Wmain
Предупреждать о неверном объявлении функции main

-Wmaybe-return-local-addr
Предупреждать о возможном возврате из функции адреса автоматической переменной (начиная с уровня -O1)

-Wmaybe-uninitialized
Предупреждать об использовании возможно неинициализированных скалярных автоматических переменных. Предупреждение выдаётся в случае, когда существует путь от входа в функцию до использования переменной, на котором нет инициализации данной переменной, но есть также другой путь, в котором инициализация есть. Данные предупреждения включаются отдельной опцией, поскольку lcc недостаточно умный для того, чтобы понять, могут ли указанные пути реализовываться при исполнении программы. Рассмотрим пример:

    int foo( int par)
    {
        int x;
        if( par > 0 )
            x = 1000 / par;
        return x;
    }
    

Если параметр «par» всегда больше нуля, то «x» будет всегда инициализирован, однако lcc не знает об этом. Для подавления предупреждения в данном случае достаточно инициализировать «x» в начале функции или добавить блок else с вызовом функции abort() или чем-то подобным.

Предупреждение не выдаётся для переменных, объявленных как volatile.

Предупреждения выдаются начиная с уровня -O1.

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

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

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

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

Предупреждения выдаются начиная с уровня -O1.

-Wmaybe-use-out-of-scope
Предупреждать о возможном использовании адреса автоматической переменной за пределами времени его жизни. Данный анализ не является точным, и выдаёт предупреждения на основании косвенных признаков - в случае записи адреса локальной переменной в переменную (или параметр) с большей областью видимости. Это может быть в четырёх случаях:

Запись адреса локальной переменной в другую локальную переменную с более широкой областью видимости. Пример кода:

    {
        int * ptr;
        ...
        if(...)
        {
            int var;
            ptr = &var;
        }
        ...
    }
    

Запись адреса локальной переменной (не параметра) в параметр. Пример кода:

    void foo(int * ptr)
    {
        if(...)
        {
           int var;
           ptr = &var;
        }
    }
    

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

    int * global_ptr;
    void foo( int par)
    {
        int var;
        global_ptr = &var;
        global_ptr = ∥
    }
    

Запись адреса локала или параметра в статическую переменную функции. Пример кода:

    void foo( int par)
    {
        static int * static_ptr;
        int var;
        static_ptr = &var;
        static_ptr = ∥
    }
    

Предупреждения выдаются начиная с уровня -O1

-Wmisleading-indentation
Игнорируется

-Wmissing-braces
Игнорируется

-Wmissing-declarations
Игнорируется

-Wmissing-include-dirs
Для языка Фортран предупреждать о несуществующей include директории

-Wmissing-field-initializers
Игнорируется

-Wmissing-format-attribute
Игнорируется

-Wmissing-initializer-in-constructor
Предупреждать об отсутсвии в конструкторе инициализатора для константных или ссылочных полей (только в режиме языка C++)

-Wmissing-initializer-on-const
Предупреждать об отсутствии инициализатора у переменной с квалификатором const (только в режиме языка C)

-Wmissing-noreturn
Игнорируется

-Wmissing-parameter-type
Предупреждать об отсутствия типа у параметра функции K&R (только в режиме языка C)

-Wmissing-profile
Игнорируется

-Wmissing-prototypes
Игнорируется

-Wmixed-enum-type
Предупреждать о смешивании enum и не-enum типов

-Wmultichar
Предупреждать о наличии multichar литералов

-Wmultistatement-macros
Игнорируется

-Wnarrowing
Предупреждать о narrowing conversions

-Wnested-externs
Игнорируется

-Wnoexcept
Игнорируется

-Wnoexcept-type
Игнорируется

-Wnonnull-compare
Игнорируется

-Wnonstd-extra-comma
Предупреждать о замыкающих запятых, не соответствующих стандарту

-Wnon-virtual-dtor
Предупреждать о невиртуальном деструкторе базового класса

-Wnonnull
Предупреждать о передаче нулевого указателя в качестве аргумента, помеченного через __attribute__((nonnull))

-Wnormalized
Игнорируется

-Wnormalized=none
Игнорируется

-Wnormalized=id
Игнорируется

-Wnormalized=nfc
Игнорируется

-Wnormalized=nfkc
Игнорируется

-Wnull-conversion
Игнорируется

-Wnull-dereference
Игнорируется

-Wodr
В режиме -fwhole предупреждать о нарушении One Definition Rule

-Wold-style-cast
Игнорируется

-Wold-style-declaration
Предупреждать о декларациях в устаревшем стиле (только в режиме языка C)

-Wold-style-definition
Предупреждать об описании процедуры в старом стиле (только в режиме языка C). Включает в себя -Wimplicit-function-declaration, -Wimplicit-int

-Womit-vla-deallocate
Предупреждать о непостроении VLA-deallocate

-Wopenmp-simd
Игнорируется

-Worphan-pragmas
Предупреждать об известных директивах #pragma, которые поставлены в неправильном месте исходника

-Woverflow
Предупреждать о целочисленном переполнении

-Woverlength-strings
Игнорируется

-Woverloaded-virtual
Предупреждать об объявлениях виртуальных методов, которые скрывают виртуальные методы базового класса

-Woverride-init
Игнорируется

-Wpacked
Игнорируется

-Wpacked-bitfield-compat
Игнорируется

-Wpadded
Игнорируется

-Wparam-id-list-needs-function-def
Предупреждать о списке параметров без описания типов в описании функции

-Wparentheses
Игнорируется

-Wpartial-overloaded-virtual
Предупреждать о ситуациях, когда переопределены не все перегрузки виртуального метода

-Wpointer-arith
Предупреждать о вычислениях над указателями на функции или на void

-Wpointer-qual
Эквивалентно -Wdiscarded-qualifiers. Опция устарела и будет удалена

-Wpointer-sign
Предупреждать о неявном преобразовании типа между указателями, отличающимися только знаковостью базовых типов (только в режиме языка C, в языке Си++ такие преобразования запрещены)

-Wpointer-to-int-cast
Предупреждать о явном преобразовании типа из указателя в целое с отличающимся размером (только в режиме языка C). В защищённом режиме опция игнорируется

-Wpointer-to-int-cast-same-size
Предупреждать о явном преобразовании типа из указателя в целое с совпадающим размером (только в режиме языка C). В защищённом режиме опция игнорируется

-Wpointer-to-int32-cast-protected
В защищённом режиме предупреждать о явном преобразовании типа из указателя в целое размером 32 бита и меньше (только в режиме языка C, в языке Си++ такие преобразования запрещены)

-Wpointer-to-int64-cast-protected
В защищённом режиме предупреждать о явном преобразовании типа из указателя в целое размером 64 бита

-Wpointer-to-int128-cast-protected
В защищённом режиме предупреждать о явном преобразовании типа из указателя в целое размером 128 бит

-Wpointer-to-pointer-cast
Эквивалентно -Wincompatible-pointer-types. Опция устарела и будет удалена

-Wpragma-unroll-check
Предупреждать (начиная с уровня -O2) о значениях pragma unroll, которые могут ухудшить производительность

-Wpragmas
Предупреждать о некорректном использовании директив #pragma

-Wpsabi
Игнорируется

-Wreal-and-imag-applied-to-real-value
Предупреждать об операторах __real и __imag, применяемых к целочисленному или вещественному значению

-Wreal-q-constant
Для языка Фортран предупреждать о вещественных константах с обозначением экспоненты буквой "q"

-Wrealloc-lhs
Для языка Фортран предупреждать о том, что левая часть массивного присваивания будет заново размещена

-Wrealloc-lhs-all
Для языка Фортран предупреждать о том, что левая часть присваивания будет заново размещена

-Wreduced-alignment
Предупреждать о настройке меньшего выравнивания переменной, чем написано в __attribute__((alignment))

-Wredundant-decls
Игнорируется

-Wreorder
Проверять порядок инициализации полей класса в конструкторе (только в режиме языка C++)

-Wrestrict
Игнорируется

-Wreturn-local-addr
Предупреждать о гарантированном возврате из функции адреса автоматической переменной (начиная с уровня -O1) и дополнительно включить опцию -Wmaybe-return-local-addr

-Wreturn-type
Предупреждать о неявных return из не-void функции (начиная с уровня -O2)

-Wsequence-point
Игнорируется

-Wshadow=global
Проверять, что локальная переменная скрывает другую переменную с таким же именем

-Wshadow=local
Игнорируется

-Wshadow=compatible-local
Игнорируется

-Wshadow
Эквивалентно -Wshadow=global

-Wshadow-local
Эквивалентно -Wshadow=local

-Wshadow-compatible-local
Эквивалентно -Wshadow=compatible-local

-Wshift-count-negative
Предупреждать, если величина сдвига отрицательная

-Wshift-count-overflow
Предупреждать, если величина сдвига превышает битовый размер типа аргумента сдвига

-Wshift-overflow
Игнорируется

-Wshift-overflow=1
Игнорируется

-Wshift-overflow=2
Игнорируется

-Wsign-compare
Предупреждать о сравнении знаковых и беззнаковых величинах

-Wsign-conversion
Игнорируется

-Wsign-promo
Игнорируется

-Wsigned-one-bit-field
Предупреждать о знаковом битовом поле размером 1 бит

-Wsized-deallocation
Игнорируется

-Wstack-protector
Игнорируется

-Wstatic-reference-in-c99-inline-function
Предупреждать о вызове static-функции или использовании static-переменной в inline-функции в режиме языка C99 и выше

-Wstdfunc-prototypes
Предупреждать о несоответствии прототипа со стандартным для функций, описанных в стандарте языка Си (начиная с уровня -O1). Работает только в режиме -fstdlib

-Wstrict-aliasing
Эквивалентно -Wstrict-aliasing=3

-Wstrict-aliasing=1
Предупреждать о потенциально возможных нарушениях правил перекрытия объектов в памяти (правила strict aliasing). Данный анализ включает в себя все результаты -Wstrict-aliasing=3 и -Wstrict-aliasing=2, но за счёт включения анализа приведений типов, потенциально ведущих к нарушениям правил перекрытия объектов в памяти может иметь большое количество ложных срабатываний. Работает только в режиме -fstrict-aliasing.

Пример кода, вызывающего данное предупреждение:

    float f;
    int *p = (int*) &f;
    

-Wstrict-aliasing=2
Предупреждать о возможных нарушениях правил перекрытия объектов в памяти (правила strict aliasing). Данный анализ включает в себя все результаты -Wstrict-aliasing=3, но за счёт увеличения количества шаблонов, по которым выдаются нарушения может иметь ложные срабатывания. Работает только в режиме -fstrict-aliasing.

Пример кода, вызывающего данное предупреждение:

    void func (int *a)
    {
      float *b = (float*) a;
      *b = 100.0;
    }
    

-Wstrict-aliasing=3
Предупреждать о гарантированных нарушениях правил перекрытия объектов в памяти (правила strict aliasing). Является наиболее точным анализом ошибок strict-aliasing. Работает только в режиме -fstrict-aliasing.

Пример кода, вызывающего данное предупреждение:

    void func (void)
    {
      int z = 0;
      int *a = &z;
      float *b = (float*) a;
      *b = 100.0;
    }
    

-Wstrict-null-sentinel
Игнорируется

-Wstrict-overflow
Игнорируется

-Wstrict-overflow=1
Игнорируется

-Wstrict-overflow=2
Игнорируется

-Wstrict-overflow=3
Игнорируется

-Wstrict-overflow=4
Игнорируется

-Wstrict-overflow=5
Игнорируется

-Wstrict-prototypes
Предупреждать об описании или определении функции без явного описания аргументов (только в режиме языка C)

-Wstringop-overflow
Игнорируется

-Wstringop-overflow=0
Игнорируется

-Wstringop-overflow=1
Игнорируется

-Wstringop-overflow=2
Игнорируется

-Wstringop-overflow=3
Игнорируется

-Wstringop-overflow=4
Игнорируется

-Wstringop-overread
Игнорируется

-Wstringop-truncation
Игнорируется

-Wsuggest-attribute=cold
Предупреждать о процедурах, в которых возможно было бы указать атрибут cold. Такое предложение возникает если все пути от начала функции до выхода из неё будут проходить через вызов процедур, обладающих признаком cold.

-Wsuggest-attribute=const
Предупреждать о процедурах, в которых возможно было бы указать атрибут const. Данный признак означает что процедура не имеет побочных эффектов. Т.е. её вызов с одинаковым аргументом в любой момент исполнения программы всегда даст один и тот же результат. Это свойство позволяет удалять несколько последовательно идущих вызовов, например:
    a = cos(0);
    a = cos(0);
    a = cos(0);
    a = cos(0);
    
Будет преобразовано к виду
    a = cos(0);
    
Данный признак опасно выставлять процедурам, возвращаемое значение которых зависит от переменных, меняющихся в соседних потоках, или каким-либо образом зависимым от побочных эффектов

-Wsuggest-attribute=format
Игнорируется

-Wsuggest-attribute=malloc
Предупреждать о процедурах, в которых возможно было бы указать атрибут malloc. Такое предложение возникает если процедура всегда возвращает указатель на выделенную в ней память или нулевой указатель.

-Wsuggest-attribute=noreturn
Предупреждать о процедурах, в которых возможно было бы указать атрибут noreturn. Такое предложение возникает если процедура никогда не возвращает управление. Т.е. если на любом пути исполнения будет стоять вызов noreturn процедур (например exit).

-Wsuggest-attribute=pure
Предупреждать о процедурах, в которых возможно было бы указать атрибут pure. Данный атрибут означает что процедура не имеет побочных эффектов. Т.е. её вызов с одинаковым аргументом в любой момент исполнения программы всегда даст один и тот же результат. Это свойство позволяет удалять несколько последовательно идущих вызовов, например:
    a = strlen(str);
    a = strlen(str);
    a = strlen(str);
    a = strlen(str);
    
Будет преобразовано к виду
    a = strlen(str);
    
Данный атрибут отличается от атрибута const тем что позволяет процедуре читать память, указатель на которую передаётся ей в качестве аргумента и возвращать значение в зависимости от его содержимого.

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

-Wsuggest-final-methods
Игнорируется

-Wsuggest-final-types
Игнорируется

-Wsuggest-override
Игнорируется

-Wsurprising
Для языка Фортран предупреждать о подозрительных конструкциях

-Wswitch
Игнорируется

-Wswitch-default
Игнорируется

-Wswitch-enum
Игнорируется

-Wsync-nand
Игнорируется

-Wsynth
Игнорируется

-Wtabs
Для языка Фортран предупреждать об использовании символа табуляции

-Wtarget-lifetime
Для языка Фортран предупреждать о возможно некорректном присваивании указателей

-Wtraditional
Предупреждать о конструкциях, которые имеют различное поведение в традиционном и ISO C

-Wtrampolines
Игнорируется

-Wtrigraphs
Игнорируется

-Wtrigraphs-ignored
Предупреждать о наличии триграфов в режимах, их не поддерживающих

-Wtype-limits
Предупреждать о бессмысленных сравнениях беззнаковой переменной с нулем

-Wtypedef-redefinition
Предупреждать о повторных typedef'ах с одним и тем же именем

-Wundef
Предупреждать об использовании ноля при препроцессировании для неопределенного идентификатора

-Wundefined-do-loop
Для языка Фортран предупреждать о о некорректном цикле "DO"

-Wunderflow
Для языка Фортран предупреждать о переполнении в константном выражении

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

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

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

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

Предупреждения выдаются начиная с уровня -O1.

-Wunknown-pragmas
Предупреждать о неизвестных директивах #pragma

-Wunreachable-code
Предупреждать о недостижимом коде

-Wunsafe-loop-optimizations
Игнорируется

-Wunsuffixed-float-constants
Игнорируется

-Wunused
Для языков C/C++ эквивалентно комбинации опций -Wunused-but-set-variable, -Wunused-function, -Wunused-label, -Wunused-local-typedefs, -Wunused-value, -Wunused-variable. Для языка Фортран эквивалентно комбинации опций -Wunused-dummy-argument, -Wunused-label, -Wunused-parameter, -Wunused-variable

-Wunused-builtin-result
Предупреждать о неиспользуемом результате вызова builtin-функции в случаях, когда это не имеет смысла (начиная с уровня -O1)

-Wunused-but-set-parameter
Для языка Фортран предупреждать о неиспользованном формальном параметре, в который есть присваивание

-Wunused-but-set-variable
Предупреждать об инициализированных, но неиспользуемых переменных.

Для выключения данного предупреждения для отдельных переменных используйте __attribute__((unused)).

Данное предупреждение включается также по опции -Wunused, которая входит в состав -Wall.

-Wunused-const-variable
Эквивалентно -Wunused-const-variable=2

-Wunused-const-variable=1
Предупреждать о неиспользуемых static const переменных. Только в главном компилируемом файле, но не в подключенных файлах через директивы #include

-Wunused-const-variable=2
Предупреждать о неиспользуемых static const переменных, включая подключенные файлы через директивы #include. Включает в себя -Wunused-const-variable=1

-Wunused-dummy-argument
Для языка Фортран предупреждать о неиспользованном формальном параметре

-Wunused-function
Предупреждать о неиспользуемых функциях, кроме static inline функций

-Wunused-function-all
Предупреждать о неиспользуемых функциях. Включает в себя -Wunused-function

-Wunused-label
Предупреждать о неиспользуемых метках

-Wunused-local-typedefs
Игнорируется

-Wunused-macros
Игнорируется

-Wunused-parameter
Для языков C/C++ предупреждать о неиспользуемом параметре. Для языка Фортран предупреждать о неиспользованной именованной константе (PARAMETER)

-Wunused-result
Предупреждать о неиспользуемом результате вызова функции с __attribute__((warn_unused_result)) или [[nodiscard]]

-Wunused-value
Предупреждать о выражениях, не имеющих эффекта

-Wunused-variable
Предупреждать о неиспользуемых переменных. В режиме языка C включает в себя -Wunused-const-variable=1

-Wunused-variable-all
Эквивалентно -Wunused-variable. Опция устарела и будет удалена

-Wuse-without-only
Для языка Фортран предупреждать об использовании оператора USE без квалификатора ONLY

-Wuseless-cast
Игнорируется

-Wvarargs
Игнорируется

-Wvariadic-macros
Игнорируется

-Wvector-operation-performance
Игнорируется

-Wvla
Игнорируется

-Wvoid-pointer-to-function-pointer-cast
Предупреждать о неявном преобразовании типа из указателя на void к указателю на функцию (только в режиме языка C, в языке Си++ такие преобразования запрещены)

-Wvolatile-register-var
Игнорируется

-Wwrite-strings
Предупреждать об использовании преобразования строкового литерала в тип char*

-Wzero-as-null-pointer-constant
Игнорируется

-Wzerotrip
Для языка Фортран предупреждать о неисполняемых циклах DO

-Wno-<warn>
Отключить предупреждения, соответствующие опции -W<warn>. Опции с неизвестным <warn> игнорируются

-Werror=<warn> (-Werror-<warn>)
Предупреждения, соответствующие опции -W<warn>, трактовать как ошибки

-Wno-error=<warn>
Предупреждения, соответствующие опции -W<warn>, не трактовать как ошибки и не превращать их в ошибки по опции -Werror

-Werror (-Wno-error)
Все предупреждения и замечания трактовать (не трактовать) как ошибки

-Wsystem-headers (-Wno-system-headers)
Для языков C/C++ выдавать (не выдавать) предупреждения и замечания в системных заголовочных файлах

-Wall-warnings
Отображать все возможные предупреждения, отменить действия всех опций -Werror=<...>

-Wno-all-warnings
Настройки предупреждений вернуть в состояние по умолчанию

-pedantic
Выдавать предупреждения о несоответствии строгому стандарту ISO C, ISO C++ или ISO Fortran. Включает в себя -Wtypedef-redefinition

-pedantic-errors
То же, что и -pedantic, только выдавать ошибку

-Wremarks (-Wno-remarks)
Включить (выключить) печать замечаний

-W
Эквивалентно -Wextra

-Wframe-larger-than=<size>
Предупреждать, если размер стека для процедуры превышает <size> байт

-Wlarger-than=
Игнорируется

-Wstack-usage=
Игнорируется

-Wpedantic
Эквивалентно -pedantic

-w
Подавлять все предупреждения и замечания компилятора, относящиеся к исходному тексту программы

-w<id>
Для языков C/C++ подавить предупреждение или замечание компилятора, относящееся к исходному тексту программы и имеющее номер <id>. Опция имеет самый низкий приоритет

18 Базовые опции оптимизаций

-O0
Компилировать без оптимизаций

-Og
Эквивалентно -O0

-O1
Минимальный уровень оптимизаций. Включает только локальные платформо-независимые оптимизации

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

-O3
Ещё более высокий уровень оптимизаций, нацеленный на получение высокой производительности. Включает в себя оптимизации уровня -О2 и агрессивные платформо-зависимые оптимизации, которые могут приводить к значительному росту размера кода. Также, включает решатель (-fgos-solver)

-O4
Максимальный уровень оптимизаций. Эквивалентно -O3 -fno-gos-solver

-Ominimal
Эквивалентно -O1

-O
Эквивалентно -O2

-Osize
Эквивалентно -O2

-Os
Эквивалентно -O2

-Ofast
Эквивалентно -O3 -ffast-math -fstack-arrays (последнее - если не подана опция -fmax-stack-var-size)

-fgos-solver (-fno-gos-solver)
Включение решателя для выбора оптимальной линейки оптимизаций в зависимости от свойств процедуры. Позволяет уменьшить время компиляции и размер кода, а в некоторых случаях и время исполнения. Для его включения обычно достаточно подать опцию -O3.

По сути, это некоторый искусственный интеллект, который умеет подбирать для каждой функции один из 4 наборов оптимизаций: 3 набора уровня -O3, и 1 набор уровня -O2. В этом состоит принципиальное различие работы опций -O* в компиляторах gcc и lcc. В gcc опция -O* - это просто набор опций, включающих отдельные оптимизации; и если, например, необходимо в режиме -O1 включить оптимизацию unroll, до для этого достаточно подать опцию -funroll-loops. Т.е. можно сказать, что в gcc существует единственная линейка оптимизаций, и подавая опции можно включать и отключать отдельные оптимизации. В компиляторе lcc есть множество линеек оптимизаций, и опциями можно отключать оптимизации в текущей линейке, но нельзя включать оптимизации, которых в линейке нет; например, в режиме -O1 подача опции -funroll-loops не включает оптимизацию unroll, поскольку её нет в соответствующей линейке.

Решатель отключается в режиме -fprofile-use. Для его принудительного включения в этом режиме необходимо подать дополнительную опцию -fgos-profile.

Для задания линейки оптимизации для конкретной функции можно использовать __attribute__((optimize("-O*"))). Если подать в этот атрибут опцию -O3, то для данной функции включается решатель. Если подать -O4, то решатель для данной функции отключается, и выбирается линейка уровня -O3.

Посмотреть выбранный решателем уровень оптимизации можно с помощью опции -fopt-report.

Режим по умолчанию: -fno-gos-solver

-fgos-profile
Разрешить использовать решатель в режиме -fprofile-use

-fcold-Osize
Использовать режим -Osize для компиляции холодных процедур

19 Опции профилирования

-fprofile-use[=<file>]
Загрузить данные профилирования из файла <file> (по умолчанию eprof.sum)

-fprofile-generate[=<path>]
Генерировать код программы для получения профиля в каталоге <path> (по умолчанию в текущем каталоге)

-fprofile-generate-parallel[=<path>]
Генерировать код программы, использующей распараллеливание для получения профиля в каталоге <path> (по умолчанию в текущем каталоге)

-fprofile-generate-kernel
Генерировать код программы для получения профиля в при сборке ядра

-fprofile-subst=<old_module_name1>:<new_module_name1>,...
Заменить имя считанного из профиля файла <old_module_name> на указанное имя <new_module_name>

-fprofile-strict-names
Выдать ошибку при отсутствии в профиле информации для файла, поданного в командной строке

-fprofile-values
Включить режим профилирования значений переменных

-fprofile-skip-proc=<proc1,proc2,...>
Данные процедуры не будут инструментироваться, профиль для них не будет загружаться. В данной опции можно указывать как манглированные, так и неманглированные имена процедур.

-fprofile-skip-module=<module1,module2,...>
Данные модули не будут инструментироваться, профиль для них не будет загружаться

-fprofile-filter-files=<regex1;regex2;...>
Инструментирвоаться будут только файлы, подходящие под указанный шаблон

-fprofile-exclude-files=<regex1;regex2;...>
Файлы, подходящие под заданные шаблоны не будут инструментирвоаться, их профили не будут загружаться

20 Опции режима "вся программа"

-fwhole
Включает режим компиляции "вся программа". При компиляции исходного кода с этой опцией компилятор генерирует EIR (одно из промежуточных представлений lcc) и записывает его в специальную секцию объектного файла. На стадии линковки компилятор объединяет эти секции и компилирует их так, словно это одна единица трансляции. Эта опция обязательно должна подаваться не только на стадии компиляции, но и на финальной линковке. Например:
    lcc -O3 -fwhole foo.c -c
    lcc -O3 -fwhole bar.c -c
    lcc -O3 -fwhole foo.o bar.o -o myprog
    
В данном примере первые два запуска lcc записывают бинарное представление EIR в специальную секцию объектных файлов foo.o и bar.o. Последний запуск lcc читает EIR из foo.o и bar.o, объединяет представление и компилирует его как один модуль. Это позволяет более эффективно проводить межпроцедурные анализы и оптимизации. Например, можно выполнять inline-подстановку функций из foo.c в bar.c и наоборот. Также, компилятор видит все места вызова функций и использования глобальных переменных, и за счёт этого может более эффективно определить независимость обращений к памяти.

Другой (более простой) способ использования опции:

    lcc -O3 -fwhole foo.c bar.c -o myprog
    
Важно помнить о том, что линковка должна запускаться через драйвер lcc. При этом оптимизационные опции должны подаваться на стадии линковки; исключение составляют следующие опции, наличие которых записывается в EIR индивидуально для каждой функции: -faligned, -fassociative-math, -frounding-math, -fforce-delin. Проще всего запомнить следующее правило: опция -fwhole и все оптимизационные опции должны подаваться как при компиляции, так и при линковке через драйвер lcc.

В режиме -fwhole можно объединять модули, написанные на разных языках:

    lcc -O3 -fwhole foo.c -c
    l++ -O3 -fwhole bar.cc -c
    lfortran -O3 -fwhole baz.f90 -c
    l++ -O3 -fwhole foo.o bar.o baz.o -lfcc -o myprog
    
Обратите внимание на то, что финальная линковка делается через l++, чтобы подключить библиотеки поддержки C++, и подаётся опция -lfcc, чтобы подключить библиотеки поддержки Fortran.

Опция -fwhole требует, чтобы на компиляцию подавалась вся программа, включая функцию main. Область видимости всех глобальных переменных и функций понижается, и они становятся недоступными извне. По этой причине режим -fwhole не подходит для сборки библиотек (как статических, так и динамических) - опцию запрещено использовать совместо с -fPIC, -fPIE и -shared. Для сборки динамических библиотек следует использовать опцию -fwhole-shared.

Опция -fwhole несовместима с некоторыми gnu-расширениями, влияющими на процесс линковки.

-fwhole-shared
Включает межмодульные оптимизации и анализы в режиме -fPIC или -shared. Опция экспериментальная и сейчас корректность её работы не гарантируется.

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

Важно помнить о том, что по умолчанию в режиме -fPIC реализация функции может быть переопределена снаружи библиотеки, из-за чего практически все межпроцедурные оптимизации и анализы невозможны. Поэтому опцию -fwhole-shared имеет смысл использовать только совместно с -fvisibility=protected. Пример использования:

    lcc -O3 -fwhole-shared -fPIC -fvisibility=protected -c foo.c
    lcc -O3 -fwhole-shared -fPIC -fvisibility=protected -c bar.c
    lcc -O3 -fwhole-shared -fPIC -fvisibility=protected -c baz.c
    lcc -O3 -fwhole-shared -fPIC -shared -o libexample.so foo.o bar.o baz.o -lc
    

Важной особенностью опции -fwhole-shared является то, что она работает только совместно с опциями -fPIC или -shared, а без них игнорируется. Это сделано для того, чтобы было удобно собирать библиотеки. Обычно библиотека собирается запуском команды «make», при этом на выходе одновременно получается как статическая, так и динамическая библиотеки, причём задать разные опции для них обычно затруднительно. Если к такому запуску добавить опцию -fwhole, то файлы *.o, из которых будет собрана статическая библиотека, в реальности будут файлами с EIR, в то время как требуются файлы с кодом. Опция -fwhole-shared подходит для таких сценариев - в статическую библиотеку попадёт оптимизированный код (без межмодульных оптимизаций), а динамическая библиотека будет собрана с межмодульными оптимизациями.

Опция -fwhole-shared несовместима с некоторыми gnu-расширениями, влияющими на процесс линковки.

21 Опции поддержки динамической оптимизации

-fdo-prepare
Включить режим подготовки к динамической оптимизации

-fdo-prog=<file>
Задать бинарный файл, содержащий секцию с сохранённым EIR

-fdo-proc=<proc>
Задать функцию для оптимизации

-fdo-prof=<file>
Задать файл с динамическим профилем

-fdo-softprof
Включить программное профилирование

22 Опции анализатора производительности

-fopt-report
Включить выдачу отчёта о применившихся оптимизациях

-fopt-report=<N>
Включить выдачу отчёта о применившихся оптимизациях и задать уровень детализации отчёта:

(0) - выключить генерацию отчёта;

(1) - вывод краткой информации о применении ключевых оптимизаций (overlap, apb, vect, unroll и т.п.);

(2) - (значение по умолчанию) краткий отчёт о применении всех оптимизаций;

(3) - подробный отчёт о применении всех оптимизаций; для некоторых оптимизаций - оценка ускорения цикла;

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

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

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

Язык выдачи отчёта можно задать с помощью переменных окружения: LC_ALL, LC_MESSAGES, LANG. Поддерживаются русский (ru_RU.KOI8-R, ru_RU.UTF-8) и английский (en_US) языки.

-fopt-report-file=<file>
Указать файл, в который будет записан отчёт о применившихся оптимизациях. По умолчанию файл отчёта создаётся в том же каталоге, что и выходной файл, и имеет то же имя с суффиксом «.optrep»

В качестве значения можно указать «stdout» или «stderr», в этом случае вывод отчёта будет направлен в соответствующий стандартный поток вывода.

-fopt-report-append
Добавлять выдачу отчёта в конец файла, не перезатирая его содержимое. Данный режим может быть полезен в случае компиляции множества файлов с опцией -fopt-report-file - в этом случае отчёт для очередного входного файла не будет затирать отчёт от предыдущего файла, и все отчёты о применении оптимизаций для всех входных файлов окажутся в одном файле.

-fopt-report-dir=<dir>
Указать каталог, в котором будет создан файл с отчётом о применившихся оптимизациях. Если указанного каталога не существует, он будет создан. По умолчанию файл отчёта создаётся в том же каталоге, что и выходной файл, и имеет то же имя с суффиксом «.optrep»

-fopt-report-phase=<phase1,phase2,...>
Указать оптимизации, для которых выводится отчёт. Полный список допустимых значений можно получить с помощью опции -fopt-report-help

-fopt-report-routine=<name1,name2,...>
Указать через запятую список функций, для которых выводится отчёт о применившихся оптимизациях. Если опция не задана, отчёт выводится для всех функций, дошедших до кодогенерации. В данной опции можно указывать манглированные имена функций - это может быть полезно для различения функций с одинаковым именем, например, перегруженных функций в языке С++ или функций из разных модулей в языке Fortran.

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

23 Опции пиковой производительности

-fblack-hole
Включить версию оптимизации Black Hole по счётчикам

-fblack-hole=<f>
Включить вероятностную версию оптимизации Black Hole и установление пороговой вероятности для нее [0.0-1.0]

-fno-loop-blocking
Отключить оптимизацию Loop Blocking - разрезание циклов с многократным обходом одинаковых участков памяти с целью оптимизации использования кэш-памяти

-fno-loop-jam
Отключить оптимизацию Loop Jam (fusion) - слияние независимых смежных циклов с одинаковым количеством итераций

-fno-swp-ext
Отключить программную конвейеризацию циклов (SoftWare Pipeline)

-fno-sr
Отключить оптимизацию Scalar Replacement - сбор межитерационных общих подвыражений

-fno-loop-ivrm
Отключить оптимизацию удаления избыточных индуктивных переменных

-fno-loop-float-ivrm
Отключить оптимизацию удаления избыточных вещественных индуктивных переменных

-fno-vect
Отключить оптимизацию векторизации вычислений

-fsafe-vect
Использовать безопасный способ векторизации невыровненных чтений

-fno-global-sched
Отключить оптимизацию Global Scheduling - глобальное планирование

-fno-loop-unroll
Отключить оптимизацию Loop Unroll - раскрутка цикла

-fno-loop-unroll-jam
Отключить оптимизацию Loop Unroll Jam - раскрутка цикла

-fno-loop-part-unroll
Отключить оптимизацию частичной раскрутки циклов.

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

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

-fno-loop-reroll
Отключить оптимизацию Loop Reroll - скрутка цикла

-floop-reverse (-fno-loop-reverse)
Включить оптимизацию Loop Reverse - разворот цикла

-fno-loop-nesting
Отключить оптимизацию Loop Nesting - вынос маловероятных участков из цикла с созданием объемлющего цикла

-fno-loop-peeling
Отключить оптимизацию Loop Peeling - вынос вверх нескольких первых итераций малоитерационного цикла

-fno-loop-full-peeling
Отключить оптимизацию Loop 2 Scalar - преобразования цикла в скалярный код

-fno-loop-unswitching
Отключить оптимизацию Loop Unswitching - расщепление цикла по инвариантному условию

-fno-loop-clustering
Отключить оптимизацию Loop Clustering - перенос вычислений, находящихся в цикле под неинвариантным условием, в дополнительный цикл

-fno-loop-permute
Отключить оптимизацию Loop Permute - перестановка циклов в гнезде по уровню вложенности

-fno-loop-invup
Отключить оптимизацию Loop Invariant Code-Motion - вынос инвариантных вычислений из цикла

-fno-loop-utos
Отключить преобразование беззнаковых счетчиков циклов в знаковые

-fno-loop-asr
Отключить оптимизацию Advanced Scalar Replacement - вынос переменных из циклов

-fno-loop-fill-objs
Отключить оптимизацию Loop Reroll - перевод на регистры объектов цикла, распределенных в память

-fno-gcp
Отключить оптимизацию Global Copy Propagation - уменьшения глобально живущих объектов

-fno-rtmd
Отключить оптимизацию Loop Run-Time Memory Disambiguation - динамический разрыв зависимостей по памяти в цикле

-fno-srtmd
Отключить оптимизацию Scalar RTMD - динамических разрыв блоков зависимостей по памяти на линейном участке

-fno-switch-opt
Отключить оптимизацию switch'ей

-fvir (-fno-vir)
Включить оптимизацию выноса векторного инварианта.

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

-fno-comb-oper
Отключить генерацию комбинированных операций

-fno-memopt
Отключить оптимизацию расположения массивов в памяти

-fno-merge-oper
Отключить генерацию операций merge на поздних фазах компиляции.

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

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

-fgsr (-fno-gsr)
Включить оптимизацию Global Scalar Replacement

-fdce-fp (-fno-dce-fp)
Включить оптимизацию Dead Code Elimination для вещественных операций

-fint-divide-opt (-fno-int-divide-opt)
Включить оптимизации для целочисленных операций деления и остатка от деления:

* Разрешить удаление целочисленного деления на ноль без использований результата.

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

* Разрешить понижение силы операций (Strength Reduction) для целочисленного деления.

* Разрешить использовать инструкцию SMODX для реализации остатка от деления. В Elbrus V1-V2 инструкция SMODX не выдаёт прерывания в случае нулевого делителя, поэтому по умолчанию остаток от деления вычисляется с помощью инструкции SDIV. В Elbrus V3 и далее такой проблемы нет, поэтому компилятор может использовать инструкцию SMODX без каких-либо опций. Однако, инструкция SMODX не конвейеризована, поэтому во многих случаях компилятор всё равно будет использовать SDIV для более быстрого вычисления остатка от деления.

-fforce-loop-apb
Применять механизм аппаратной подкачки массивов, игнорируя проверки эффективности

-fforce-loop-apb=
Применять механизм аппаратной подкачки массивов, игнорируя проверки эффективности, для циклов с количеством итераций больше заданного

-fno-loop-apb
Отключить механизм аппаратной подкачки массивов

-fno-loop-apb=
Отключить механизм аппаратной подкачки массивов для циклов с количеством итераций меньше заданного

-fno-dbl-mode
Не использовать dbl флаг операции setwd

-floop-apb-conditional-loads (-fno-loop-apb-conditional-loads)
Включить механизм аппаратной подкачки для чтений под условием. Данная оптимизация может приводить к некорректному поведению программы в некоторых редких случаях, например, когда чтение под условием обращается по некорректому адресу.

В защищённом режиме данная опция игнорируется.

-floop-nesting4swp
Безусловно включить nesting циклов, для которых возможна конвейеризация

-fcfetch=<dist>,<gap>[,<priority>]
Задать эвристики для предварительной подкачки кода - <расстояние до подкачиваемого кода (в тактах)>,<минимальное расстояние между операциями подкачки(в тактах)>[,<приоритет планирования инструкции подготовки перехода>]

-fno-cfetch
Отключить генерацию предварительной подкачки кода

-fno-dam
Отключить DAM - аппаратный механизм разрешения конфликтов по чтению-записи

-fno-dam4swp
Отключить DAM для конвейеризованных циклов

-fno-dam-call
Отключить DAM для зависимостей чтение-вызов

-fdam-eq-arrays
Разрешить DAM рвать зависимости между операциями, обращающимися к одному массиву (т.е. по одному указателю или с одним объектом)

-fdam-no-rbranch
Включить использование DAM без построения компенсирующего кода

-fno-swp
Отключить конвейеризацию циклов с аппаратной поддержкой

-fswp-prefetch
Включить механизм программной предподкачки данных для конвейеризованных циклов. Работает для тех чтений, к которым не применилась аппаратная предподкачка.

-fswp-regs-priority
Включить режим экономии регистров при конвейеризации циклов за счет возможного снижения эффективности кэша 2 уровня

-fguess-prefetch=<n>
Задать эвристику для нерегулярной предварительной подкачки данных [1..10]

-fswp-maxopers=<n>
Задать эвристику для конвейеризации циклов - максимальное количество операций в конвейеризуемом цикле

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

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

В качестве альтернативы можно использовать более консервативную опцию -fcache-opt-l2, либо вставлять в цикл операции предподкачки данных с помощью __builtin_prefetch.

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

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

В данном режиме также включается опция -fswp-cache-opt=4

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

-fcache-opt-grow=<f>
Задать максимально допустимое увеличение времени исполнения цикла при применениии кэш-оптимизации [1.0-2.0]

-fcache-opt-step=<n>
Задать шаг уменьшения задержки от операций чтения в режиме -fcache-opt [0..100]

-fibranch-bound=<f>
Задать порог неподготавливаемых переходов [0.0-1.0]

-fnesting-prob=<f>
Задать пороговое отношение счетчиков между выкидываемым узлом и головой цикла [0.0-1.0]

-fswp-cond-cc (-fno-swp-cond-cc)
Включить конвейеризацию циклов с двумя обратными дугами

-fforce-swp
Включить генерацию принудительной конвейеризации циклов

-fno-ibranch
Отключить генерацию неподготовленных переходов

-flist-prefetch
Включить предварительную подкачку списков

-fno-global-regs
Отключить использование глобальных регистров. Данная опция включается в режимах -fkernel и -fsysware.

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

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

Режим по-умолчанию -fprefetch для архитектуры Эльбрус, -fno-prefetch для архитектуры SPARC

-fno-prefetch
Отключить технику программной предварительной подкачки данных

-fset-ld-delay=<n>
Задать задержку для операций чтения из памяти

-fset-mau-delay=<n>
Задать время в тактах микропроцессора, необходимое на подкачку данных из оперативной памяти в кэш L2

-fblock-size-limit=<n>
Установить ограничение на максимальный размер линейного участка (по умолчанию 290 операций) [8-65535]

-fipo-globals2regs[=n]
Разрешить использование глобальных регистров для хранения глобальных переменных. Параметр игнорируется для совместимости со старыми версиями компилятора.

Компилятор находит все глобальные скалярные переменные, на которые не брался адрес, и распределяет наиболее часто используемые из них на глобальные регистры. Может быть использована только совместно с опциями -fwhole и -ffast. В случае ручного использования глобальных регистров (например, в asm-вставках либо при распределении переменной на регистр с помощью register asm) необходимо все использованные вручную регистры дополнительно перечислить в опциях -ffixed-g*.

-finline-level=<f>
Задать эвристику для подстановки функций - коэффициент увеличения интенсивности подстановки [0.1-20.0]

-finline-scale=<f>
Задать эвристику для подстановки функций - коэффициент увеличения основных ресурсных ограничений [0.1-5.0]

-finline-part-size=<n>
Задать эвристику для подстановки функций - максимальный размер вероятного региона процедуры для частичной подстановки

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

В режиме по умолчанию компилятор сам принимает решение о том, inline-подстановки каких конкретно функций выполнять. Спецификатор inline на этот выбор не влияет. Принудительная inline-подстановка выполняется только для функций, помеченных __attribute__((always_inline)). При наличии данной опции принудительная inline-подстановка выполняется в том числе и для функций, имеющих спецификатор inline.

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

-finline-only-native
Выполнять подстановку только для функций с явным модификатором inline

-fsr-ext
Включить расширенную версию оптимизации Scalar Replacement - сбор межитерационных общих подвыражений

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

-fOsize-selective=<f>
Понизить уровень оптимизации для процедур, некритичных по профилю задачи, с заданием порога срабатывания

-fstruct-unite (-fno-struct-unite)
Включить объединение структур одного типа

-fstruct-decomp (-fno-struct-decomp)
Включить декомпозицию локальных структур на отдельные поля

-fstruct-reorg (-fno-struct-reorg)
Включить оптимизации расположения данных в памяти для структур. Оптимизация работает только в режиме -fwhole. Также, желательно использовать профильную информацию (опция -fprofile-use).

Опция экспериментальная, корректность её работы не гарантируется.

-farray-reorg (-fno-array-reorg)
Включить оптимизации расположения данных в памяти для массивов

-fdata-reorg (-fno-data-reorg)
Включить оптимизации расположения данных в памяти (эквивалентно -fstruct-reorg -farray-reorg)

-fipo-call-under-cond
Включить оптимизацию Call Under Condition для внесения вызовов pure функций под условие. Если результат вызова некоторой pure функции используется только под условием, то данная оптимизация переносит вызов функции под это условие, чтобы уменьшить количество вызовов функции. Под pure здесь подразумеваются либо функции, явно помеченные __attribute__((pure)), либо функции, для которых компилятор определил отсутствие побочных эффектов и как бы навесил __attribute__((pure)).

Включает опцию -fipa-attrs, по которой включается анализ функций на наличие побочных эффектов.

-fipo-cprop-globals
Включить межпроцедурное распространение констант (Constant Propagation) для адресов глобальных объектов

-fipo-cprop-cond
Включить межпроцедурное распространение констант (Constant Propagation) для глобальных переменных, которые изменяются под невыполнимым условием

-fipo-cprop (-fno-ipo-cprop)
Включить межпроцедурное распространение констант (Constant Propagation)

-fipo-code-split
Разделять код на секции по профилю

-fmain-l2g
Включить преобразование локальных объектов процедуры main в глобальные

-fipa-align (-fno-ipa-align)
Включить межпроцедурный анализ выровненности указателей

-fipa-ptrs (-fno-ipa-ptrs)
Включить межпроцедурный анализ зависимостей указателей

-fipa-pta (-fno-ipa-pta)
Эквивалентно -fipa-ptrs (-fno-ipa-ptrs)

-fipa0
Выключить межпроцедурные анализы указателей и распространение констант. Включает опции -fno-ipa-align, -fno-ipa-ptrs, -fno-ipa-attrs, -fno-canon-calls, -fno-ipo-cprop.

Данная опция включена по умолчанию начиная с уровня -O1.

-fipa1
Включить межпроцедурный анализ указателей и замену передачи параметров функции по указателю на передачу по значению. Включает опции -fipa-align, -fipa-ptrs, -fcanon-calls, -fno-ipo-cprop.

Данная опция включена по умолчанию начиная с уровня -O2.

-fipa2
Включить межпроцедурный анализ указателей, замену передачи параметров функции по указателю на передачу по значению, межпроцедурное распространение констант. Включает опции -fipa-align, -fipa-ptrs, -fcanon-calls, -fipo-cprop.

Данная опция включена по умолчанию начиная с уровня -O3.

-fmem-functions-subst
Включить оптимизацию вызовов функций memset, memcpy, memmove

-fmalloc-opt (-fno-malloc-opt)
Разрешить удалять, перемещать и заменять на выделение стека вызовы функций malloc, free и им подобных

-ffast-mem
Разрешить преобразования стандартных функций выделения/освобождения памяти. При этом подразумевается, что они имеют обычную реализацию, т.е. не переопределены пользователем. Кроме того, подразумевается, что программе не требуется обработка исключительной ситуации, вызванной нехваткой памяти. При подаче этой опции компилятор:

- считает, что функция malloc никогда не возвращает NULL

- считает, что оператор new/new[] не бросает исключение в случае нехватки памяти

- считает, что free/delete/delete[] корректно обрабатывает NULL (стандартное поведение - ничего не делать в случае нулевого указателя)

- удаляет проверку на NULL указателя, полученного в результате вызова new/new[]/malloc

- заменяет вызовы new/new[] на malloc (не влияет на вызов конструктора)

- заменяет вызовы delete/delete[] на free (не влияет на вызов деструктора)

- может выдавать ошибку, если обнаружена пользовательская реализация функций new/new[]/delete/delete[]/malloc/free

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

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

-fswitch-opt-ext
Включить расширенную версию оптимизации оператора switch

-fstrict-overflow
Разрешить оптимизации на основе предположения о невыходе за границы диапазона целого знакового типа при выполнении операций над знаковыми целыми

-fno-strict-overflow
Запретить оптимизации на основе предположения о невыходе за границы диапазона целого знакового типа при выполнении операций над знаковыми целыми

-floop-fusion-late
Отложенное применение оптимизации loop fusion

-floop-split-by-cond
Включить оптимизацию разбиения цикла по условию.

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

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

-fforce-delin
Принудительно делинеаризовать массивы C по подобию Фортран 77

-fforce-rtmd
Снять ограничение по коду для оптимизации Run-Time Memory Disambiguation

-fforce-split-by-index
Отключить проверки эффективности применения оптимизации расщепления цикла по индексу

-fforce-loop-unswitching
Отключить проверки эффективности применения оптимизации вынесения инвариантного условия из цикла с созданием версий цикла

-frtmd-aggr
Снять ограничение на максимальное количество обрабатываемых пар для оптимизации Run-Time Memory Disambiguation

-fforce-unroll=<n>
Включить принудительную раскрутку всех циклов [1-8]

-funroll-scale=<f>
Коэффициент увеличения основных ресурсных ограничений Loop Unroll [0.1-8.0]

-fforce-vect
Включить принудительную векторизацию циклов

-fforce-alignopt
Включить принудительное выравнивание операций обращения к памяти в циклах

-fno-ipo-const
Отключить межпроцедурную пропагацию констант и клонирование

-fno-ipo-cloning
Отключить клонирование процедур

-fptr-func-spec=<n>
Задать количество вариантов вызова функций по имени при замене с вызова по указателю [1-10]

-fmax-iter-for-ovlpeel=<n>
Максимальное количество итераций цикла, при котором возможна открутка пролога в ковейеризованном цикле

-frestrict-disable=<proc1,proc2,...>
Игнорировать модификаторы restrict для заданных процедур. В данной опции можно указывать как манглированные, так и неманглированные имена процедур.

-frestrict-params
Параметры функций типа указатель трактовать как с модификатором restrict

-frestrict-locals
Локальные переменные типа указатель трактовать как с модификатором restrict

-frestrict-all
Эквивалентно -frestrict-params -frestrict-locals

-frestrict-safe
Включить более консервативный анализ зависимостей для restrict-указателей.

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

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

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

Данная опция работает независимо от -frestrict-unsafe

-frestrict-unsafe
Включить более агрессивный анализ зависимостей для restrict-указателей.

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

    *p = a[i];
    
и только если одно из обращений к памяти выполняется по restrict-указателю, а другое - по произвольному имени либо по любому другому указателю. Данная опция позволяет разрешить зависимости между простым обращением к памяти по restrict-указателю и всеми остальными (сколь угодно сложными) обращениями к памяти. Это может привести к некорректному поведению программы в случае нетривиальных обращений к памяти по restrict-указателю.

По умолчанию restrict позволяет разрешить зависимости только между инструкциями, пришедшими из одной функции исходной программы. Если в коде есть инструкции, подставленные inline'ом из разных функций, то зависимости между ними не разрешаются за счёт подсказок restrict. Опция -frestrict-unsafe снимает данное ограничение. Это может привести к некорректному поведению программы в случае передачи restrict-указателя в вызов функции, который подставляется inline'ом.

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

Данная опция работает независимо от -frestrict-safe

-fno-strength-reduce
Запретить оптимизацию понижения силы операций

-fvect-verbose
Включить печать параллелизма операций

-fovl-verbose
Включить печать о результатах планирования конвейеризованных циклов

-fzero-strides(-fno-zero-strides)
Учитывать при анализе цикловых зависимостей, что шаг адреса операции обращения в память может быть нулевым. Опция включена по умолчанию.

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

-floop-st-dcache-mode=<s>
Установить режим отключения кэширования записей в циклах.

Параметр опции может принимать следующие значения:
«nocache_wc» - в соответствии с эвристиками запрещается заведение строки в кэш-памяти всех уровней и включается режим write combining;
«nocache_wc_force» - безусловно в тех циклах, где это возможно, запрещается заведение строки в кэш-памяти всех уровней и включается режим write combining.

-fno-ipo-array-padding
Отключить оптимизацию Array Padding - относительное расположение статических массивов для оптимизации работы кэш-памяти

-fautopar
Включить автоматическое распараллеливание.

Данная опция игнорируется при одновременной подаче с ней опции -fopenmp.

-fthreads=<n>
Количество потоков, на которое параллелить программу

-fpar-numa=
Применить автоматическое распределение памяти по узлам NUMA-машины совместно с автоматическим распараллеливанием

-fpar-distr-mem=
Применить автоматическое распределение памяти по узлам для комплекса с распределённой памятью совместно с автоматическим распараллеливанием

-fral-esb-factor=<f>
Задать пороговое значение вероятности исполнения линейного участка для проведения дополнительных оптимизаций распределения регистров [0.0-1.0]

-fsetjmp-opt
Оптимизировать процедуры с вызовами setjmp

-flcv (-fno-lcv)
Включить (отключить) Loop Counter Versioning

-fcanon-calls (-fno-canon-calls)
Разрешить замену передачи параметров в функции по указателю на передачу по значению, если по адресу, на который указывает данный параметр, ничего не пишется и он передается дальше только в процедуры, которые тоже ничего не пишут по этому адресу.

Оптимизация работает только в режиме -fwhole. Данная опция включена по умолчанию начиная с уровня -O2.

-fignore-getenv-call
Игнорировать вызовы getenv(name), всегда возвращая нулевой указатель на информацию об окружении, ассоциированную со строкой name

24 Опции, которые могут приводить к неточным преобразованиям

-ffast
Включает опции -fstdlib, -faligned, -fno-math-errno, -fno-signed-zeros, -ffinite-math-only, -fno-rounding-math, -fcx-limited-range, -fprefetch, -fmalloc-opt, -floop-apb-conditional-loads, -fstrict-aliasing, -fext-strict-aliasing, -fipa-attrs, -fgsr, -fdce-fp, -fint-divide-opt.

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

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

Опция -fstdlib требует, чтобы в программе не были переопределены стандартные библиотечные функции. Опция -fmalloc-opt накладывает аналогичные ограничения на стандартные функции выделения памяти, такие как malloc и free.

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

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

Опция -fno-signed-zeros требует, программа работала корректно при замене знака нуля в некоторых вещественных вычислениях.

Опция -ffinite-math-only требует, чтобы в процессе вычислений не возникали бесконечные (Inf) и неопределённые (NaN) значения. Аналогичные требования накладывает опция -fcx-limited-range на операции комплексного умножения и деления.

Опция -fno-rounding-math требует, чтобы в программе не менялся режим округления по умолчанию.

Опция -floop-apb-conditional-loads требует, чтобы в циклах не было регулярных чтений под условием по некорректному адресу. Фактически, требуется, чтобы при выносе всех чтений из-под их условий программа работала корректно.

Опции -fstrict-aliasing и -fext-strict-aliasing требуют, чтобы в программе соблюдались правила строгой типизации, прописанные в современных стандартах языков C, C++. Например, стандарт запрещает писать в память значение типа double, а затем читать его как long long int.

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

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

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

-fassociative-math (-fno-associative-math)
Разрешить менять местами аргументы в цепочках вещественных операций. Это нарушает стандарт ISO языков C/C++ и может привести к изменению результата вычислений. Это также может привести к изменению знака нуля, игнорированию NaN-ов, потере или возникновению переполнения или антипереполнения (underflow). Может менять порядок аргументов сравнений, поэтому не должна использоваться в случае, когда такой порядок важен.

Для успешной работы требует взведения следующих опций: -fno-signed-zeros, -ffinite-math-only, -fno-rounding-math. Эти опции взводятся в режимах -ffast и -ffast-math.

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

-fmath-errno (-fno-math-errno)
При замене вызова математической функции на встроенную реализацию учитывать (не учитывать) её спецификацию по работе с errno

-funsafe-math-optimizations (-fno-unsafe-math-optimizations)
Включает опции -fassociative-math, -fno-signed-zeros.

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

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

-ffast-math (-fno-fast-math)
Разрешить преобразования с вещественной арифметикой, приводящие к возможному изменению точности. Включает опции -funsafe-math-optimizations, -ffinite-math-only, -fno-signaling-nans, -fno-rounding-math, -fno-math-errno, -fcx-limited-range, -ffp-contract=fast.

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

-ffinite-math-only (-fno-finite-math-only)
Разрешить (запретить) оптимизации, предполагающие, что не будет работы с NaN'ами и Inf'ами

-fsignaling-nans (-fno-signaling-nans)
Запретить (разрешить) оптимизации, предполагающие, что вещественные особые ситуации типа деления на 0 можно игнорировать

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

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

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

-fsigned-zeros (-fno-signed-zeros)
При оптимизациях учитывать (не учитывать) различия между +0.0 и -0.0

-fno-safe-call-params
Запретить оптимизации, предполагающие, что параметром функции не может быть неинициализированная переменная

-fcx-limited-range (-fno-cx-limited-range)
Разрешить (запретить) упрощённое построение операций комплексного умножения и деления

-fcx-fortran-rules (-fno-cx-fortran-rules)
Разрешить (запретить) упрощённое построение операций комплексного умножения и деления по правилам языка Фортран

-fexcess-precision=fast
Эквивалентно -fassociative-math -fno-rounding-math

-fexcess-precision=standard
Эквивалентно -fno-associative-math -frounding-math

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

25 Опции работы с sanitizer'ами

-fsanitize=<san1,san2,...> (-fno-sanitize=<san1,san2,...>)
Включить (выключить) sanitizer'ы <san1>, <san2>, ...

26 Дополнительные опции AddressSanitizer

-fno-asan-globals (-fasan-globals)
Выключить инструментирование глобалов

-fno-asan-reads (-fasan-reads)
Выключить инструментирование чтений из памяти

-fno-asan-writes (-fasan-writes)
Выключить инструментирование записей в память

-fno-asan-stack (-fasan-stack)
Выключить инструментирование стека

-fno-asan-dynamic-stack (-fasan-dynamic-stack)
Выключить инструментирование VLA и alloca

-fno-sanitize-address-use-after-scope (-fsanitize-address-use-after-scope)
Выключить механизм детектирования обращения к автоматическим переменным после выхода из области видимости

-fno-sanitize-address-use-after-return (-fsanitize-address-use-after-return)
Выключить механизм детектирования обращения к данным в стеке процедуры после выхода из неё

27 Дополнительные опции MemorySanitizer

-fsanitize-memory-track-origins
Включить функциональность, позволяющую следить за аллокацией адресов памяти, которая содержит неинициализированные данные (по умолчанию функциональность выключена)

-fsanitize-memory-track-origins=
Включить функциональность, позволяющую следить за аллокацией адресов памяти, которая содержит неинициализированные данные. Значение после '=' задает уровень детализации отчета о неинициализированной памяти (по умолчанию функциональность выключена)

-fno-sanitize-memory-track-origins
Выключить функциональность, позволяющую следить за аллокацией адресов памяти, которая содержит неинициализированные данные

28 Расширенные опции управления процессом компиляции

-B<prefix> (-B <prefix>)
Добавить префикс поиска исполняемых компонент, заголовочных файлов, библиотек и crt-модулей

-Wa,<opt1>,<opt2>...
Передать опции <opt1> <opt2> ... напрямую ассемблеру

-Wc,<opt1>,<opt2>...
Передать опции <opt1> <opt2> ... напрямую компилятору

-Wl,<opt1>,<opt2>...
Передать опции <opt1> <opt2> ... напрямую линкеру и трактовать их как файлы

-Wl2,<opt1>,<opt2>...
Передать опции <opt1> <opt2> ... напрямую линкеру в конец строки (актуально для стадии линковки режима -fwhole)

-Wp,<opt1>,<opt2>...
Передать опции <opt1> <opt2> ... напрямую препроцессору

-Xlinker <opt1>,<opt2>...
Эквивалентно опции -Wl,<opt1>,<opt2>...

-x<lang> (-x <lang>)
Прямо специфицирует язык «<lang>» последующих входных файлов (даже если компилятор может выбрать язык на основании суффикса имени файла). Эта опция действует на все входные файлы вплоть до следующего появления опции -x. Возможными значениями для языка являются: c, c-header, cpp-output, c++, c++-header, c++-cpp-output, f77, f77-cpp-input, f95, f95-cpp-input, assembler, assembler-with-cpp

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

@<file>
Прочитать опции из файла <file>

29 Опции управления линковкой

-static (-dynamic)
Опция, обратная к -dynamic.

-L<dir> (-L <dir>)
Добавить <dir> к списку директорий для поиска библиотек

-l<name> (-l <name>)
Линковать с библиотекой <name>

-nodefaultlibs
Не линковать с библиотеками по умолчанию

-nostartfiles
Не линковать со стартовыми модулями по умолчанию

-nostdlib
Эквивалентно комбинации опций -nodefaultlibs и -nostartfiles

-pie (-no-pie)
Линковать до позиционно-независимого исполняемого файла

-static-pie
Линковать до статически слинкованного позиционно-независимого исполняемого файла

-r
Создать relocatable object

-rdynamic
Вывести все символы в динамическую таблицу символов

-shared
Создать динамическую библиотеку

-shared-libgcc
Принудительно использовать динамическую версию libgcc

-static-libgcc
Принудительно использовать статическую версию libgcc

-static-libstdc++
Принудительно использовать статическую версию libstdc++

-static-libgfortran
Принудительно использовать статическую версию libgfortran

-shared-libasan
Использовать динамическую версию libasan

-static-libasan
Использовать статическую версию libasan

-symbolic
Передать в линкер опцию -Bsymbolic

30 Опции передаются линкеру

-e<entry> (-e <entry>)
 

-h<soname> (-h <soname>)
 

-R<path> (-R <path>)
 

-s
 

-T<script> (-T <script>)
 

-u<symname> (-u <symname>)
 

-z<keyword> (-z <keyword>)
 

31 Опции печати и настройки конфигурации

--version
Вывести внутреннюю версию компилятора. Опция сделана по аналогии с gcc. В gcc опция -dumpversion предназначена для того, чтобы её распознавать в автоматическом режиме всякими системами автоконфигурации. А опция --version для того, чтобы читать глазами. Такое же и отличие от опции -print-version, которая предназначена для автоматического разбора (но уже теми программами, которые изначально писались под lcc, а не под gcc).

-dumpmachine
Печатать название целевой машины

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

-print-multiarch
Печатать название целевой режима

-print-file-name=<lib>
Печатать путь до указанного неисполняемого файла

-print-prog-name=<prog>
Печатать путь до указанного исполняемого файла

-print-search-dirs
Печатать пути поиска

-print-libgcc-file-name
Печатать путь до libgcc.a

-print-version
Печатать версию компилятора

-set-target-build <target-build>
Эмулировать конфигурацию <target-build> в части работы с внутренним каталогом

-print-home-dir
Печатать домашний каталог компилятора

-set-home-dir <dir>
Установить домашний каталог компилятора

-print-binutils-dir
Печатать путь до корня файловой системы, в которой ведётся поиск binutils

-set-binutils-dir <dir>
Установить путь до корня файловой системы, в которой ведётся поиск binutils

--sysroot <dir> (--sysroot=<dir>)
Установить путь до корня файловой системы, в которой ведётся поиск системных библиотек в момент компиляции и дополнительно передать опцию --sysroot=<dir> линкеру. Файловая система должна быть эквивалентна той, что установлена на машине в момент исполнения кода

-print-sysroot
Печатать путь до корня файловой системы, в которой ведётся поиск системных библиотек в момент компиляции

-isysroot <dir> (-isysroot=<dir>)
Эквивалентно --sysroot <dir>, но только в объёме поиска include-файлов

-print-config
Эквивалентно -print-config=all

-print-config=<name>
Напечатать значение текущего конфигурационного параметра «<name>». Параметр опции может принимать следующие значения: all, target-arch, target-os, target-build, cross-compiler, version, gcc-version, build-date, home-dir, binutils-dir, fs-dir, rfs-dir. Опция используется при сборке библиотек run-time поддержки и при сборке дистрибутива. Конечному пользователю использовать опцию не рекомендуется (но не запрещается), т.к. поведение опции может меняться при изменении версии компилятора

-print-mode
Эквивалентно -print-mode=all

-print-mode=<name>
Напечатать значение текущего режимного параметра «<name>». Параметр опции может принимать следующие значения: all, cpu, ptr, libc. Опция используется при сборке библиотек run-time поддержки и при сборке дистрибутива. Конечному пользователю использовать опцию не рекомендуется (но не запрещается), т.к. поведение опции может меняться при изменении версии компилятора

-print-internal-dir
Эквивалентно -print-internal-dir=all

-print-internal-dir=<name>
Напечатать значение текущего внутреннего каталога «<name>». Параметр опции может принимать следующие значения: all, base, bin, lib, include, include-c++, include-c++-stl, fccn-include, fccn-mod, dsp-include, libmcst-lib, libmcst-include. Опция используется при сборке библиотек run-time поддержки и при сборке дистрибутива. Конечному пользователю использовать опцию не рекомендуется (но не запрещается), т.к. поведение опции может меняться при изменении версии компилятора

-print-recognized-environment
Печатать установленные переменные окружения, влияющие на работу компилятора

32 Опции для повторения внутренних свойств gcc

-ftext-switch-table
Таблицу переходов switch'а помещать в секцию .text

-fcopy-aggregate-memcpy[=<size>]
При агрегатном копировании [размером не менее <size> байт] вместо цикла использовать вызов функции memcpy

33 Опции для имитации поведения gcc под x86

-mmmx
Включить предопределённый макрос __MMX__

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

В gcc данные опции отвечают за то, что в x86 называется "расширение системы команд". Это операции, которые формально НЕ включены в состав базовой системы команд и находятся в статусе "расширения". Это означает, что набор операций может отсутствовать на некоторых моделях процессора, даже в том случае, если на других моделях процессоров данной серии набор операций присутствует. Опции выполняют две функции: разрешают компилятору самостоятельно использовать набор операций из соответствующего расширения и включают соответствующий предопределённый макрос

Когда речь идёт о процессорах "Эльбрус", то в них нет такого понятия, как "расширение системы команд", поэтому нет необходимости управлять компилятором в вопросе расширений. Таким образом, для компилятора "Эльбрус" данные опции не имеют никакого смысла. Они поддержаны только ради того, чтобы не спотыкаться об уже имеющиеся опции, которые по умолчанию включены в систему сборки некоторых программ. Напрямую сравнивать поведение опций в lcc и в gcc нельзя, т.к. поведение некоторых опций в gcc зависит от конкретной сборки gcc. Зависимость растёт от того, под какой минимальный процессор x86 сконфигурирован gcc. В зависимости от этого часть данных опций будет включена по умолчанию. А поведение некоторых опций зависит от того, включена опция по умолчанию, или нет. В случае lcc компилятор настроен таким образом, что все опции данной группы по умолчанию включены. Т.е. поведение lcc соответствует поведению некоторой абстрактной версии gcc, которая сконфигурирована под максимально возможный процессор x86. Обращаем внимание на то, что действие включающих и выключающих опций НЕ симметрично (аналогично тому, как это имеет место быть на gcc под x86)

Мы НЕ рекомендуем использовать опции -mno-* в качестве средства для борьбы с ошибками сборки программ. Если опция -mno-* помогла в сборке, то это в первую очередь говорит о том, что программа написана неаккуратно. Т.е. под соответствующий макрос был внесён какой-то код, напрямую к данному макросу отношения не имеющий. Более правильным вариантом было бы исправить код. Фактически это является частью процесса портирования под "Эльбрус" программы, изначально реализованной под x86

-mno-mmx
Выключить предопределённый макрос __MMX__, взвести опцию -mno-3dnow

-msse
Включить предопределённый макрос __SSE__

-mno-sse
Выключить предопределённый макрос __SSE__, взвести опцию -mno-sse2

-msse2
Включить предопределённый макрос __SSE2__, взвести опцию -msse

-mno-sse2
Выключить предопределённый макрос __SSE2__, взвести опцию -mno-sse3

-msse3
Включить предопределённый макрос __SSE3__, взвести опцию -msse2

-mno-sse3
Выключить предопределённый макрос __SSE3__, взвести опции -mno-ssse3, -mno-sse4a

-mssse3
Включить предопределённый макрос __SSSE3__, взвести опцию -msse3

-mno-ssse3
Выключить предопределённый макрос __SSSE3__, взвести опцию -mno-sse4.1

-msse4.1
Включить предопределённый макрос __SSE4_1__, взвести опцию -mssse3

-mno-sse4.1
Выключить предопределённый макрос __SSE4_1__, взвести опцию -mno-sse4.2

-msse4.2
Включить предопределённый макрос __SSE4_2__, взвести опциию -msse4.1

-mno-sse4.2
Выключить предопределённый макрос __SSE4_2__, взвести опциию -mno-avx

-msse4
Эквивалентно -msse4.2

-mno-sse4
Эквивалентно -mno-sse4.1

-mavx
Включить предопределённый макрос __AVX__, взвести опцию -msse4.2

-mno-avx
Выключить предопределённый макрос __AVX__, взвести опции -mno-fma, -mno-fma4, -mno-f16c, -mno-avx2

-m3dnow
Включить предопределённый макрос __3dNOW__, взвести опцию -mmmx

-mno-3dnow
Выключить предопределённый макрос __3dNOW__, взвести опцию -mno-3dnowa

-m3dnowa
Включить предопределённый макрос __3dNOW_A__, взвести опцию -m3dnow

-mno-3dnowa
Выключить предопределённый макрос __3dNOW_A__

-msse4a
Включить предопределённый макрос __SSE4A__, взвести опцию -msse3

-mno-sse4a
Выключить предопределённый макрос __SSE4A__, взвести опцию -mno-fma4

-mfma4
Включить предопределённый макрос __FMA4__, взвести опции -msse4a, -mavx

-mno-fma4
Выключить предопределённый макрос __FMA4__, взвести опцию -mno-xop

-mxop
Включить предопределённый макрос __XOP__, взвести опцию -mfma4

-mno-xop
Выключить предопределённый макрос __XOP__

-maes
Включить предопределённый макрос __AES__, взвести опцию -msse2

-mno-aes
Выключить предопределённый макрос __AES__

-mpclmul
Включить предопределённый макрос __PCLMUL__, взвести опцию -msse2

-mno-pclmul
Выключить предопределённый макрос __PCLMUL__

-mrdrnd
Включить предопределённый макрос __RDRND__

-mno-rdrnd
Выключить предопределённый макрос __RDRND__

-mbmi
Включить предопределённый макрос __BMI__

-mno-bmi
Выключить предопределённый макрос __BMI__

-mtbm
Включить предопределённый макрос __TBM__

-mno-tbm
Выключить предопределённый макрос __TBM__

-mabm
Включить предопределённый макрос __ABM__, взвести опцию -mpopcnt

-mno-abm
Выключить предопределённый макрос __ABM__

-mf16c
Включить предопределённый макрос __F16C__, взвести опцию -mavx

-mno-f16c
Выключить предопределённый макрос __F16C__

-mpopcnt
Включить предопределённый макрос __POPCNT__

-mno-popcnt
Выключить предопределённый макрос __POPCNT__

-mrdseed
Включить предопределённый макрос __RDSEED__

-mno-rdseed
Выключить предопределённый макрос __RDSEED__

-mlzcnt
Включить предопределённый макрос __LZCNT__

-mno-lzcnt
Выключить предопределённый макрос __LZCNT__

-mmwaitx
Включить предопределённый макрос __MWAITX__

-mno-mwaitx
Выключить предопределённый макрос __MWAITX__

-mclzero
Включить предопределённый макрос __CLZERO__

-mno-clzero
Выключить предопределённый макрос __CLZERO__

-mclflushopt
Включить предопределённый макрос __CLFLUSHOPT__

-mno-clflushopt
Выключить предопределённый макрос __CLFLUSHOPT__

-mclwb
Включить предопределённый макрос __CLWB__

-mno-clwb
Выключить предопределённый макрос __CLWB__

-mbmi2
Включить предопределённый макрос __BMI2__

-mno-bmi2
Выключить предопределённый макрос __BMI2__

-mfma
Включить предопределённый макрос __FMA__, взвести опцию -mavx

-mno-fma
Выключить предопределённый макрос __FMA__

-mavx2
Включить предопределённый макрос __AVX2__, взвести опцию -mavx

-mno-avx2
Выключить предопределённый макрос __AVX2__

-msha
Включить предопределённый макрос __SHA__, взвести опцию -msse2

-mno-sha
Выключить предопределённый макрос __SHA__

34 Игнорируемые опции (для совместимости с gcc)

-F <dir> (-F<dir>)
 

-faggressive-loop-optimizations (-fno-aggressive-loop-optimizations)
 

-falign-labels (-fno-align-labels)
 

-falign-labels=<val>
 

-falign-loops (-fno-align-loops)
 

-falign-loops=<val>
 

-fasm (-fno-asm)
 

-fbranch-count-reg
 

-fbuilding-libgcc
 

-fgcse (-fno-gcse)
 

-fcse-follow-jumps (-fno-cse-follow-jumps)
 

-fcse-skip-blocks (-fno-cse-skip-blocks)
 

-fcheck-new (-fno-check-new)
 

-fcode-hoisting (-fno-code-hoisting)
 

-fconserve-stack (-fno-conserve-stack)
 

-fdebug-prefix-map=<old>=<new>
 

-fdefer-pop (-fno-defer-pop)
 

-fdevirtualize-at-ltrans (-fno-devirtualize-at-ltrans)
 

-fdiagnostics-show-location=<val>
 

-fdiagnostics-show-option (-fno-diagnostics-show-option)
 

-fdollars-in-identifiers (-fno-dollars-in-identifiers)
 

-fdwarf2-indirect-strings (-fno-dwarf2-indirect-strings)
 

-felide-constructors
 

-feliminate-unused-debug-symbols (-fno-eliminate-unused-debug-symbols)
 

-feliminate-unused-debug-types (-fno-eliminate-unused-debug-types)
 

-femit-struct-debug-baseonly (-fno-emit-struct-debug-baseonly)
 

-femit-struct-debug-reduced (-fno-emit-struct-debug-reduced)
 

-femit-struct-debug-detailed=<list> (-fno-emit-struct-debug-detailed=<list>)
 

-fenforce-eh-specs (-fno-enforce-eh-specs)
 

-fexpensive-optimizations (-fno-expensive-optimizations)
 

-ffat-lto-objects (-fno-fat-lto-objects)
 

-ffile-prefix-map=<old>=<new>
 

-ffloat-store (-fno-float-store)
 

-fforce-addr
 

-fforce-mem
 

-fimplement-inlines (-fno-implement-inlines)
 

-fimplicit-templates (-fno-implicit-templates)
 

-fimplicit-inline-templates (-fno-implicit-inline-templates)
 

-finline-limit-<num> (-finline-limit=<num>)
 

-finline-small-functions (-fno-inline-small-functions)
 

-fipa-sra (-fno-ipa-sra)
 

-fkeep-inline-functions (-fno-keep-inline-functions)
 

-flifetime-dse (-fno-lifetime-dse)
 

-flifetime-dse=<val>
 

-flto (-fno-lto)
 

-flto=<n>
 

-flto-compression-level=<n>
 

-flto-partition=<alg>
 

-flto-report (-fno-lto-report)
 

-flto-report-wpa (-fno-lto-report-wpa)
 

-fmacro-prefix-map=<old>=<new>
 

-fmerge-all-constants (-fno-merge-all-constants)
 

-fms-extensions (-fno-ms-extensions)
 

-fnon-call-exceptions (-fno-non-call-exceptions)
 

-foffload=disable
 

-fomit-frame-pointer (-fno-omit-frame-pointer)
 

-foptimize-register-move (-fno-optimize-register-move)
 

-foptimize-sibling-calls
 

-fpch-deps
 

-fprefetch-loop-arrays (-fno-prefetch-loop-arrays)
 

-fpreprocessed
 

-frandom-seed=<string>
 

-fregmove (-fno-regmove)
 

-frename-registers (-fno-rename-registers)
 

-freorder-blocks (-fno-reorder-blocks)
 

-frerun-cse-after-loop (-fno-rerun-cse-after-loop)
 

-frerun-loop-opt (-fno-rerun-loop-opt)
 

-fsanitize-recover=(-fno-sanitize-recover=)
 

-fsanitize-recover=all (-fno-sanitize-recover=all)
 

-fschedule-insns (-fno-schedule-insns)
 

-fschedule-insns2 (-fno-schedule-insns2)
 

-fsecond-underscore (-fno-second-underscore)
 

-fshow-column (-fno-show-column)
 

-fsingle-precision-constant (-fno-single-precision-constant)
 

-fstack-check (-fno-stack-check)
 

-fstack-clash-protection (-fno-stack-clash-protection)
 

-fstack-protector (-fno-stack-protector)
 

-fstack-protector-all (-fno-stack-protector-all)
 

-fstack-protector-explicit (-fno-stack-protector-explicit)
 

-fstack-protector-strong (-fno-stack-protector-strong)
 

-fstdarg-opt (-fno-stdarg-opt)
 

-fsync-libcalls (-fno-sync-libcalls)
 

-fthread-jumps (-fno-thread-jumps)
 

-fthreadsafe-statics (-fno-threadsafe-statics)
 

-ftoplevel-reorder (-fno-toplevel-reorder)
 

-ftrapping-math (-fno-trapping-math)
 

-ftree-ccp (-fno-tree-ccp)
 

-ftree-copyrename (-fno-tree-copyrename)
 

-ftree-copy-prop (-fno-tree-copy-prop)
 

-ftree-dominator-opts (-fno-tree-dominator-opts)
 

-ftree-fre (-fno-tree-fre)
 

-ftree-loop-distribute-patterns (-fno-tree-loop-distribute-patterns)
 

-ftree-loop-im (-fno-tree-loop-im)
 

-ftree-pre (-fno-tree-pre)
 

-ftree-slp-vectorize (-fno-tree-slp-vectorize)
 

-ftree-ter (-fno-tree-ter)
 

-ftree-vectorize (-fno-tree-vectorize)
 

-ftree-vrp (-fno-tree-vrp)
 

-funit-at-a-time (-fno-unit-at-a-time)
 

-funroll-loops (-fno-unroll-loops)
 

-funroll-all-loops (-fno-unroll-all-loops)
 

-funsafe-loop-optimizations (-fno-unsafe-loop-optimizations)
 

-fuse-linker-plugin (-fno-use-linker-plugin)
 

-fvar-tracking (-fno-var-tracking)
 

-fvar-tracking-assignments (-fno-var-tracking-assignments)
 

-fweb (-fno-web)
 

-fno-working-directory
 

-fwrapv (-fno-wrapv)
 

-malign-jumps (-mno-align-jumps)
 

-malign-jumps=<val>
 

-mpreferred-stack-boundary=<val>
 

-mfpmath=<val>
 

--param <str> (--param=<str>)
 

-pipe (--pipe)
 

35 Игнорируемые опции (для совместимости с прошлыми версиями lcc)

-fipo-cprop-arrays
Опция устарела и будет удалена в следующей версии компилятора

36 Поддерживаемые переменные окружения

TMPDIR
Настройка каталога для временных файлов

CPATH
Дополнительные пути поиска заголовочных файлов

C_INCLUDE_PATH
Дополнительные пути поиска заголовочных файлов языка C

CPLUS_INCLUDE_PATH
Дополнительные пути поиска заголовочных файлов языка C++

DEPENDENCIES_OUTPUT
Значение должно иметь формат "file[ name]"; то же, что и -MMD -MF file -MT name

SUNPRO_DEPENDENCIES
Значение должно иметь формат "file[ name]"; то же, что и -MD -MF file -MT name

LIBRARY_PATH
Дополнительные пути поиска библиотек

LC_ALL
Определяет язык выдачи сообщений

LC_MESSAGES
Определяет язык выдачи сообщений

LANG
Определяет язык выдачи сообщений

MCST_CFLAGS_FILE
Эквивалетно наличию опции @ в конце командной строки

GCC_COLORS
Задаёт настройки цвета для цветовой подсветки сообщений. Пустое значение отключает цветовую подсветку сообщений

TERM
Если выставлено в значение "dumb", то отключает цветовую подсветку сообщений

MCST_PROF_DIR
Задаёт каталог для сброса/чтения профильной информации. Имеет приоритет над каталогом, заданным опциями -fprofile-generate и -fprofile-use

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