Compiler reference guide#

Applies to Linux and Windows

2024-02-09

99 min read time

Introduction to compiler reference guide#

ROCmCC is a Clang/LLVM-based compiler. It is optimized for high-performance computing on AMD GPUs and CPUs and supports various heterogeneous programming models such as HIP, OpenMP, and OpenCL.

ROCmCC is made available via two packages: rocm-llvm and rocm-llvm-alt. The differences are listed in the table below.

Differences between rocm-llvm and rocm-llvm-alt#

rocm-llvm

rocm-llvm-alt

Installed by default when ROCm™ itself is installed

An optional package

Provides an open-source compiler

Provides an additional closed-source compiler for users interested in additional CPU optimizations not available in rocm-llvm

For more details, see:

ROCm compiler interfaces#

ROCm currently provides two compiler interfaces for compiling HIP programs:

  • /opt/rocm/bin/hipcc

  • /opt/rocm/bin/amdclang++

Both leverage the same LLVM compiler technology with the AMD GCN GPU support; however, they offer a slightly different user experience. The hipcc command-line interface aims to provide a more familiar user interface to users who are experienced in CUDA but relatively new to the ROCm/HIP development environment. On the other hand, amdclang++ provides a user interface identical to the clang++ compiler. It is more suitable for experienced developers who want to directly interact with the clang compiler and gain full control of their application’s build process.

The major differences between hipcc and amdclang++ are listed below:

Differences between hipcc and amdclang++#

*

hipcc

amdclang++

Compiling HIP source files

Treats all source files as HIP language source files

Enables the HIP language support for files with the .hip extension or through the -x hip compiler option

Detecting GPU architecture

Auto-detects the GPUs available on the system and generates code for those devices when no GPU architecture is specified

Has AMD GCN gfx803 as the default GPU architecture. The --offload-arch compiler option may be used to target other GPU architectures

Finding a HIP installation

Finds the HIP installation based on its own location and its knowledge about the ROCm directory structure

First looks for HIP under the same parent directory as its own LLVM directory and then falls back on /opt/rocm. Users can use the --rocm-path option to instruct the compiler to use HIP from the specified ROCm installation.

Linking to the HIP runtime library

Is configured to automatically link to the HIP runtime from the detected HIP installation

Requires the --hip-link flag to be specified to link to the HIP runtime. Alternatively, users can use the -l<dir> -lamdhip64 option to link to a HIP runtime library.

Device function inlining

Inlines all GPU device functions, which provide greater performance and compatibility for codes that contain file scoped or device function scoped __shared__ variables. However, it may increase compile time.

Relies on inlining heuristics to control inlining. Users experiencing performance or compilation issues with code using file scoped or device function scoped __shared__ variables could try -mllvm -amdgpu-early-inline-all=true -mllvm -amdgpu-function-calls=false to work around the issue. There are plans to address these issues with future compiler improvements.

Source code location

ROCm/HIPCC

ROCm/llvm-project

Compiler options and features#

This chapter discusses compiler options and features.

AMD GPU compilation#

This section outlines commonly used compiler flags for hipcc and amdclang++.

-x hip#

Compiles the source file as a HIP program.

-fopenmp#

Enables the OpenMP support.

-fopenmp-targets=<gpu>#

Enables the OpenMP target offload support of the specified GPU architecture.

Gpu:

The GPU architecture. E.g. gfx908.

--gpu-max-threads-per-block=<value>:#

Sets the default limit of threads per block. Also referred to as the launch bounds.

Value:

The default maximum amount of threads per block.

-munsafe-fp-atomics#

Enables unsafe floating point atomic instructions (AMDGPU only).

-ffast-math#

Allows aggressive, lossy floating-point optimizations.

-mwavefrontsize64, -mno-wavefrontsize64#

Sets wavefront size to be 64 or 32 on RDNA architectures.

-mcumode#

Switches between CU and WGP modes on RDNA architectures.

--offload-arch=<gpu>#

HIP offloading target ID. May be specified more than once.

Gpu:

The a device architecture followed by target ID features delimited by a colon. Each target ID feature is a predefined string followed by a plus or minus sign (e.g. gfx908:xnack+:sramecc-).

-g#

Generates source-level debug information.

-fgpu-rdc, -fno-gpu-rdc#

Generates relocatable device code, also known as separate compilation mode.

AMD optimizations for zen architectures#

The CPU compiler optimizations described in this chapter originate from the AMD Optimizing C/C++ Compiler (AOCC) compiler. They are available in ROCmCC if the optional rocm-llvm-alt package is installed. The user’s interaction with the compiler does not change once rocm-llvm-alt is installed. The user should use the same compiler entry point, provided AMD provides high-performance compiler optimizations for Zen-based processors in AOCC.

For more information, refer to https://www.amd.com/en/developer/aocc.html.

-famd-opt#

Enables a default set of AMD proprietary optimizations for the AMD Zen CPU architectures.

-fno-amd-opt disables the AMD proprietary optimizations.

The -famd-opt flag is useful when a user wants to build with the proprietary optimization compiler and not have to depend on setting any of the other proprietary optimization flags.

Note

-famd-opt can be used in addition to the other proprietary CPU optimization flags. The table of optimizations below implicitly enables the invocation of the AMD proprietary optimizations compiler, whereas the -famd-opt flag requires this to be handled explicitly.

-fstruct-layout=[1,2,3,4,5,6,7]#

Analyzes the whole program to determine if the structures in the code can be peeled and the pointer or integer fields in the structure can be compressed. If feasible, this optimization transforms the code to enable these improvements. This transformation is likely to improve cache utilization and memory bandwidth. It is expected to improve the scalability of programs executed on multiple cores.

This is effective only under -flto, as the whole program analysis is required to perform this optimization. Users can choose different levels of aggressiveness with which this optimization can be applied to the application, with 1 being the least aggressive and 7 being the most aggressive level.

-fstruct-layout Values and Their Effects#

-fstruct-layout value

Structure peeling

Pointer size after selective compression of self-referential pointers in structures, wherever safe

Type of structure fields eligible for compression

Whether compression performed under safety check

1

Enabled

NA

NA

NA

2

Enabled

32-bit

NA

NA

3

Enabled

16-bit

NA

NA

4

Enabled

32-bit

Integer

Yes

5

Enabled

16-bit

Integer

Yes

6

Enabled

32-bit

64-bit signed int or unsigned int. Users must ensure that the values assigned to 64-bit signed int fields are in range -(2^31 - 1) to +(2^31 - 1) and 64-bit unsigned int fields are in the range 0 to +(2^31 - 1). Otherwise, you may obtain incorrect results.

No. Users must ensure the safety based on the program compiled.

7

Enabled

16-bit

64-bit signed int or unsigned int. Users must ensure that the values assigned to 64-bit signed int fields are in range -(2^31 - 1) to +(2^31 - 1) and 64-bit unsigned int fields are in the range 0 to +(2^31 - 1). Otherwise, you may obtain incorrect results.

No. Users must ensure the safety based on the program compiled.

-fitodcalls#

Promotes indirect-to-direct calls by placing conditional calls. Application or benchmarks that have a small and deterministic set of target functions for function pointers passed as call parameters benefit from this optimization. Indirect-to-direct call promotion transforms the code to use all possible determined targets under runtime checks and falls back to the original code for all the other cases. Runtime checks are introduced by the compiler for each of these possible function pointer targets followed by direct calls to the targets.

This is a link time optimization, which is invoked as -flto -fitodcalls

-fitodcallsbyclone#

Performs value specialization for functions with function pointers passed as an argument. It does this specialization by generating a clone of the function. The cloning of the function happens in the call chain as needed, to allow conversion of indirect function call to direct call.

This complements -fitodcalls optimization and is also a link time optimization, which is invoked as -flto -fitodcallsbyclone.

-fremap-arrays#

Transforms the data layout of a single dimensional array to provide better cache locality. This optimization is effective only under -flto, as the whole program needs to be analyzed to perform this optimization, which can be invoked as -flto -fremap-arrays.

-finline-aggressive#

Enables improved inlining capability through better heuristics. This optimization is more effective when used with -flto, as the whole program analysis is required to perform this optimization, which can be invoked as -flto -finline-aggressive.

-fnt-store (non-temporal store)#

Generates a non-temporal store instruction for array accesses in a loop with a large trip count.

-fnt-store=aggressive#

This is an experimental option to generate non-temporal store instruction for array accesses in a loop, whose iteration count cannot be determined at compile time. In this case, the compiler assumes the iteration count to be huge.

Optimizations through driver -mllvm <options>#

The following optimization options must be invoked through driver -mllvm <options>:

-enable-partial-unswitch#

Enables partial loop unswitching, which is an enhancement to the existing loop unswitching optimization in LLVM. Partial loop unswitching hoists a condition inside a loop from a path for which the execution condition remains invariant, whereas the original loop unswitching works for a condition that is completely loop invariant. The condition inside the loop gets hoisted out from the invariant path, and the original loop is retained for the path where the condition is variant.

-aggressive-loop-unswitch#

Experimental option that enables aggressive loop unswitching heuristic (including -enable-partial-unswitch) based on the usage of the branch conditional values. Loop unswitching leads to code bloat. Code bloat can be minimized if the hoisted condition is executed more often. This heuristic prioritizes the conditions based on the number of times they are used within the loop. The heuristic can be controlled with the following options:

  • -unswitch-identical-branches-min-count=<n>

    • Enables unswitching of a loop with respect to a branch conditional value (B), where B appears in at least <n> compares in the loop. This option is enabled with -aggressive-loop-unswitch. The default value is 3.

    Usage: -mllvm -aggressive-loop-unswitch -mllvm -unswitch-identical-branches-min-count=<n>

    Where, n is a positive integer and lower value of <n> facilitates more unswitching.

  • -unswitch-identical-branches-max-count=<n>

    • Enables unswitching of a loop with respect to a branch conditional value (B), where B appears in at most <n> compares in the loop. This option is enabled with -aggressive-loop-unswitch. The default value is 6.

    Usage: -mllvm -aggressive-loop-unswitch -mllvm -unswitch-identical-branches-max-count=<n>

    Where, n is a positive integer and higher value of <n> facilitates more unswitching.

    Note

    These options may facilitate more unswitching under some workloads. Since loop-unswitching inherently leads to code bloat, facilitating more unswitching may significantly increase the code size. Hence, it may also lead to longer compilation times.

-enable-strided-vectorization#

Enables strided memory vectorization as an enhancement to the interleaved vectorization framework present in LLVM. It enables the effective use of gather and scatter kind of instruction patterns. This flag must be used along with the interleave vectorization flag.

-enable-epilog-vectorization#

Enables vectorization of epilog-iterations as an enhancement to existing vectorization framework. This enables generation of an additional epilog vector loop version for the remainder iterations of the original vector loop. The vector size or factor of the original loop should be large enough to allow an effective epilog vectorization of the remaining iterations. This optimization takes place only when the original vector loop is vectorized with a vector width or factor of 16. This vectorization width of 16 may be overwritten by -min-width-epilog-vectorization command-line option.

-enable-redundant-movs#

Removes any redundant mov operations including redundant loads from memory and stores to memory. This can be invoked using -Wl,-plugin-opt=-enable-redundant-movs.

-merge-constant#

Attempts to promote frequently occurring constants to registers. The aim is to reduce the size of the instruction encoding for instructions using constants and obtain a performance improvement.

-function-specialize#

Optimizes the functions with compile time constant formal arguments.

-lv-function-specialization#

Generates specialized function versions when the loops inside function are vectorizable and the arguments are not aliased with each other.

-enable-vectorize-compares#

Enables vectorization on certain loops with conditional breaks assuming the memory accesses are safely bound within the page boundary.

-inline-recursion=[1,2,3,4]#

Enables inlining for recursive functions based on heuristics where the aggressiveness of heuristics increases with the level (1-4). The default level is 2. Higher levels may lead to code bloat due to expansion of recursive functions at call sites.

-inline-recursion Level and Their Effects#

-inline-recursion value

Inline depth of heuristics used to enable inlining for recursive functions

1

1

2

1

3

1

4

10

This is more effective with -flto as the whole program needs to be analyzed to perform this optimization, which can be invoked as -flto -inline-recursion=[1,2,3,4].

-reduce-array-computations=[1,2,3]#

Performs array data flow analysis and optimizes the unused array computations.

-reduce-array-computations Values and Their Effects#

-reduce-array-computations value

Array elements eligible for elimination of computations

1

Unused

2

Zero valued

3

Both unused and zero valued

This optimization is effective with -flto as the whole program needs to be analyzed to perform this optimization, which can be invoked as -flto -reduce-array-computations=[1,2,3].

-global-vectorize-slp={true,false}#

Vectorizes the straight-line code inside a basic block with data reordering vector operations. This option is set to true by default.

-region-vectorize#

Experimental flag for enabling vectorization on certain loops with complex control flow, which the normal vectorizer cannot handle.

This optimization is effective with -flto as the whole program needs to be analyzed to perform this optimization, which can be invoked as -flto -region-vectorize.

-enable-x86-prefetching#

Enables the generation of x86 prefetch instruction for the memory references inside a loop or inside an innermost loop of a loop nest to prefetch the second dimension of multidimensional array/memory references in the innermost loop of a loop nest. This is an experimental pass; its profitability is being improved.

-suppress-fmas#

Identifies the reduction patterns on FMA and suppresses the FMA generation, as it is not profitable on the reduction patterns.

-enable-icm-vrp#

Enables estimation of the virtual register pressure before performing loop invariant code motion. This estimation is used to control the number of loop invariants that will be hoisted during the loop invariant code motion.

-loop-splitting#

Enables splitting of loops into multiple loops to eliminate the branches, which compare the loop induction with an invariant or constant expression. This option is enabled under -O3 by default. To disable this optimization, use -loop-splitting=false.

-enable-ipo-loop-split#

Enables splitting of loops into multiple loops to eliminate the branches, which compares the loop induction with a constant expression. This constant expression can be derived through inter-procedural analysis. This option is enabled under -O3 by default. To disable this optimization, use -enable-ipo-loop-split=false.

-compute-interchange-order#

Enables heuristic for finding the best possible interchange order for a loop nest. To enable this option, use -enable-loopinterchange. This option is set to false by default.

Usage:

-mllvm -enable-loopinterchange -mllvm -compute-interchange-order
-convert-pow-exp-to-int={true,false}#

Converts the call to floating point exponent version of pow to its integer exponent version if the floating-point exponent can be converted to integer. This option is set to true by default.

-do-lock-reordering={none,normal,aggressive}#

Reorders the control predicates in increasing order of complexity from outer predicate to inner when it is safe. The normal mode reorders simple expressions, while the aggressive mode reorders predicates involving function calls if no side effects are determined. This option is set to normal by default.

-fuse-tile-inner-loop#

Enables fusion of adjacent tiled loops as a part of loop tiling transformation. This option is set to false by default.

-Hz,1,0x1 [Fortran]#

Helps to preserve array index information for array access expressions which get linearized in the compiler front end. The preserved information is used by the compiler optimization phase in performing optimizations such as loop transformations. It is recommended that any user who is using optimizations such as loop transformations and other optimizations requiring de-linearized index expressions should use the Hz option. This option has no impact on any other aspects of the Flang front end.

Inline ASM statements#

Inline assembly (ASM) statements allow a developer to include assembly instructions directly in either host or device code. While the ROCm compiler supports ASM statements, their use is not recommended for the following reasons:

  • The compiler’s ability to produce both correct code and to optimize surrounding code is impeded.

  • The compiler does not parse the content of the ASM statements and so cannot “see” its contents.

  • The compiler must make conservative assumptions in an effort to retain correctness.

  • The conservative assumptions may yield code that, on the whole, is less performant compared to code without ASM statements. It is possible that a syntactically correct ASM statement may cause incorrect runtime behavior.

  • ASM statements are often ASIC-specific; code containing them is less portable and adds a maintenance burden to the developer if different ASICs are targeted.

  • Writing correct ASM statements is often difficult; we strongly recommend thorough testing of any use of ASM statements.

Note

For developers who choose to include ASM statements in the code, AMD is interested in understanding the use case and appreciates feedback at ROCm/ROCm#issues

Miscellaneous OpenMP compiler features#

This section discusses features that have been added or enhanced in the OpenMP compiler.

Offload-arch tool#

An LLVM library and tool that is used to query the execution capability of the current system as well as to query requirements of a binary file. It is used by OpenMP device runtime to ensure compatibility of an image with the current system while loading it. It is compatible with target ID support and multi-image fat binary support.

Usage:

offload-arch [Options] [Optional lookup-value]

When used without an option, offload-arch prints the value of the first offload arch found in the underlying system. This can be used by various clang front ends. For example, to compile for OpenMP offloading on your current system, invoke clang with the following command:

clang -fopenmp -fopenmp-targets=`offload-arch` foo.c

If an optional lookup-value is specified, offload-arch will check if the value is either a valid offload-arch or a codename and look up requested additional information.

The following command provides all the information for offload-arch gfx906:

offload-arch gfx906 -v

The options are listed below:

-h#

Prints the help message.

-a#

Prints values for all devices. Do not stop at the first device found.

-m#

Prints device code name (often found in pci.ids file).

-n#

Prints numeric pci-id.

-t#

Prints clang offload triple to use for the offload arch.

-v#

Verbose. Implies: -a -m -n -t. For: all devices, prints codename, numeric value, and triple.

-f <file>#

Prints offload requirements including offload-arch for each compiled offload image built into an application binary file.

-c#

Prints offload capabilities of the underlying system. This option is used by the language runtime to select an image when multiple images are available. A capability must exist for each requirement of the selected image.

There are symbolic link aliases amdgpu-offload-arch and nvidia-arch for offload-arch. These aliases return 1 if no AMD GCN GPU or CUDA GPU is found. These aliases are useful in determining whether architecture-specific tests should be run or to conditionally load architecture-specific software.

Command-line simplification using offload-arch flag#

Legacy mechanism of specifying offloading target for OpenMP involves using three flags, -fopenmp-targets, -Xopenmp-target, and -march. The first two flags take a target triple (like amdgcn-amd-amdhsa or nvptx64-nvidia-cuda), while the last flag takes device name (like gfx908 or sm_70) as input. Alternatively, users of ROCmCC compiler can use the flag —offload-arch for a combined effect of the above three flags.

Example:

# Legacy mechanism
clang -fopenmp -target x86_64-linux-gnu \
-fopenmp-targets=amdgcn-amd-amdhsa -Xopenmp-target=amdgcn-amd-amdhsa \
-march=gfx906 helloworld.c -o helloworld

Example:

# Using offload-arch flag
clang -fopenmp -target x86_64-linux-gnu \
--offload-arch=gfx906 helloworld.c -o helloworld.

To ensure backward compatibility, both styles are supported. This option is compatible with target ID support and multi-image fat binaries.

Target ID support for OpenMP#

The ROCmCC compiler supports specification of target features along with the GPU name while specifying a target offload device in the command line, using -march or --offload-arch options. The compiled image in such cases is specialized for a given configuration of device and target features (target ID).

Example:

# compiling for a gfx908 device with XNACK paging support turned ON
clang -fopenmp -target x86_64-linux-gnu \
-fopenmp-targets=amdgcn-amd-amdhsa -Xopenmp-target=amdgcn-amd-amdhsa \
-march=gfx908:xnack+ helloworld.c -o helloworld

Example:

# compiling for a gfx908 device with SRAMECC support turned OFF
clang -fopenmp -target x86_64-linux-gnu \
-fopenmp-targets=amdgcn-amd-amdhsa -Xopenmp-target=amdgcn-amd-amdhsa \
-march=gfx908:sramecc- helloworld.c -o helloworld

Example:

# compiling for a gfx908 device with SRAMECC support turned ON and XNACK paging support turned OFF
clang -fopenmp -target x86_64-linux-gnu \
-fopenmp-targets=amdgcn-amd-amdhsa -Xopenmp-target=amdgcn-amd-amdhsa \
-march=gfx908:sramecc+:xnack- helloworld.c -o helloworld

The target ID specified on the command line is passed to the clang driver using target-feature flag, to the LLVM optimizer and back end using -mattr flag, and to linker using -plugin-opt=-mattr flag. This feature is compatible with offload-arch command-line option and multi-image binaries for multiple architectures.

Multi-image fat binary for OpenMP#

The ROCmCC compiler is enhanced to generate binaries that can contain heterogenous images. This heterogeneity could be in terms of:

  • Images of different architectures, like AMD GCN and NVPTX

  • Images of same architectures but for different GPUs, like gfx906 and gfx908

  • Images of same architecture and same GPU but for different target features, like gfx908:xnack+ and gfx908:xnack-

An appropriate image is selected by the OpenMP device runtime for execution depending on the capability of the current system. This feature is compatible with target ID support and offload-arch command-line options and uses offload-arch tool to determine capability of the current system.

Example:

clang -fopenmp -target x86_64-linux-gnu \
-fopenmp-targets=amdgcn-amd-amdhsa,amdgcn-amd-amdhsa \
-Xopenmp-target=amdgcn-amd-amdhsa -march=gfx906 \
-Xopenmp-target=amdgcn-amd-amdhsa -march=gfx908 \
helloworld.c -o helloworld

Example:

clang -fopenmp -target x86_64-linux-gnu \
--offload-arch=gfx906 \
--offload-arch=gfx908 \
helloworld.c -o helloworld

Example:

clang -fopenmp -target x86_64-linux-gnu \
-fopenmp-targets=amdgcn-amd-amdhsa,amdgcn-amd-amdhsa,amdgcn-amd-amdhsa,amdgcn-amd-amdhsa \
-Xopenmp-target=amdgcn-amd-amdhsa -march=gfx908:sramecc+:xnack+ \
-Xopenmp-target=amdgcn-amd-amdhsa -march=gfx908:sramecc-:xnack+ \
-Xopenmp-target=amdgcn-amd-amdhsa -march=gfx908:sramecc+:xnack- \
-Xopenmp-target=amdgcn-amd-amdhsa -march=gfx908:sramecc-:xnack- \
helloworld.c -o helloworld

The ROCmCC compiler creates an instance of toolchain for each unique combination of target triple and the target GPU (along with the associated target features). clang-offload-wrapper tool is modified to insert a new structure __tgt_image_info along with each image in the binary. Device runtime is also modified to query this structure to identify a compatible image based on the capability of the current system.

Unified shared memory#

The following OpenMP pragma is available on MI200, and it must be executed with xnack+ support.

omp requires unified_shared_memory

For more details on unified shared memory refer to the Asynchronous behavior in OpenMP target regions section of the OpenMP Guide.

Support status of other Clang options#

The following table lists the other Clang options and their support status.

Clang Options#

Option

Support Status

Description

-###

Supported

Prints (but does not run) the commands to run for this compilation

--analyzer-output <value>

Supported

“Static analyzer report output format (`html

--analyze

Supported

Runs the static analyzer

-arcmt-migrate-emit-errors

Unsupported

Emits ARC errors even if the migrator can fix them

-arcmt-migrate-report-output  <value>

Unsupported

Output path for the plist report

-byteswapio

Supported

Swaps byte-order for unformatted input/output

-B <dir>

Supported

Adds <dir> to search path for binaries and object files used implicitly

-CC

Supported

Includes comments from within the macros in the preprocessed output

-cl-denorms-are-zero

Supported

OpenCL only. Allows denormals to be flushed to zero

-cl-fast-relaxed-math

Supported

OpenCL only. Sets -cl-finite-math-only and -cl-unsafe-math-optimizations and defines __FAST_RELAXED_MATH__

-cl-finite-math-only

Supported

OpenCL only. Allows floating-point optimizations that assume arguments and results are not NaNs or +-Inf

-cl-fp32-correctly-rounded-divide-sqrt

Supported

OpenCL only. Specifies that single-precision floating-point divide and sqrt used in the program source are correctly rounded

-cl-kernel-arg-info

Supported

OpenCL only. Generates kernel argument metadata

-cl-mad-enable

Supported

OpenCL only. Allows use of less precise MAD computations in the generated binary

-cl-no-signed-zeros

Supported

OpenCL only. Allows use of less precise no-signed-zeros computations in the generated binary

-cl-opt-disable

Supported

OpenCL only. Disables all optimizations. By default, optimizations are enabled.

-cl-single-precision-constant

Supported

OpenCL only. Treats double-precision floating-point constant as single precision constant

-cl-std= <value>

Supported

OpenCL language standard to compile for

-cl-strict-aliasing

Supported

OpenCL only. This option is added for compatibility with OpenCL 1.0.

-cl-uniform-work-group-size

Supported

OpenCL only. Defines the global work-size to be a multiple of the work-group size specified for clEnqueueNDRangeKernel

-cl-unsafe-math-optimizations

Supported

OpenCL only. Allows unsafe floating-point optimizations. Also implies -cl-no-signed-zeros and -cl-mad-enable

--config <value>

Supported

Specifies configuration file

--cuda-compile-host-device

Supported

Compiles CUDA code for both host and device (default). Has no effect on non-CUDA compilations

--cuda-device-only

Supported

Compiles CUDA code for device only

--cuda-host-only

Supported

Compiles CUDA code for host only. Has no effect on non-CUDA compilations

--cuda-include-ptx=<value>

Unsupported

Includes PTX for the following GPU architecture (e.g. sm_35) or “all.” May be specified more than once

--cuda-noopt-device-debug

Unsupported

Enables device-side debug info generation. Disables ptxas optimizations

--cuda-path-ignore-env

Unsupported

Ignores environment variables to detect CUDA installation

--cuda-path=<value>

Unsupported

CUDA installation path

-cxx-isystem <directory>

Supported

Adds a directory to the C++ SYSTEM include search path

-C

Supported

Includes comments in the preprocessed output

-c

Supported

Runs only preprocess, compile, and assemble steps

-dD

Supported

Prints macro definitions in -E mode in addition to the normal output

-dependency-dot <value>

Supported

Writes DOT-formatted header dependencies to the specified filename

-dependency-file <value>

Supported

Writes dependency output to the specified filename (or -)

-dI

Supported

Prints include directives in -E mode in addition to the normal output

-dM

Supported

Prints macro definitions in -E mode instead of the normal output

-dsym-dir <dir>

Unsupported

Outputs dSYMs (if any) to the specified directory

-D <macro>

Supported

=<value>. Defines <macro> to <value> (or 1 if <value> omitted)

-emit-ast

Supported

Emits Clang AST files for source inputs

-emit-interface-stubs

Supported

Generates interface stub files

-emit-llvm

Supported

Uses the LLVM representation for assembler and object files

-emit-merged-ifs

Supported

Generates interface stub files and emits merged text not binary

--emit-static-lib

Supported

Enables linker job to emit a static library

-enable-trivial-auto-var-init-zero-knowing-it-will-be-removed-from-clang

Supported

Declares enabling trivial automatic variable initialization to zero for benchmarking purpose with the knowledge that it will eventually be removed

-E

Supported

Runs the preprocessor only

-fAAPCSBitfieldLoad

Unsupported

Follows the AAPCS standard where all volatile bit-field writes generate at least one load (ARM only)

-faddrsig

Supported

Emits an address-significance table

-faligned-allocation

Supported

Enables C++17 aligned allocation functions

-fallow-editor-placeholders

Supported

Treats editor placeholders as valid source code

-fallow-fortran-gnu-ext

Supported

Allows Fortran GNU extensions

-fansi-escape-codes

Supported

Uses ANSI escape codes for diagnostics

-fapple-kext

Unsupported

Uses Apple’s kernel extensions ABI

-fapple-link-rtlib

Unsupported

Forces linking of the clang built-ins runtime library

-fapple-pragma-pack

Unsupported

Enables Apple gcc-compatible #pragma pack handling

-fapplication-extension

Unsupported

Restricts code to those available for App Extensions

-fbackslash

Supported

Treats backslash as C-style escape character

-fbasic-block-sections= <value>

Supported

“Places each function’s basic blocks in unique sections (ELF Only) : all | labels | none | list= <file>”

-fblocks

Supported

Enables the ‘blocks’ language feature

-fborland-extensions

Unsupported

Accepts non-standard constructs supported by the Borland compile

-fbuild-session-file= <file>

Supported

Uses the last modification time of <file> as the build session timestamp

-fbuild-session-timestamp= <time since Epoch in seconds>

Supported

Specifies starting time of the current build session

-fbuiltin-module-map

Unsupported

Loads the Clang built-ins module map file

-fcall-saved-x10

Unsupported

Makes the x10 register call-saved (AArch64 only)

-fcall-saved-x11

Unsupported

Makes the x11 register call-saved (AArch64 only)

-fcall-saved-x12

Unsupported

Makes the x12 register call-saved (AArch64 only)

-fcall-saved-x13

Unsupported

Makes the x13 register call-saved (AArch64 only)

-fcall-saved-x14

Unsupported

Makes the x14 register call-saved (AArch64 only)

-fcall-saved-x15

Unsupported

Makes the x15 register call-saved (AArch64 only)

-fcall-saved-x18

Unsupported

Makes the x18 register call-saved (AArch64 only)

-fcall-saved-x8

Unsupported

Makes the x8 register call-saved (AArch64 only)

-fcall-saved-x9

Unsupported

Makes the x9 register call-saved (AArch64 only)

-fcf-protection= <value>

Unsupported

Specifies the instrument control-flow architecture protection using options: return, branch, full, none

-fcf-protection

Unsupported

Enables cf-protection in ‘full’ mode

-fchar8_t

Supported

Enables C++ built-in type char8_t

-fclang-abi-compat= <version>

Supported

Attempts to match the ABI of Clang <version>

-fcolor-diagnostics

Supported

Enables colors in diagnostics

-fcomment-block-commands= <arg>

Supported

Treats each comma-separated argument in <arg> as a documentation comment block command

-fcommon

Supported

Places uninitialized global variables in a common block

-fcomplete-member-pointers

Supported

Requires member pointer base types to be complete if they are significant under the Microsoft ABI

-fconvergent-functions

Supported

Assumes functions to be convergent

-fcoroutines-ts

Supported

Enables support for the C++ Coroutines TS

-fcoverage-mapping

Unsupported

Generates coverage mapping to enable code coverage analysis

-fcs-profile-generate= <directory>

Unsupported

Generates instrumented code to collect context-sensitive execution counts into <directory>/default.profraw (overridden by LLVM_PROFILE_FILE env var)

-fcs-profile-generate

Unsupported

Generates instrumented code to collect context-sensitive execution counts into default.profraw (overridden by LLVM_PROFILE_FILE env var)

-fcuda-approx-transcendentals

Unsupported

Uses approximate transcendental functions

-fcuda-flush-denormals-to-zero

Supported

Flushes denormal floating-point values to zero in CUDA device mode

-fcuda-short-ptr

Unsupported

Uses 32-bit pointers for accessing const/local/shared address spaces

-fcxx-exceptions

Supported

Enables C++ exceptions

-fdata-sections

Supported

Places each data in its section

-fdebug-compilation-dir <value>

Supported

Specifies the compilation directory for embedding the debug info

-fdebug-default-version= <value>

Supported

Specifies the default DWARF version to use, if a -g option caused DWARF debug info to be produced

-fdebug-info-for-profiling

Supported

Emits extra debug info to make the sample profile more accurate

-fdebug-macro

Supported

Emits macro debug information

-fdebug-prefix-map= <value>

Supported

Remaps file source paths in debug info

-fdebug-ranges-base-address

Supported

Uses DWARF base address selection entries in .debug ranges

-fdebug-types-section

Supported

Places debug types in their section (ELF only)

-fdeclspec

Supported

Allows __declspec as a keyword

-fdelayed-template-parsing

Supported

Parses templated function definitions at the end of the translation unit

-fdelete-null-pointer-checks

Supported

Treats usage of null pointers as undefined behavior (default)

-fdiagnostics-absolute-paths

Supported

Prints absolute paths in diagnostics

-fdiagnostics-hotness-threshold= <number>

Unsupported

Prevents optimization remarks from being output if they do not have at least the specified number of profile count

-fdiagnostics-parseable-fixits

Supported

Prints fix-its in machine parseable form

-fdiagnostics-print-source-range-info

Supported

Prints source range spans in numeric form

-fdiagnostics-show-hotness

Unsupported

Enables profile hotness information in diagnostic line

-fdiagnostics-show-note-include-stack

Supported

Displays include stacks for diagnostic notes

-fdiagnostics-show-option

Supported

Prints option name with mappable diagnostics

-fdiagnostics-show-template-tree

Supported

Prints a template comparison tree for differing templates

-fdigraphs

Supported

Enables alternative token representations ‘ <:’, ‘:>’, ‘ <%’, ‘%>’, ‘%:’, ‘%:%:’ (default)

-fdiscard-value-names

Supported

Discards value names in LLVM IR

-fdollars-in-identifiers

Supported

Allows “$” in identifiers

-fdouble-square-bracket-attributes

Supported

Enables ‘[[]]’ attributes in all C and C++ language modes

-fdwarf-exceptions

Unsupported

Uses DWARF style exceptions

-feliminate-unused-debug-types

Supported

Eliminates debug info for defined but unused types

-fembed-bitcode-marker

Supported

Embeds placeholder LLVM IR data as a marker

-fembed-bitcode= <option>

Supported

Embeds LLVM bitcode (option: off, all, bitcode, marker)

-fembed-bitcode

Supported

Embeds LLVM IR bitcode as data

-femit-all-decls

Supported

Emits all declarations, even if unused

-femulated-tls

Supported

Uses emutls functions to access thread_local variables

-fenable-matrix

Supported

Enables matrix data type and related built-in functions

-fexceptions

Supported

Enables support for exception handling

-fexperimental-new-constant-interpreter

Supported

Enables the experimental new constant interpreter

-fexperimental-new-pass-manager

Supported

Enables an experimental new pass manager in LLVM

-fexperimental-relative-c+±abi-vtables

Supported

Uses the experimental C++ class ABI for classes with virtual tables

-fexperimental-strict-floating-point

Supported

Enables experimental strict floating point in LLVM

-ffast-math

Supported

Allows aggressive, lossy floating-point optimizations

-ffile-prefix-map= <value>

Supported

Remaps file source paths in debug info and predefined preprocessor macros

-ffine-grained-bitfield-accesses

Supported

Uses separate accesses for consecutive bitfield runs with legal widths and alignments

-ffixed-form

Supported

Enables fixed-form format for Fortran

-ffixed-point

Supported

Enables fixed point types

-ffixed-r19

Unsupported

Reserves the r19 register (Hexagon only)

-ffixed-r9

Unsupported

Reserves the r9 register (ARM only)

-ffixed-x10

Unsupported

Reserves the x10 register (AArch64/RISC-V only)

-ffixed-x11

Unsupported

Reserves the x11 register (AArch64/RISC-V only)

-ffixed-x12

Unsupported

Reserves the x12 register (AArch64/RISC-V only)

-ffixed-x13

Unsupported

Reserves the x13 register (AArch64/RISC-V only)

-ffixed-x14

Unsupported

Reserves the x14 register (AArch64/RISC-V only)

-ffixed-x15

Unsupported

Reserves the x15 register (AArch64/RISC-V only)

-ffixed-x16

Unsupported

Reserves the x16 register (AArch64/RISC-V only)

-ffixed-x17

Unsupported

Reserves the x17 register (AArch64/RISC-V only)

-ffixed-x18

Unsupported

Reserves the x18 register (AArch64/RISC-V only)

-ffixed-x19

Unsupported

Reserves the x19 register (AArch64/RISC-V only)

-ffixed-x1

Unsupported

Reserves the x1 register (AArch64/RISC-V only)

-ffixed-x20

Unsupported

Reserves the x20 register (AArch64/RISC-V only)

-ffixed-x21

Unsupported

Reserves the x21 register (AArch64/RISC-V only)

-ffixed-x22

Unsupported

Reserves the x22 register (AArch64/RISC-V only)

-ffixed-x23

Unsupported

Reserves the x23 register (AArch64/RISC-V only)

-ffixed-x24

Unsupported

Reserves the x24 register (AArch64/RISC-V only)

-ffixed-x25

Unsupported

Reserves the x25 register (AArch64/RISC-V only)

-ffixed-x26

Unsupported

Reserves the x26 register (AArch64/RISC-V only)

-ffixed-x27

Unsupported

Reserves the x27 register (AArch64/RISC-V only)

-ffixed-x28

Unsupported

Reserves the x28 register (AArch64/RISC-V only)

-ffixed-x29

Unsupported

Reserves the x29 register (AArch64/RISC-V only)

-ffixed-x2

Unsupported

Reserves the x2 register (AArch64/RISC-V only)

-ffixed-x30

Unsupported

Reserves the x30 register (AArch64/RISC-V only)

-ffixed-x31

Unsupported

Reserves the x31 register (AArch64/RISC-V only)

-ffixed-x3

Unsupported

Reserves the x3 register (AArch64/RISC-V only)

-ffixed-x4

Unsupported

Reserves the x4 register (AArch64/RISC-V only)

-ffixed-x5

Unsupported

Reserves the x5 register (AArch64/RISC-V only)

-ffixed-x6

Unsupported

Reserves the x6 register (AArch64/RISC-V only)

-ffixed-x7

Unsupported

Reserves the x7 register (AArch64/RISC-V only)

-ffixed-x8

Unsupported

Reserves the x8 register (AArch64/RISC-V only)

-ffixed-x9

Unsupported

Reserves the x9 register (AArch64/RISC-V only)

-fforce-dwarf-frame

Supported

Mandatorily emits a debug frame section

-fforce-emit-vtables

Supported

Emits more virtual tables to improve devirtualization

-fforce-enable-int128

Supported

Enables support for int128_t type

-ffp-contract= <value>

Supported

Forms fused FP ops (e.g. FMAs): fast (everywhere) \ on (according to FP_CONTRACT pragma) \ off (never fuse). Default is “fast” for CUDA/HIP and “on” for others.

-ffp-exception-behavior= <value>

Supported

Specifies the exception behavior of floating-point operations

-ffp-model= <value>

Supported

Controls the semantics of floating-point calculations

-ffree-form

Supported

Enables free-form format for Fortran

-ffreestanding

Supported

Asserts the compilation to take place in a freestanding environment

-ffunc-args-alias

Supported

Allows the function arguments aliases (equivalent to ansi alias)

-ffunction-sections

Supported

Places each function in its section

-fglobal-isel

Supported

Enables the global instruction selector

-fgnu-keywords

Supported

Allows GNU-extension keywords regardless of a language standard

-fgnu-runtime

Unsupported

Generates output compatible with the standard GNU Objective-C runtime

-fgnu89-inline

Unsupported

Uses the gnu89 inline semantics

-fgnuc-version= <value>

Supported

Sets various macros to claim compatibility with the given GCC version (default is 4.2.1)

-fgpu-allow-device-init

Supported

Allows device-side init function in HIP

-fgpu-rdc

Supported

Generates relocatable device code, also known as separate compilation mode

-fhip-new-launch-api

Supported

Uses new kernel launching API for HIP

-fignore-exceptions

Supported

Enables support for ignoring exception handling constructs

-fimplicit-module-maps

Unsupported

Implicitly searches the file system for module map files

-finline-functions

Supported

Inlines suitable functions

-finline-hint-functions

Supported

Inlines functions that are (explicitly or implicitly) marked inline

-finstrument-function-entry-bare

Unsupported

Allows instrument function entry only after inlining, without arguments to the instrumentation call

-finstrument-functions-after-inlining

Unsupported

Similar to -finstrument-functions option but inserts the calls after inlining

-finstrument-functions

Unsupported

Generates calls to instrument function entry and exit

-fintegrated-as

Supported

Enables the integrated assembler

-fintegrated-cc1

Supported

Runs cc1 in-process

-fjump-tables

Supported

Uses jump tables for lowering switches

-fkeep-static-consts

Supported

Keeps static const variables if unused

-flax-vector-conversions= <value>

Supported

Enables implicit vector bit-casts

-flto-jobs= <value>

Unsupported

Controls the backend parallelism of -flto=thin (A default value of 0 means the number of threads will be derived from the number of CPUs detected.)

-flto= <value>

Unsupported

Sets LTO mode to either “full” or “thin”

-flto

Unsupported

Enables LTO in “full” mode

-fmacro-prefix-map= <value>

Supported

Remaps file source paths in predefined preprocessor macros

-fmath-errno

Supported

Requires math functions to indicate errors by setting errno

-fmax-tokens= <value>

Supported

Specifies max total number of preprocessed tokens for -Wmax-tokens

-fmax-type-align= <value>

Supported

Specifies the maximum alignment to enforce on pointers lacking an explicit alignment

-fmemory-profile

Supported

Enables heap memory profiling

-fmerge-all-constants

Supported

Allows merging of constants

-fmessage-length= <value>

Supported

Formats message diagnostics to fit within N columns

-fmodule-file=[ <name>=] <file>

Unsupported

Specifies the mapping of module name to precompiled module file. Loads a module file if name is omitted

-fmodule-map-file= <file>

Unsupported

Loads the specified module map file

-fmodule-name= <name>

Unsupported

Specifies the name of the module to build

-fmodules-cache-path= <directory>

Unsupported

Specifies the module cache path

-fmodules-decluse

Unsupported

Asserts declaration of modules used within a module

-fmodules-disable-diagnostic-validation

Unsupported

Disables validation of the diagnostic options when loading the module

-fmodules-ignore-macro= <value>

Unsupported

Ignores the definition of the specified macro when building and loading modules

-fmodules-prune-after= <seconds>

Unsupported

Specifies the interval (in seconds) after which a module file is to be considered unused

-fmodules-prune-interval= <seconds>

Unsupported

Specifies the interval (in seconds) between attempts to prune the module cache

-fmodules-search-all

Unsupported

Searches even non-imported modules to resolve references

-fmodules-strict-decluse

Unsupported

Similar to -fmodules-decluse option but requires all headers to be in the modules

-fmodules-ts

Unsupported

Enables support for the C++ Modules TS

-fmodules-user-build-path <directory>

Unsupported

Specifies the module user build path

-fmodules-validate-input-files-content

Supported

Validates PCM input files based on content if mtime differs

-fmodules-validate-once-per-build-session

Unsupported

Prohibits verification of input files for the modules if the module has been successfully validated or loaded during the current build session

-fmodules-validate-system-headers

Supported

Validates the system headers that a module depends on when loading the module

-fmodules

Unsupported

Enables the “modules” language feature

-fms-compatibility-version= <value>

Supported

Specifies the dot-separated value representing the Microsoft compiler version number to report in _MSC_VER (0 = do not define it (default))

-fms-compatibility

Supported

Enables full Microsoft Visual C++ compatibility

-fms-extensions

Supported

Accepts some non-standard constructs supported by the Microsoft compiler

-fmsc-version= <value>

Supported

Specifies the Microsoft compiler version number to report in _MSC_VER (0 = do not define it (default))

-fnew-alignment= <align>

Supported

Specifies the largest alignment guaranteed by “::operator new(size_t)”

-fno-addrsig

Supported

Prohibits emitting an address-significance table

-fno-allow-fortran-gnu-ext

Supported

Allows Fortran GNU extensions

-fno-assume-sane-operator-new

Supported

Prohibits the assumption that C++’s global operator new cannot alias any pointer

-fno-autolink

Supported

Disables generation of linker directives for automatic library linking

-fno-backslash

Supported

Allows treatment of backslash like any other character in character strings

-fno-builtin- <value>

Supported

Disables implicit built-in knowledge of a specific function

-fno-builtin

Supported

Disables implicit built-in knowledge of functions

-fno-c+±static-destructors

Supported

Disables C++ static destructor registration

-fno-char8_t

Supported

Disables C++ built-in type char8_t

-fno-color-diagnostics

Supported

Disables colors in diagnostics

-fno-common

Supported

Compiles common globals like normal definitions

-fno-complete-member-pointers

Supported

Eliminates the requirement for the member pointer base types to be complete if they would be significant under the Microsoft ABI

-fno-constant-cfstrings

Supported

Disables creation of CodeFoundation-type constant strings

-fno-coverage-mapping

Supported

Disables code coverage analysis

-fno-crash-diagnostics

Supported

Disables auto-generation of preprocessed source files and a script for reproduction during a Clang crash

-fno-cuda-approx-transcendentals

Unsupported

Eliminates the usage of approximate transcendental functions

-fno-debug-macro

Supported

Prohibits emitting the macro debug information

-fno-declspec

Unsupported

Disallows declspec as a keyword

-fno-delayed-template-parsing

Supported

Disables delayed template parsing

-fno-delete-null-pointer-checks

Supported

Prohibits the treatment of null pointers as undefined behavior

-fno-diagnostics-fixit-info

Supported

Prohibits including fixit information in diagnostics

-fno-digraphs

Supported

Disallows alternative token representations “ <:’, ‘:>’, ‘ <%’, ‘%>’, ‘%:’, ‘%:%:”

-fno-discard-value-names

Supported

Prohibits discarding value names in LLVM IR

-fno-dollars-in-identifiers

Supported

Disallows ‘$’ in identifiers

-fno-double-square-bracket-attributes

Supported

Disables ‘[[]]’ attributes in all C and C++ language modes

-fno-elide-constructors

Supported

Disables C++ copy constructor elision

-fno-elide-type

Supported

Prohibits eliding types when printing diagnostics

-fno-eliminate-unused-debug-types

Supported

Emits debug info for defined but unused types

-fno-exceptions

Supported

Disables support for exception handling

-fno-experimental-new-pass-manager

Supported

Disables an experimental new pass manager in LLVM

-fno-experimental-relative-c+±abi-vtables

Supported

Prohibits using the experimental C++ class ABI for classes with virtual tables

-fno-fine-grained-bitfield-accesses

Supported

Allows using large-integer access for consecutive bitfield runs

-fno-fixed-form

Supported

Disables fixed-form format for Fortran

-fno-fixed-point

Supported

Disables fixed point types

-fno-force-enable-int128

Supported

Disables support for int128_t type

-fno-fortran-main

Supported

Prohibits linking in Fortran main

-fno-free-form

Supported

Disables free-form format for Fortran

-fno-func-args-alias

Supported

Allows the function argument alias (equivalent to ansi alias)

-fno-global-isel

Supported

Disables the global instruction selector

-fno-gnu-inline-asm

Supported

Disables GNU style inline asm

-fno-gpu-allow-device-init

Supported

Disallows device-side init function in HIP

-fno-hip-new-launch-api

Supported

Disallows new kernel launching API for HIP

-fno-integrated-as

Supported

Disables the integrated assembler

-fno-integrated-cc1

Supported

Spawns a separate process for each cc1

-fno-jump-tables

Supported

Disallows jump tables for lowering switches

-fno-keep-static-consts

Supported

Prohibits keeping static const variables if unused

-fno-lto

Supported

Disables LTO mode (default)

-fno-memory-profile

Supported

Disables heap memory profiling

-fno-merge-all-constants

Supported

Disallows merging of constants

-fno-no-access-control

Supported

Disables C++ access control

-fno-objc-infer-related-result-type

Supported

Prohibits inferring Objective-C related result type based on the method family

-fno-operator-names

Supported

Disallows treatment of C++ operator name keywords as synonyms for operators

-fno-pch-codegen

Supported

Disallows code-generation for uses of the PCH that assumes building an explicit object file for the PCH

-fno-pch-debuginfo

Supported

Prohibits generation of debug info for types in an object file built from this PCH or elsewhere

-fno-plt

Supported

Asserts usage of GOT indirection instead of PLT to make external function calls (x86 only)

-fno-preserve-as-comments

Supported

Prohibits preserving comments in inline assembly

-fno-profile-generate

Supported

Disables generation of profile instrumentation

-fno-profile-instr-generate

Supported

Disables generation of profile instrumentation

-fno-profile-instr-use

Supported

Disables usage of instrumentation data for profile-guided optimization

-fno-register-global-dtors-with-atexit

Supported

Disallows usage of atexit or __cxa_atexit to register global destructors

-fno-rtlib-add-rpath

Supported

Prohibits adding -rpath with architecture-specific resource directory to the linker flags

-fno-rtti-data

Supported

Disables generation of RTTI data

-fno-rtti

Supported

Disables generation of rtti information

-fno-sanitize-address-poison-custom-array-cookie

Supported on Host only

Disables poisoning of array cookies when using custom operator new[] in AddressSanitizer

-fno-sanitize-address-use-after-scope

Supported on Host only

Disables use-after-scope detection in AddressSanitizer

-fno-sanitize-address-use-odr-indicator

Supported on Host only

Disables ODR indicator globals

-fno-sanitize-blacklist

Supported on Host only

Prohibits using blacklist file for sanitizers

-fno-sanitize-cfi-canonical-jump-tables

Supported on Host only

Prohibits making the jump table addresses canonical in the symbol table

-fno-sanitize-cfi-cross-dso

Supported on Host only

Disables control flow integrity (CFI) checks for cross-DSO calls

-fno-sanitize-coverage= <value>

Supported on Host only

Disables specified features of coverage instrumentation for Sanitizers

-fno-sanitize-memory-track-origins

Supported on Host only

Disables origins tracking in MemorySanitizer

-fno-sanitize-memory-use-after-dtor

Supported on Host only

Disables use-after-destroy detection in MemorySanitizer

-fno-sanitize-recover= <value>

Supported on Host only

Disables recovery for specified sanitizers

-fno-sanitize-stats

Supported on Host only

Disables sanitizer statistics gathering

-fno-sanitize-thread-atomics

Supported on Host only

Disables atomic operations instrumentation in ThreadSanitizer

-fno-sanitize-thread-func-entry-exit

Supported on Host only

Disables function entry/exit instrumentation in ThreadSanitizer

-fno-sanitize-thread-memory-access

Supported on Host only

Disables memory access instrumentation in ThreadSanitizer

-fno-sanitize-trap= <value>

Supported on Host only

Disables trapping for specified sanitizers

-fno-sanitize-trap

Supported on Host only

Disables trapping for all sanitizers

-fno-short-wchar

Supported

Forces wchar_t to be an unsigned int

-fno-show-column

Supported

Prohibits including column number on diagnostics

-fno-show-source-location

Supported

Prohibits including source location information with diagnostics

-fno-signed-char

Supported

char is unsigned

-fno-signed-zeros

Supported

Allows optimizations that ignore the sign of floating point zeros

-fno-spell-checking

Supported

Disables spell-check

-fno-split-machine-functions

Supported

Disables late function splitting using profile information (x86 ELF)

-fno-stack-clash-protection

Supported

Disables stack clash protection

-fno-stack-protector

Supported

Disables the use of stack protectors

-fno-standalone-debug

Supported

Limits debug information produced to reduce size of debug binary

-fno-strict-float-cast-overflow

Supported

Relaxes language rules and tries to match the behavior of the target’s native float-to-int conversion instructions

-fno-strict-return

Supported

Prohibits treating the control flow paths that fall off the end of a non-void function as unreachable

-fno-sycl

Unsupported

Disables SYCL kernels compilation for device

-fno-temp-file

Supported

Asserts direct creation of compilation output files. This may lead to incorrect incremental builds if the compiler crashes.

-fno-threadsafe-statics

Supported

Prohibits emitting code to make initialization of local statics thread safe

-fno-trigraphs

Supported

Prohibits processing trigraph sequences

-fno-unique-section-names

Supported

Prohibits the usage of unique names for text and data sections

-fno-unroll-loops

Supported

Turns off the loop unroller

-fno-use-cxa-atexit

Supported

Prohibits the usage of __cxa_atexit for calling destructors

-fno-use-flang-math-libs

Supported

Asserts the usage of Flang internal runtime math library instead of LLVM math intrinsics

-fno-use-init-array

Supported

Asserts the usage of .ctors/.dtors instead of .init_array/.fini_array

-fno-visibility-inlines-hidden-static-local-var

Supported

Disables -fvisibility-inlines-hidden-static-local-var (This is the default on non-darwin targets.)

-fno-xray-function-index

Unsupported

Allows omitting function index section at the expense of single-function patching performance

-fno-zero-initialized-in-bss

Supported

Prohibits placing zero initialized data in BSS

-fobjc-arc-exceptions

Unsupported

Asserts using EH-safe code when synthesizing retains and releases in -fobjc-arc

-fobjc-arc

Unsupported

Synthesizes retain and release calls for Objective-C pointers

-fobjc-exceptions

Unsupported

Enables Objective-C exceptions

-fobjc-runtime= <value>

Unsupported

Specifies the target Objective-C runtime kind and version

-fobjc-weak

Unsupported

Enables ARC-style weak references in Objective-C

-fopenmp-simd

Unsupported

Emits OpenMP code only for SIMD-based constructs

-fopenmp-targets= <value>

Unsupported

Specifies a comma-separated list of triples OpenMP offloading targets to be supported

-fopenmp

Unsupported

Parses OpenMP pragmas and generates parallel code

-foptimization-record-file= <file>

Supported

Specifies the output name of the file containing the optimization remarks. Implies -fsave-optimization-record. On Darwin platforms, this cannot be used with multiple -arch <arch> options.

-foptimization-record-passes= <regex>

Supported

Exclusively allows the inclusion of passes that match a specified regular expression in the generated optimization record (By default, include all passes.)

-forder-file-instrumentation

Supported

Generates instrumented code to collect order file into default.profraw file (overridden by ‘=’ form of option or LLVM_PROFILE_FILE env var)

-fpack-struct= <value>

Unsupported

Specifies the default maximum struct packing alignment

-fpascal-strings

Supported

Recognizes and constructs Pascal-style string literals

-fpass-plugin= <dsopath>

Supported

Loads pass plugin from a dynamic shared object file (only with new pass manager)

-fpatchable-function-entry= <N,M>

Supported

Generates M NOPs before function entry and N-M NOPs after function entry

-fpcc-struct-return

Unsupported

Overrides the default ABI to return all structs on the stack

-fpch-codegen

Supported

Generates code for using this PCH that assumes building an explicit object file for the PCH

-fpch-debuginfo

Supported

Generates debug info for types exclusively in an object file built from this PCH

-fpch-instantiate-templates

Supported

Instantiates templates already while building a PCH

-fpch-validate-input-files-content

Supported

Validates PCH input files based on the content if mtime differs

-fplugin= <dsopath>

Supported

Loads the named plugin (dynamic shared object)

-fprebuilt-module-path= <directory>

Unsupported

Specifies the prebuilt module path

-fprofile-exclude-files= <value>

Unsupported

Exclusively instruments those functions from files where names do not match all the regexes separated by a semicolon

-fprofile-filter-files= <value>

Unsupported

Exclusively instruments those functions from files where names match any regex separated by a semicolon

-fprofile-generate= <directory>

Unsupported

Generates instrumented code to collect execution counts into <directory>/default.profraw (overridden by LLVM_PROFILE_FILE env var)

-fprofile-generate

Unsupported

Generates instrumented code to collect execution counts into default.profraw (overridden by LLVM_PROFILE_FILE env var)

-fprofile-instr-generate= <file>

Unsupported

Generates instrumented code to collect execution counts into <file> (overridden by LLVM_PROFILE_FILE env var)

-fprofile-instr-generate

Unsupported

Generates instrumented code to collect execution counts into default.profraw file (overridden by ‘=’ form of option or LLVM_PROFILE_FILE env var)

-fprofile-instr-use= <value>

Unsupported

Uses instrumentation data for profile-guided optimization

-fprofile-remapping-file= <file>

Unsupported

Uses the remappings described in <file> to match the profile data against the names in the program

-fprofile-sample-accurate

Unsupported

Specifies that the sample profile is accurate

-fprofile-sample-use= <value>

Unsupported

Enables sample-based profile-guided optimizations

-fprofile-use= <pathname>

Unsupported

Uses instrumentation data for profile-guided optimization. If pathname is a directory, it reads from <pathname>/default.profdata. Otherwise, it reads from file <pathname>.

-freciprocal-math

Supported

Allows division operations to be reassociated

-freg-struct-return

Unsupported

Overrides the default ABI to return small structs in registers

-fregister-global-dtors-with-atexit

Supported

Uses atexit or __cxa_atexit to register global destructors

-frelaxed-template-template-args

Supported

Enables C++17 relaxed template argument matching

-freroll-loops

Supported

Turns on loop reroller

-fropi

Unsupported

Generates read-only position independent code (ARM only)

-frtlib-add-rpath

Supported

Adds -rpath with architecture-specific resource directory to the linker flags

-frwpi

Unsupported

Generates read-write position-independent code (ARM only)

-fsanitize-address-field-padding= <value>

Supported on Host only

Specifies the level of field padding for AddressSanitizer

-fsanitize-address-globals-dead-stripping

Supported on Host only

Enables linker dead stripping of globals in AddressSanitizer

-fsanitize-address-poison-custom-array-cookie

Supported on Host only

Enables poisoning of array cookies when using custom operator new[] in AddressSanitizer

-fsanitize-address-use-after-scope

Supported on Host only

Enables use-after-scope detection in AddressSanitizer

-fsanitize-address-use-odr-indicator

Supported on Host only

Enables ODR indicator globals to avoid false ODR violation reports in partially sanitized programs at the cost of an increase in binary size

-fsanitize-blacklist= <value>

Supported on Host only

Specifies the path to blacklisted files for sanitizers

-fsanitize-cfi-canonical-jump-tables

Supported on Host only

Makes the jump table addresses canonical in the symbol table

-fsanitize-cfi-cross-dso

Supported on Host only

Enables control flow integrity (CFI) checks for cross-DSO calls

-fsanitize-cfi-icall-generalize-pointers

Supported on Host only

Generalizes pointers in CFI indirect call type signature checks

-fsanitize-coverage-allowlist= <value>

Supported on Host only

Restricts sanitizer coverage instrumentation exclusively to modules and functions that match the provided special case list, except the blocked ones

-fsanitize-coverage-blacklist= <value>

Supported on Host only

Deprecated; use -fsanitize-coverage-blocklist= instead.

-fsanitize-coverage-blocklist= <value>

Supported on Host only

Disables sanitizer coverage instrumentation for modules and functions that match the provided special case list, even the allowed ones

-fsanitize-coverage-whitelist= <value>

Supported on Host only

Deprecated; use -fsanitize-coverage-allowlist= instead.

-fsanitize-coverage= <value>

Supported on Host only

Specifies the type of coverage instrumentation for Sanitizers

-fsanitize-hwaddress-abi= <value>

Supported on Host only

Selects the HWAddressSanitizer ABI to target (interceptor or platform, default interceptor). This option is currently unused.

-fsanitize-memory-track-origins= <value>

Supported on Host only

Enables origins tracking in MemorySanitizer

-fsanitize-memory-track-origins

Supported on Host only

Enables origins tracking in MemorySanitizer

-fsanitize-memory-use-after-dtor

Supported on Host only

Enables use-after-destroy detection in MemorySanitizer

-fsanitize-recover= <value>

Supported on Host only

Enables recovery for specified sanitizers

-fsanitize-stats

Supported on Host only

Enables sanitizer statistics gathering

-fsanitize-system-blacklist= <value>

Supported on Host only

Specifies the path to system blacklist files for sanitizers

-fsanitize-thread-atomics

Supported on Host only

Enables atomic operations instrumentation in ThreadSanitizer (default)

-fsanitize-thread-func-entry-exit

Supported on Host only

Enables function entry/exit instrumentation in ThreadSanitizer (default)

-fsanitize-thread-memory-access

Supported on Host only

Enables memory access instrumentation in ThreadSanitizer (default)

-fsanitize-trap= <value>

Supported on Host only

Enables trapping for specified sanitizers

-fsanitize-trap

Supported on Host only

Enables trapping for all sanitizers

-fsanitize-undefined-strip-path-components= <number>

Supported on Host only

Strips (or keeps only, if negative) the given number of path components when emitting check metadata

-fsanitize= <check>

Supported on Host only

Turns on runtime checks for various forms of undefined or suspicious behavior. See user manual for available checks.

-fsave-optimization-record= <format>

Supported

Generates an optimization record file in the specified format

-fsave-optimization-record

Supported

Generates a YAML optimization record file

-fseh-exceptions

Supported

Uses SEH style exceptions

-fshort-enums

Supported

Allocates to an enum type only as many bytes as it needs for the declared range of possible values

-fshort-wchar

Unsupported

Forces wchar_t to be a short unsigned int

-fshow-overloads= <value>

Supported

Specifies which overload candidates are shown when overload resolution fails. Values = best\all; default value = “all”

-fsigned-char

Supported

Asserts that the char is signed

-fsized-deallocation

Supported

Enables C++14 sized global deallocation functions

-fsjlj-exceptions

Supported

Uses SjLj style exceptions

-fslp-vectorize

Supported

Enables the superword-level parallelism vectorization passes

-fsplit-dwarf-inlining

Unsupported

Provides minimal debug info in the object/executable to facilitate online symbolication/stack traces in the absence of .dwo/.dwp files when using Split DWARF

-fsplit-lto-unit

Unsupported

Enables splitting of the LTO unit

-fsplit-machine-functions

Supported

Enables late function splitting using profile information (x86 ELF)

-fstack-clash-protection

Supported

Enables stack clash protection

-fstack-protector-all

Unsupported

Enables stack protectors for all functions

-fstack-protector-strong

Unsupported

Enables stack protectors for some functions vulnerable to stack smashing. Compared to -fstack-protector, this uses a stronger heuristic that includes functions containing arrays of any size (and any type), as well as any calls to allocate or the taking of an address from a local variable.

-fstack-protector

Unsupported

Enables stack protectors for some functions vulnerable to stack smashing. This uses a loose heuristic that considers the functions to be vulnerable if they contain a char (or 8bit integer) array or constant-size calls to alloca, which are of greater size than ssp-buffer-size (default: 8 bytes). All variable-size calls to alloca are considered vulnerable. A function with a stack protector has a guard value added to the stack frame that is checked on function exit. The guard value must be positioned in the stack frame such that a buffer overflow from a vulnerable variable will overwrite the guard value before overwriting the function’s return address. The reference stack guard value is stored in a global variable.

-fstack-size-section

Supported

Emits section containing metadata on function stack sizes

-fstandalone-debug

Supported

Emits full debug info for all types used by the program

-fstrict-enums

Supported

Enables optimizations based on the strict definition of an enum’s value range

-fstrict-float-cast-overflow

Supported

Assumes the overflowing float-to-int casts to be undefined (default)

-fstrict-vtable-pointers

Supported

Enables optimizations based on the strict rules for overwriting polymorphic C++ objects

-fsycl

Unsupported

Enables SYCL kernels compilation for device

-fsystem-module

u

Builds this module as a system module. Only used with -emit-module

-fthin-link-bitcode= <value>

Supported

Writes minimized bitcode to <file> for the ThinLTO thin link only

-fthinlto-index= <value>

Unsupported

Performs ThinLTO import using the provided function summary index

-ftime-trace-granularity= <value>

Supported

Specifies the minimum time granularity (in microseconds) traced by time profiler

-ftime-trace

Supported

Turns on time profiler. Generates JSON file based on output filename

-ftrap-function= <value>

Unsupported

Issues call to specified function rather than a trap instruction

-ftrapv-handler= <function name>

Unsupported

Specifies the function to be called on overflow

-ftrapv

Supported

Traps on integer overflow

-ftrigraphs

Supported

Processes trigraph sequences

-ftrivial-auto-var-init-stop-after= <value>

Supported

Stops initializing trivial automatic stack variables after the specified number of instances

-ftrivial-auto-var-init= <value>

Supported

Initializes trivial automatic stack variables. Values: uninitialized (default) / pattern

-funique-basic-block-section-names

Supported

Uses unique names for basic block sections (ELF only)

-funique-internal-linkage-names

Supported

Makes the Internal Linkage Symbol names unique by appending the MD5 hash of the module path

-funroll-loops

Supported

Turns on loop unroller

-fuse-flang-math-libs

Supported

Uses Flang internal runtime math library instead of LLVM math intrinsics

-fuse-line-directives

Supported

Uses #line in preprocessed output

-fvalidate-ast-input-files-content

Supported

Computes and stores the hash of input files used to build an AST. Files with mismatching mtimes are considered valid if both have identical contents.

-fveclib= <value>

Unsupported

Uses the given vector functions library

-fvectorize

Unsupported

Enables the loop vectorization passes

-fverbose-asm

Supported

Generates verbose assembly output

-fvirtual-function-elimination

Supported

Enables dead virtual function elimination optimization. Requires -flto=full

-fvisibility-global-new-delete-hidden

Supported

Marks the visibility of global C++ operators “new” and “delete” as hidden

-fvisibility-inlines-hidden-static-local-var

Supported

Marks the visibility of static variables in inline C++ member functions as hidden by default when -fvisibility-inlines-hidden is enabled

-fvisibility-inlines-hidden

Supported

Marks the visibility of inline C++ member functions as hidden by default

-fvisibility-ms-compat

Supported

Marks the visibility of global types as default and global functions and variables as hidden by default

-fvisibility= <value>

Supported

Sets the default symbol visibility for all global declarations to the specified value

-fwasm-exceptions

Unsupported

Uses WebAssembly style exceptions

-fwhole-program-vtables

Unsupported

Enables whole program vtable optimization. Requires -flto

-fwrapv

Supported

Treats signed integer overflow as two’s complement

-fwritable-strings

Supported

Stores string literals as writable data

-fxray-always-emit-customevents

Unsupported

Mandates emitting __xray_customevent(…) calls even if the containing function is not always instrumented

-fxray-always-emit-typedevents

Unsupported

Mandates emitting __xray_typedevent(…) calls even if the containing function is not always instrumented

-fxray-always-instrument= <value>

Unsupported

Deprecated: Specifies the filename defining the whitelist for imbuing the “always instrument” XRay attribute

-fxray-attr-list= <value>

Unsupported

Specifies the filename defining the list of functions/types for imbuing XRay attributes

-fxray-ignore-loops

Unsupported

Prohibits instrumenting functions with loops unless they also meet the minimum function size

-fxray-instruction-threshold= <value>

Unsupported

Sets the minimum function size to instrument with Xray

-fxray-instrumentation-bundle= <value>

Unsupported

Specifies which XRay instrumentation points to emit. Values: all/ none/ function-entry/ function-exit/ function/ custom. Default is “all,” and “function” includes both “function-entry” and “function-exit.”

-fxray-instrument

Unsupported

Generates XRay instrumentation sleds on function entry and exit

-fxray-link-deps

Unsupported

Informs Clang to add the link dependencies for XRay

-fxray-modes= <value>

Unsupported

Specifies the list of modes to link in by default into the XRay instrumented binaries

-fxray-never-instrument= <value>

Unsupported

Deprecated: Specifies the filename defining the whitelist for imbuing the “never instrument” XRay attribute

-fzvector

Supported

Enables System z vector language extension

-F <value>

Unsupported

Adds directory to the framework include search path

–gcc-toolchain= <value>

Supported

Uses the gcc toolchain at the given directory

-gcodeview-ghash

Supported

Emits type record hashes in a .debug$H section

-gcodeview

Supported

Generates code view debug information

-gdwarf-2

Supported

Generates source-level debug information with dwarf version 2

-gdwarf-3

Supported

Generates source-level debug information with dwarf version 3

-gdwarf-4

Supported

Generates source-level debug information with dwarf version 4

-gdwarf-5

Supported

Generates source-level debug information with dwarf version 5

-gdwarf

Supported

Generates source-level debug information with the default DWARF version

-gembed-source

Supported

Embeds source text in DWARF debug sections

-gline-directives-only

Supported

Emits debug line info directives only.

-gline-tables-only

Supported

Emits debug line number tables only.

-gmodules

Supported

Generates debug info with external references to clang modules or precompiled headers

-gno-embed-source

Supported

Restores the default behavior of not embedding the source text in DWARF debug sections

-gno-inline-line-tables

Supported

Prohibits emitting inline line tables

–gpu-max-threads-per-block= <value>

Supported

Specifies the default max threads per block for kernel launch bounds for HIP

-gsplit-dwarf= <value>

Supported

Sets DWARF fission mode to values: “split”/ “single”

-gz= <value>

Supported

Specifies DWARF debug section’s compression type

-gz

Supported

Shows DWARF debug section”s compression type

-G <size>

Unsupported

Puts objects of maximum <size> bytes into small data section (MIPS / Hexagon)

-g

Supported

Generates source-level debug information

–help-hidden

Supported

Displays help for hidden options

-help

Supported

Displays available options

–hip-device-lib= <value>

Supported

Specifies the HIP device library

–hip-link

Supported

Links clang-offload-bundler bundles for HIP

–hip-version= <value>

Supported

Allows specification of HIP version in the format: major/minor/patch

-H

Supported

Shows header “includes” and nesting depth

-I-

Supported

Restricts all prior -I flags to double-quoted inclusion and removes the current directory from include path

-ibuiltininc

Supported

Enables built-in #include directories even when -nostdinc is used before or after -ibuiltininc. Using -nobuiltininc after the option disables it

-idirafter <value>

Supported

Adds the directory to AFTER include search path

-iframeworkwithsysroot <directory>

Unsupported

Adds the directory to SYSTEM framework search path; absolute paths are relative to -isysroot

-iframework <value>

Unsupported

Adds the directory to SYSTEM framework search path

-imacros <file>

Supported

Specifies the file containing macros to be included before parsing

-include-pch <file>

Supported

Includes the specified precompiled header file

-include <file>

Supported

Includes the specified file before parsing

-index-header-map

Supported

Makes the next included directory (-I or -F) an indexer header map

-iprefix <dir>

Supported

Sets the -iwithprefix/-iwithprefixbefore prefix

-iquote <directory>

Supported

Adds the directory to QUOTE include search path

-isysroot <dir>

Supported

Sets the system root directory (usually /)

-isystem-after <directory>

Supported

Adds the directory to end of the SYSTEM include search path

-isystem <directory>

Supported

Adds the directory to SYSTEM include search path

-ivfsoverlay <value>

Supported

Overlays the virtual file system described by the specified file over the real file system

-iwithprefixbefore <dir>

Supported

Sets the directory to include search path with prefix

-iwithprefix <dir>

Supported

Sets the directory to SYSTEM include search path with prefix

-iwithsysroot <directory>

Supported

Adds directory to SYSTEM include search path; absolute paths are relative to -isysroot

-I <dir>

Supported

Adds directory to include search path. If there are multiple -I options, these directories are searched in the order they are given before the standard system directories are searched. If the same directory is in the SYSTEM include search paths, for example, if also specified with -isystem, the -I option is ignored.

–libomptarget-nvptx-path= <value>

Unsupported

Specifies path to libomptarget-nvptx libraries

-L <dir>

Supported

Adds directory to library search path

-mabicalls

Unsupported

Enables SVR4-style position-independent code (Mips only)

-maix-struct-return

Unsupported

Returns all structs in memory (PPC32 only)

-malign-branch-boundary= <value>

Supported

Specifies the boundary’s size to align branches

-malign-branch= <value>

Supported

Specifies the types of branches to align

-malign-double

Supported

Aligns doubles to two words in structs (x86 only)

-Mallocatable= <value>

Unsupported

Provides semantics for assignments to allocatables. Value: F03/ F95.

-mbackchain

Unsupported

Links stack frames through backchain on System Z

-mbranch-protection= <value>

Unsupported

Enforces targets of indirect branches and function returns

-mbranches-within-32B-boundaries

Supported

Aligns selected branches (fused, jcc, jmp) within 32-byte boundary

-mcmodel=medany

Unsupported

Equivalent to -mcmodel=medium, compatible with RISC-V gcc

-mcmodel=medlow

Unsupported

Equivalent to -mcmodel=small, compatible with RISC-V gcc

-mcmse

Unsupported

Allows use of CMSE (Armv8-M Security Extensions)

-mcode-object-v3

Supported

Legacy option to specify code object ABI V2 (-mnocode-object-v3) or V3 (-mcode-object-v3) (AMDGPU only)

-mcode-object-version= <version>

Supported

Specifies code object ABI version. Default value: 4. (AMDGPU only).

-mcrc

Unsupported

Allows use of CRC instructions (ARM/Mips only)

-mcumode

Supported

Specifies CU (-mcumode) or WGP (-mno-cumode) wavefront execution mode (AMDGPU only)

-mdouble= <value>

Supported

Forces double to be 32 bits or 64 bits

-MD

Supported

Writes a depfile containing user and system headers

-meabi <value>

Supported

Sets EABI type. Value: 4/ 5/ gnu. Default depends on triple

-membedded-data

Unsupported

Places constants in the .rodata section instead of the .sdata section even if they meet the -G <size> threshold (MIPS)

-menable-experimental-extensions

Unsupported

Enables usage of experimental RISC-V extensions.

-mexec-model= <value>

Unsupported

Specifies the execution model (WebAssembly only)

-mexecute-only

Unsupported

Disallows generation of data access to code sections (ARM only)

-mextern-sdata

Unsupported

Assumes externally defined data to be in the small data if it meets the -G <size> threshold (MIPS)

-mfentry

Unsupported

Inserts calls to fentry at function entry (x86/SystemZ only)

-mfix-cortex-a53-835769

Unsupported

Workaround Cortex-A53 erratum 835769 (AArch64 only)

0

Unsupported

Asserts usage of 32-bit floating point registers (MIPS only)

0

Unsupported

Asserts usage of 64-bit floating point registers (MIPS only)

-MF <file>

Supported

Writes depfile output from -MMD, -MD, -MM, or -M to <file>

-mgeneral-regs-only

Unsupported

Generates code that exclusively uses the general-purpose registers (AArch64 only)

-mglobal-merge

Supported

Enables merging of globals

-mgpopt

Unsupported

Allows using GP relative accesses for symbols known to be in a small data section (MIPS)

-MG

Supported

Adds missing headers to depfile

-mharden-sls= <value>

Unsupported

Sets straight-line speculation hardening scope

-mhvx-length= <value>

Unsupported

Sets Hexagon Vector Length

-mhvx= <value>

Unsupported

Sets Hexagon Vector eXtensions

-mhvx

Unsupported

Enables Hexagon Vector eXtensions

-miamcu

Unsupported

Allows using Intel MCU ABI

–migrate

Unsupported

Runs the migrator

-mincremental-linker-compatible

Supported

(integrated-as) Emits an object file that can be used with an incremental linker

-mindirect-jump= <value>

Unsupported

Changes indirect jump instructions to inhibit speculation

-Minform= <value>

Supported

Sets error level of messages to display

-mios-version-min= <value>

Unsupported

Sets iOS deployment target

-MJ <value>

Unsupported

Writes a compilation database entry per input

-mllvm <value>

Supported

Specifies additional arguments to forward to LLVM’s option processing

-mlocal-sdata

Unsupported

Extends the -G behavior to object local data (MIPS)

-mlong-calls

Supported

Generates branches with extended addressability, usually via indirect jumps

-mlong-double-128

Supported on Host only

Forces long double to be 128 bits

-mlong-double-64

Supported

Forces long double to be 64 bits

-mlong-double-80

Supported on Host only

Forces long double to be 80 bits, padded to 128 bits for storage

-mlvi-cfi

Supported on Host only

Enables only control-flow mitigations for Load Value Injection (LVI)

-mlvi-hardening

Supported on Host only

Enables all mitigations for Load Value Injection (LVI)

-mmacosx-version-min= <value>

Unsupported

Sets Mac OS X deployment target

-mmadd4

Supported

Enables the generation of 4-operand madd.s, madd.d, and related instructions

-mmark-bti-property

Unsupported

Adds .note.gnu.property with BTI to assembly files (AArch64 only)

-MMD

Supported

Writes a depfile containing user headers

-mmemops

Supported

Enables generation of memop instructions

-mms-bitfields

Unsupported

Sets the default structure layout to be compatible with the Microsoft compiler standard

-mmsa

Unsupported

Enables MSA ASE (MIPS only)

-mmt

Unsupported

Enables MT ASE (MIPS only)

-MM

Supported

Similar to -MMD but also implies -E and writes to stdout by default

-mno-abicalls

Unsupported

Disables SVR4-style position-independent code (Mips only)

-mno-crc

Unsupported

Disallows use of CRC instructions (MIPS only)

-mno-embedded-data

Unsupported

Prohibits placing constants in the .rodata section instead of the .sdata if they meet the -G <size> threshold (MIPS)

-mno-execute-only

Unsupported

Allows generation of data access to code sections (ARM only)

-mno-extern-sdata

Unsupported

Prohibits assuming the externally defined data to be in the small data if it meets the -G <size> threshold (MIPS)

-mno-fix-cortex-a53-835769

Unsupported

Disallows workaround Cortex-A53 erratum 835769 (AArch64 only)

-mno-global-merge

Supported

Disables merging of globals

-mno-gpopt

Unsupported

Prohibits using GP relative accesses for symbols known to be in a small data section (MIPS)

-mno-hvx

Unsupported

Disables Hexagon Vector eXtensions.

-mno-implicit-float

Supported

Prohibits generating implicit floating-point instructions

-mno-incremental-linker-compatible

Supported

(integrated-as) Emits an object file that cannot be used with an incremental linker

-mno-local-sdata

Unsupported

Prohibits extending the -G behavior to object local data (MIPS)

-mno-long-calls

Supported

Restores the default behavior of not generating long calls

-mno-lvi-cfi

Supported on Host only

Disables control-flow mitigations for Load Value Injection (LVI)

-mno-lvi-hardening

Supported on Host only

Disables mitigations for Load Value Injection (LVI)

-mno-madd4

Supported

Disables the generation of 4-operand madd.s, madd.d, and related instructions

-mno-memops

Supported

Disables the generation of memop instructions

-mno-movt

Supported

Disallows usage of movt/movw pairs (ARM only)

-mno-ms-bitfields

Supported

Prohibits setting the default structure layout to be compatible with the Microsoft compiler standard

-mno-msa

Unsupported

Disables MSA ASE (MIPS only)

-mno-mt

Unsupported

Disables MT ASE (MIPS only)

-mno-neg-immediates

Supported

Disallows converting instructions with negative immediates to their negation or inversion

-mno-nvj

Supported

Disables generation of new-value jumps

-mno-nvs

Supported

Disables generation of new-value stores

-mno-outline

Unsupported

Disables function outlining (AArch64 only)

-mno-packets

Supported

Disables generation of instruction packets

-mno-relax

Supported

Disables linker relaxation

-mno-restrict-it

Unsupported

Allows generation of deprecated IT blocks for ARMv8. It is off by default for ARMv8 Thumb mode

-mno-save-restore

Unsupported

Disables usage of library calls for save and restore

-mno-seses

Unsupported

Disables speculative execution side-effect suppression (SESES)

-mno-stack-arg-probe

Supported

Disables stack probes which are enabled by default

-mno-tls-direct-seg-refs

Supported

Disables direct TLS access through segment registers

-mno-unaligned-access

Unsupported

Forces all memory accesses to be aligned (AArch32/AArch64 only)

-mno-wavefrontsize64

Supported

Asserts wavefront size to 32 (AMDGPU only)

-mnocrc

Unsupported

Disallows usage of CRC instructions (ARM only)

-mnop-mcount

Supported

Generates mcount/__fentry__ calls as nops. To activate, they need to be patched in

-mnvj

Supported

Enables generation of new-value jumps

-mnvs

Supported

Enables generation of new-value stores

-module-dependency-dir <value>

Unsupported

Specifies directory for dumping module dependencies

-module-file-info

Unsupported

Provides information about a particular module file

-momit-leaf-frame-pointer

Supported

Omits frame pointer setup for leaf functions

-moutline

Unsupported

Enables function outlining (AArch64 only)

-mpacked-stack

Unsupported

Asserts the usage of packed stack layout (SystemZ only)

-mpackets

Supported

Enables generation of instruction packets

-mpad-max-prefix-size= <value>

Supported

Specifies maximum number of prefixes to use for padding

-mpie-copy-relocations

Supported

Asserts the usage of copy relocations support for PIE builds

-mprefer-vector-width= <value>

Unsupported

Specifies preferred vector width for auto-vectorization. Default value: “none,” which allows target specific decisions.

-MP

Supported

Creates phony target for each dependency (other than the main file)

-mqdsp6-compat

Unsupported

Enables hexagon-qdsp6 backward compatibility

-MQ <value>

Supported

Specifies the name of the main file output to quote in depfile

-mrecord-mcount

Supported

Generates a __mcount_loc section entry for each fentry call

-mrelax-all

Supported

(integrated-as) Relaxes all machine instructions

-mrelax

Supported

Enables linker relaxation

-mrestrict-it

Unsupported

Disallows generation of deprecated IT blocks for ARMv8. It is on by default for ARMv8 Thumb mode.

-mrtd

Unsupported

Makes StdCall calling the default convention

-msave-restore

Unsupported

Enables using library calls for save and restore

-mseses

Unsupported

Enables speculative execution side effect suppression (SESES). Includes LVI control flow integrity mitigations.

-msign-return-address= <value>

Unsupported

Specifies the return address signing scope

-msmall-data-limit= <value>

Supported

Puts global and static data smaller than the specified limit into a special section

-msoft-float

Supported

Uses software floating point

-msram-ecc

Supported

Legacy option to specify SRAM ECC mode (AMDGPU only). Should use –offload-arch with sramecc+ instead.

-mstack-alignment= <value>

Unsupported

Sets the stack alignment

-mstack-arg-probe

Unsupported

Enables stack probes

-mstack-probe-size= <value>

Unsupported

Sets the stack probe size

-mstackrealign

Unsupported

Forces realign the stack at entry on every function

-msve-vector-bits= <value>

Unsupported

Specifies the size in bits of an SVE vector register. Defaults to the vector length agnostic value of “scalable” (AArch64 only).

-msvr4-struct-return

Unsupported

Returns small structs in registers (PPC32 only)

-mthread-model <value>

Supported

Specifies the thread model to use. Value: posix/single. Default: posix.

-mtls-direct-seg-refs

Supported

Enables direct TLS access through segment registers (default)

-mtls-size= <value>

Unsupported

Specifies the bit size of immediate TLS offsets (AArch64 ELF only). Value: 12 (for 4KB) \ 24 (for 16MB, default) \ 32 (for 4GB) \ 48 (for 256TB, needs -mcmodel=large).

-mtp= <value>

Unsupported

Specifies the thread pointer access method. Value: AArch32/AArch64 only

-mtune= <value>

Supported on Host only

Supported on X86 only. Otherwise accepted for compatibility with GCC.

-MT <value>

Unsupported

Specifies the name of main file output in depfile

-munaligned-access

Unsupported

Allows memory accesses to be unaligned (AArch32/AArch64 only)

-MV

Supported

Uses NMake/Jom format for the depfile

-mwavefrontsize64

Supported

Asserts wavefront size of 64 (AMDGPU only)

-mxnack

Supported

Legacy option to specify XNACK mode (AMDGPU only). Use –offload-arch with :xnack+ instead.

-M

Supported

Similar to -MD but also implies -E and writes to stdout by default

–no-cuda-include-ptx= <value>

Supported

Prohibits including PTX for the specified GPU architecture (e.g. sm_35) or “all”. May be specified more than once.

–no-cuda-version-check

Supported

Disallows erroring out if the detected version of the CUDA install is too low for the requested CUDA GPU architecture

-no-flang-libs

Supported

Prohibits linking against Flang libraries

–no-offload-arch= <value>

Supported

Removes CUDA/HIP offloading device architecture (e.g. sm_35, gfx906) from the list of devices to compile for. “all” resets the list to its default value

–no-system-header-prefix= <prefix>

Supported

Assumes no system header for all #include paths starting with the given <prefix>

-nobuiltininc

Supported

Disables built-in #include directories

-nogpuinc

Supported

Prohibits adding CUDA/HIP include paths and includes default CUDA/HIP wrapper header files

-nogpulib

Supported

Prohibits linking device library for CUDA/HIP device compilation

-nostdinc++

Unsupported

Disables standard #include directories for the C++ standard library

-ObjC++

Unsupported

Treats source input files as Objective-C++ inputs

-objcmt-atomic-property

Unsupported

Enables migration to “atomic” properties

-objcmt-migrate-all

Unsupported

Enables migration to modern ObjC

-objcmt-migrate-annotation

Unsupported

Enables migration to property and method annotations

-objcmt-migrate-designated-init

Unsupported

Enables migration to infer NS_DESIGNATED_INITIALIZER for initializer methods

-objcmt-migrate-instancetype

Unsupported

Enables migration to infer instancetype for method result type

-objcmt-migrate-literals

Unsupported

Enables migration to modern ObjC literals

-objcmt-migrate-ns-macros

Unsupported

Enables migration to NS_ENUM/NS_OPTIONS macros

-objcmt-migrate-property-dot-syntax

Unsupported

Enables migration of setter/getter messages to property-dot syntax

-objcmt-migrate-property

Unsupported

Enables migration to modern ObjC property

-objcmt-migrate-protocol-conformance

Unsupported

Enables migration to add protocol conformance on classes

-objcmt-migrate-readonly-property

Unsupported

Enables migration to modern ObjC readonly property

-objcmt-migrate-readwrite-property

Unsupported

Enables migration to modern ObjC readwrite property

-objcmt-migrate-subscripting

Unsupported

Enables migration to modern ObjC subscripting

-objcmt-ns-nonatomic-iosonly

Unsupported

Enables migration to use NS_NONATOMIC_IOSONLY macro for setting property’s “atomic” attribute

-objcmt-returns-innerpointer-property

Unsupported

Enables migration to annotate property with NS_RETURNS_INNER_POINTER

-objcmt-whitelist-dir-path= <value>

Unsupported

Modifies exclusively the files with the filename present in the given directory

-ObjC

Unsupported

Treats source input files as Objective-C inputs

–offload-arch= <value>

Supported

Specifies CUDA offloading device architecture (e.g. sm_35), or HIP offloading target ID in the form of a device architecture followed by target ID features delimited by a colon. Each target ID feature is a predefined string followed by a plus or minus sign (e.g. gfx908:xnack+:sramecc-). May be specified more than once.

-o <file>

Supported

Writes output to the given <file>

-parallel-jobs= <value>

Supported

Specifies the number of parallel jobs allowed

-pg

Supported

Enables mcount instrumentation

-pipe

Supported

Asserts using pipes between commands, when possible.

–precompile

Supported

Only precompiles the input

-print-effective-triple

Supported

Prints the effective target triple

-print-file-name= <file>

Supported

Prints the full library path of the given <file>

-print-ivar-layout

Unsupported

Enables Objective-C Ivar layout bitmap print trace

-print-libgcc-file-name

Supported

“Prints the library path for the currently used compiler runtime library (“”libgcc.a”” or “”libclang_rt.builtins.*.a””)”

-print-prog-name= <name>

Supported

Prints the full program path of the given <name>

-print-resource-dir

Supported

Prints the resource directory pathname

-print-search-dirs

Supported

Prints the paths used for finding libraries and programs

-print-supported-cpus

Supported

Prints the supported CPU models for the given target. If target is not specified, it prints the supported CPUs for the default target.

-print-target-triple

Supported

Prints the normalized target triple

-print-targets

Supported

Prints the registered targets

-pthread

Supported

Supports POSIX threads in the generated code

–ptxas-path= <value>

Unsupported

Specifies the path to ptxas (used for compiling CUDA code)

-P

Supported

Disables linemarker output in -E mode

-Qn

Supported

Prohibits emitting metadata containing compiler name and version

-Qunused-arguments

Supported

Prohibits emitting warning for unused driver arguments

-Qy

Supported

Emits metadata containing compiler name and version

-relocatable-pch

Supported

Allows to build a relocatable precompiled header

-rewrite-legacy-objc

Unsupported

Rewrites Legacy Objective-C source to C++

-rewrite-objc

Unsupported

Rewrites Objective-C source to C++

–rocm-device-lib-path= <value>

Supported

Specifies ROCm device library path. Alternative to rocm-path

–rocm-path= <value>

Supported

Specifies ROCm installation path that is used for finding and automatically linking required bitcode libraries

-Rpass-analysis= <value>

Supported

Reports transformation analysis by optimization passes whose names match the given POSIX regular expression

-Rpass-missed= <value>

Supported

Reports missed transformations by optimization passes whose names match the given POSIX regular expression

-Rpass= <value>

Supported

Reports transformations by optimization passes whose names match the given POSIX regular expression

-rtlib= <value>

Unsupported

Specifies the compiler runtime library to be used

-R <remark>

Unsupported

Enables the specified remark

-save-stats= <value>

Supported

Saves llvm statistics

-save-stats

Supported

Saves llvm statistics

-save-temps= <value>

Supported

Saves intermediate compilation results

-save-temps

Supported

Saves intermediate compilation results

-serialize-diagnostics= <value>

Supported

Serializes compiler diagnostics to the specified file

-shared-libsan

Unsupported

Dynamically links the sanitizer runtime

-static-flang-libs

Supported

Asserts linking using static Flang libraries

-static-libsan

Unsupported

Statically links the sanitizer runtime

-static-openmp

Supported

Asserts using the static host OpenMP runtime while linking

-std= <value>

Supported

Specifies the language standard to compile for.

-stdlib+±isystem <directory>

Supported

Specifies the directory to be used as the C++ standard library include path

-stdlib= <value>

Supported

Specifies the C++ standard library to be used

-sycl-std= <value>

Unsupported

Specifies the SYCL language standard to compile for

–system-header-prefix= <prefix>

Supported

Assumes all #include paths starting with the given <prefix> to include a system header

-S

Supported

Runs only preprocess and compilation steps

–target= <value>

Supported

Generates code for the given target

-Tbss <addr>

Supported

Sets the starting address of BSS to the given <addr>

-Tdata <addr>

Supported

Sets the starting address of DATA to the given <addr>

-time

Supported

Times individual commands

-traditional-cpp

Unsupported

Enables some traditional CPP emulation

-trigraphs

Supported

Processes trigraph sequences

-Ttext <addr>

Supported

Sets starting address of TEXT to the given <addr>

-T \ <script\>

Unsupported

Specifies the given. \ <script\> as linker script

-undef

Supported

undefs all system defines

-unwindlib= <value>

Supported

Specifies the unwind library to be used

-U <macro>

Supported

Undefines the given <macro>

–verify-debug-info

Supported

Verifies the binary representation of the debug output

-verify-pch

Unsupported

Loads and verifies if a precompiled header file is stale

–version

Supported

Prints version information

-v

Supported

Shows commands to be run, and uses verbose output

-Wa, <arg>

Supported

Passes the comma-separated arguments in the given <arg> to the assembler

-Wdeprecated

Supported

Enables warnings for deprecated constructs and defines_DEPRECATED

-Wl, <arg>

Supported

Passes comma-separated arguments in <arg> to the linker.

-working-directory <value>

Supported

Resolves file paths relative to the specified directory

-Wp, <arg>

Supported

Passes comma-separated arguments in <arg> to the preprocessor

-W <warning>

Supported

Enables the specified warning

-w

Supported

Suppresses all warnings

-Xanalyzer <arg>

Supported

Passes <arg> to the static analyzer

-Xarch_device <arg>

Supported

Passes <arg> to the CUDA/HIP device compilation

-Xarch_host <arg>

Supported

Passes <arg> to the CUDA/HIP host compilation

-Xassembler <arg>

Supported

Passes <arg> to the assembler

-Xclang <arg>

Supported

Passes <arg> to the clang compiler

-Xcuda-fatbinary <arg>

Supported

Passes <arg> to fatbinary invocation

-Xcuda-ptxas <arg>

Supported

Passes <arg> to the ptxas assembler

-Xlinker <arg>

Supported

Passes <arg> to the linker

-Xopenmp-target= <triple> <arg>

Supported

Passes <arg> to the target offloading toolchain identified by <triple>

-Xopenmp-target <arg>

Supported

Passes <arg> to the target offloading toolchain

-Xpreprocessor <arg>

Supported

Passes <arg> to the preprocessor

-x <language>

Supported

Assumes subsequent input files to have the given type <language>

-z <arg>

Supported

Passes -z <arg> to the linker