CLANG(1) User Commands CLANG(1)

# [NAME](#NAME)

clang - Wolfi Clang 14.0.6-r11

# [DESCRIPTION](#DESCRIPTION)

OVERVIEW: clang LLVM compiler

USAGE: clang-14 \[options] file...

## [DEBUG/DEVELOPMENT OPTIONS:](#DEBUG/DEVELOPMENT_OPTIONS:)

[**-ccc-install-dir** <value>](#ccc)

Simulate installation in the given directory

**-ccc-print-bindings** Show bindings of tools to actions

[**-ccc-print-phases**](#ccc~2)

Dump list of actions to perform

[**-gen-cdb-fragment-path** <value>](#gen)

Emit a compilation database fragment to the specified directory

[**-gen-reproducer**](#gen~2)

Auto-generates preprocessed source files and a reproduction script

[**-via-file-asm**](#via)

Write assembly to file for input to assemble jobs

## [DRIVER OPTIONS:](#DRIVER_OPTIONS:)

[**-ccc-arcmt-check**](#ccc~3)

Check for ARC migration issues that need manual handling

[**-ccc-arcmt-migrate** <value>](#ccc~4)

Apply modifications and produces temporary files that conform to ARC

[**-ccc-arcmt-modify**](#ccc~5)

Apply modifications to files to conform to ARC

[**-ccc-gcc-name** <gcc-path>](#ccc~6)

Name for native GCC compiler

[**-ccc-objcmt-migrate** <value>](#ccc~7)

Apply modifications and produces temporary files to migrate to modern ObjC syntax

**--driver-mode=**<value> Set the driver mode to either 'gcc', 'g++', 'cpp', or 'cl'

[**--gpu-use-aux-triple-only**](#gpu)

Prepare '-aux-triple' only without populating '-aux-target-cpu' and '-aux-target-feature'.

**--rsp-quoting=**<value> Set the rsp quoting to either 'posix', or 'windows'

## [OPTIONS:](#OPTIONS:)

-###

Print (but do not run) the commands to run for this compilation

[**--amdgpu-arch-tool=**<value>](#amdgpu)

Tool used for detecting AMD GPU arch in the system.

[**--analyzer-output** <value>](#analyzer)

Static analyzer report output format (html|plist|plist-multi-file|plist-html|sarif|sarif-html|text).

[**--analyze**](#analyze)

Run the static analyzer

[**-arcmt-migrate-emit-errors**](#arcmt)

Emit ARC errors even if the migrator can fix them

[**-arcmt-migrate-report-output** <value>](#arcmt~2)

Output path for the plist report

[**-B** <prefix>](#B)

Search $prefix$file for executables, libraries, and data files. If $prefix is a directory, search $prefix/$file

[**-b** <arg>](#b)

Pass **-b** <arg> to the linker on AIX (only).

[**-canonical-prefixes**](#canonical)

Use absolute paths for invoking subcommands (default)

[**-CC**](#CC)

Include comments from within macros in preprocessed output

[**-cl-denorms-are-zero**](#cl)

OpenCL only. Allow denormals to be flushed to zero.

[**-cl-fast-relaxed-math**](#cl~2)

OpenCL only. Sets **-cl-finite-math-only** and **-cl-unsafe-math-optimizations**, and defines \_\_FAST\_RELAXED\_MATH\_\_.

[**-cl-finite-math-only**](#cl~3)

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

[**-cl-fp32-correctly-rounded-divide-sqrt**](#cl~4)

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

[**-cl-kernel-arg-info**](#cl~5)

OpenCL only. Generate kernel argument metadata.

[**-cl-mad-enable**](#cl~6)

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

[**-cl-no-signed-zeros**](#cl~7)

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

[**-cl-no-stdinc**](#cl~8)

OpenCL only. Disables all standard includes containing non-native compiler types and functions.

[**-cl-opt-disable**](#cl~9)

OpenCL only. This option disables all optimizations. By default optimizations are enabled.

[**-cl-single-precision-constant**](#cl~10)

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

[**-cl-std=**<value>](#cl~11)

OpenCL language standard to compile for.

[**-cl-strict-aliasing**](#cl~12)

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

[**-cl-uniform-work-group-size**](#cl~13)

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

[**-cl-unsafe-math-optimizations**](#cl~14)

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

[**--config-system-dir=**<value>](#config)

System directory for configuration files

[**--config-user-dir=**<value>](#config~2)

User directory for configuration files

[**--config** <value>](#config~3)

Specifies configuration file

[**--cuda-compile-host-device**](#cuda)

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

[**--cuda-device-only**](#cuda~2)

Compile CUDA code for device only

[**--cuda-host-only**](#cuda~3)

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

[**--cuda-include-ptx=**<value>](#cuda~4)

Include PTX for the following GPU architecture (e.g. sm\_35) or 'all'. May be specified more than once.

[**--cuda-noopt-device-debug**](#cuda~5)

Enable device-side debug info generation. Disables ptxas optimizations.

[**--cuda-path-ignore-env**](#cuda~6)

Ignore environment variables to detect CUDA installation

[**--cuda-path=**<value>](#cuda~7)

CUDA installation path

[**-cuid=**<value>](#cuid=)

An ID for compilation unit, which should be the same for the same compilation unit but different for different compilation units. It is used to externalize device-side static variables for single source offloading languages CUDA and HIP so that they can be accessed by the host code of the same compilation unit.

[**-cxx-isystem** <directory>](#cxx)

Add directory to the C++ SYSTEM include search path

[**-C**](#C)

Include comments in preprocessed output

[**-c**](#c)

Only run preprocess, compile, and assemble steps

[**-dD**](#dD)

Print macro definitions in **-E** mode in addition to normal output

**-dependency-dot** <value> Filename to write DOT-formatted header dependencies to

[**-dependency-file** <value>](#dependency)

Filename (or -) to write dependency output to

[**-dI**](#dI)

Print include directives in **-E** mode in addition to normal output

[**-dM**](#dM)

Print macro definitions in **-E** mode instead of normal output

[**-dsym-dir** <dir>](#dsym)

Directory to output dSYM's (if any) to

[**-D** <macro>=<value>](#D)

Define <macro> to <value> (or 1 if <value> omitted)

[**-emit-ast**](#emit)

Emit Clang AST files for source inputs

[**-emit-interface-stubs**](#emit~2)

Generate Interface Stub Files.

[**-emit-llvm**](#emit~3)

Use the LLVM representation for assembler and object files

[**-emit-merged-ifs**](#emit~4)

Generate Interface Stub Files, emit merged text not binary.

[**--emit-static-lib**](#emit~5)

Enable linker job to emit a static library.

[**-enable-trivial-auto-var-init-zero-knowing-it-will-be-removed-from-clang**](#enable)

Trivial automatic variable initialization to zero is only here for benchmarks, it'll eventually be removed, and I'm OK with that because I'm only using it to benchmark

[**--end-no-unused-arguments**](#end)

Start emitting warnings for unused driver arguments

[**-extract-api**](#extract)

Extract API information

[**-E**](#E)

Only run the preprocessor

[**-faapcs-bitfield-load**](#faapcs)

Follows the AAPCS standard that all volatile bit-field write generates at least one load. (ARM only).

[**-faapcs-bitfield-width**](#faapcs~2)

Follow the AAPCS standard requirement stating that volatile bit-field width is dictated by the field container type. (ARM only).

[**-faddrsig**](#faddrsig)

Emit an address-significance table

[**-falign-loops=**<N>](#falign)

N must be a power of two. Align loops to the boundary

[**-faligned-allocation**](#faligned)

Enable C++17 aligned allocation functions

[**-fallow-editor-placeholders**](#fallow)

Treat editor placeholders as valid source code

[**-faltivec-src-compat=**<value>](#faltivec)

Source-level compatibility for Altivec vectors (for PowerPC targets). This includes results of vector comparison (scalar for 'xl', vector for 'gcc') as well as behavior when initializing with a scalar (splatting for 'xl', element zero only for 'gcc'). For 'mixed', the compatibility is as 'gcc' for 'vector bool/vector pixel' and as 'xl' for other types. Current default is 'mixed'.

[**-fansi-escape-codes**](#fansi)

Use ANSI escape codes for diagnostics

[**-fapple-kext**](#fapple)

Use Apple's kernel extensions ABI

[**-fapple-link-rtlib**](#fapple~2)

Force linking the clang builtins runtime library

[**-fapple-pragma-pack**](#fapple~3)

Enable Apple gcc-compatible #pragma pack handling

**-fapplication-extension** Restrict code to those available for App Extensions

[**-fapprox-func**](#fapprox)

Allow certain math function calls to be replaced with an approximately equivalent calculation

[**-fasync-exceptions**](#fasync)

Enable EH Asynchronous exceptions

[**-fbasic-block-sections=**<value>](#fbasic)

Place each function's basic blocks in unique sections (ELF Only) : all | labels | none | list=<file>

[**-fbinutils-version=**<major.minor>](#fbinutils)

Produced object files can use all ELF features supported by this binutils version and newer. If **-fno-integrated-as** is specified, the generated assembly will consider GNU as support. 'none' means that all ELF features can be used, regardless of binutils support. Defaults to 2.26.

[**-fblocks**](#fblocks)

Enable the 'blocks' language feature

[**-fborland-extensions**](#fborland)

Accept non-standard constructs supported by the Borland compiler

[**-fbuild-session-file=**<file>](#fbuild)

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

[**-fbuild-session-timestamp=**<time since Epoch in seconds>](#fbuild~2)

Time when the current build session started

[**-fbuiltin-module-map**](#fbuiltin)

Load the clang builtins module map file.

[**-fc**++-abi=<value>](#fc)

C++ ABI to use. This will override the target C++ ABI.

[**-fcall-saved-x10**](#fcall)

Make the x10 register call-saved (AArch64 only)

[**-fcall-saved-x11**](#fcall~2)

Make the x11 register call-saved (AArch64 only)

[**-fcall-saved-x12**](#fcall~3)

Make the x12 register call-saved (AArch64 only)

[**-fcall-saved-x13**](#fcall~4)

Make the x13 register call-saved (AArch64 only)

[**-fcall-saved-x14**](#fcall~5)

Make the x14 register call-saved (AArch64 only)

[**-fcall-saved-x15**](#fcall~6)

Make the x15 register call-saved (AArch64 only)

[**-fcall-saved-x18**](#fcall~7)

Make the x18 register call-saved (AArch64 only)

[**-fcall-saved-x8**](#fcall~8)

Make the x8 register call-saved (AArch64 only)

[**-fcall-saved-x9**](#fcall~9)

Make the x9 register call-saved (AArch64 only)

**-fcf-protection=**<value> Instrument control-flow architecture protection. Options: return, branch, full, none.

[**-fcf-protection**](#fcf)

Enable cf-protection in 'full' mode

[**-fchar8\_t**](#fchar8_t)

Enable C++ builtin type char8\_t

[**-fclang-abi-compat=**<version>](#fclang)

Attempt to match the ABI of Clang <version>

[**-fcolor-diagnostics**](#fcolor)

Enable colors in diagnostics

[**-fcomment-block-commands=**<arg>](#fcomment)

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

[**-fcommon**](#fcommon)

Place uninitialized global variables in a common block

[**-fcomplete-member-pointers**](#fcomplete)

Require member pointer base types to be complete if they would be significant under the Microsoft ABI

[**-fconvergent-functions**](#fconvergent)

Assume functions may be convergent

[**-fcoroutines-ts**](#fcoroutines)

Enable support for the C++ Coroutines TS

[**-fcoverage-compilation-dir=**<value>](#fcoverage)

The compilation directory to embed in the coverage mapping.

[**-fcoverage-mapping**](#fcoverage~2)

Generate coverage mapping to enable code coverage analysis

[**-fcoverage-prefix-map=**<value>](#fcoverage~3)

remap file source paths in coverage mapping

[**-fcrash-diagnostics-dir=**<dir>](#fcrash)

Put crash-report files in <dir>

[**-fcs-profile-generate=**<directory>](#fcs)

Generate instrumented code to collect context sensitive execution counts into <directory>/default.profraw (overridden by LLVM\_PROFILE\_FILE env var)

[**-fcs-profile-generate**](#fcs~2)

Generate instrumented code to collect context sensitive execution counts into default.profraw (overridden by LLVM\_PROFILE\_FILE env var)

[**-fcuda-approx-transcendentals**](#fcuda)

Use approximate transcendental functions

[**-fcuda-short-ptr**](#fcuda~2)

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

[**-fcxx-exceptions**](#fcxx)

Enable C++ exceptions

[**-fcxx-modules**](#fcxx~2)

Enable modules for C++

[**-fdata-sections**](#fdata)

Place each data in its own section

[**-fdebug-compilation-dir=**<value>](#fdebug)

The compilation directory to embed in the debug info

[**-fdebug-default-version=**<value>](#fdebug~2)

Default DWARF version to use, if a **-g** option caused DWARF debug info to be produced

[**-fdebug-info-for-profiling**](#fdebug~3)

Emit extra debug info to make sample profile more accurate

[**-fdebug-macro**](#fdebug~4)

Emit macro debug information

[**-fdebug-prefix-map=**<value>](#fdebug~5)

remap file source paths in debug info

[**-fdebug-ranges-base-address**](#fdebug~6)

Use DWARF base address selection entries in .debug\_ranges

[**-fdebug-types-section**](#fdebug~7)

Place debug types in their own section (ELF Only)

[**-fdeclspec**](#fdeclspec)

Allow \_\_declspec as a keyword

[**-fdelayed-template-parsing**](#fdelayed)

Parse templated function definitions at the end of the translation unit

[**-fdelete-null-pointer-checks**](#fdelete)

Treat usage of null pointers as undefined behavior (default)

[**-fdiagnostics-absolute-paths**](#fdiagnostics)

Print absolute paths in diagnostics

[**-fdiagnostics-hotness-threshold=**<value>](#fdiagnostics~2)

Prevent optimization remarks from being output if they do not have at least this profile count. Use 'auto' to apply the threshold from profile summary

[**-fdiagnostics-parseable-fixits**](#fdiagnostics~3)

Print fix-its in machine parseable form

[**-fdiagnostics-print-source-range-info**](#fdiagnostics~4)

Print source range spans in numeric form

[**-fdiagnostics-show-hotness**](#fdiagnostics~5)

Enable profile hotness information in diagnostic line

[**-fdiagnostics-show-note-include-stack**](#fdiagnostics~6)

Display include stacks for diagnostic notes

[**-fdiagnostics-show-option**](#fdiagnostics~7)

Print option name with mappable diagnostics

[**-fdiagnostics-show-template-tree**](#fdiagnostics~8)

Print a template comparison tree for differing templates

[**-fdigraphs**](#fdigraphs)

Enable alternative token representations '<:', ':>', '<%', '%>', '%:', '%:%:' (default)

[**-fdirect-access-external-data**](#fdirect)

Don't use GOT indirection to reference external data symbols

[**-fdiscard-value-names**](#fdiscard)

Discard value names in LLVM IR

[**-fdollars-in-identifiers**](#fdollars)

Allow '$' in identifiers

[**-fdouble-square-bracket-attributes**](#fdouble)

Enable '\[\[]]' attributes in all C and C++ language modes

[**-fdwarf-exceptions**](#fdwarf)

Use DWARF style exceptions

[**-feliminate-unused-debug-types**](#feliminate)

Do not emit debug info for defined but unused types

[**-fembed-bitcode-marker**](#fembed)

Embed placeholder LLVM IR data as a marker

[**-fembed-bitcode=**<option>](#fembed~2)

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

[**-fembed-bitcode**](#fembed~3)

Embed LLVM IR bitcode as data

[**-fembed-offload-object=**<value>](#fembed~4)

Embed Offloading device-side binary into host object file as a section.

[**-femit-all-decls**](#femit)

Emit all declarations, even if unused

[**-femulated-tls**](#femulated)

Use emutls functions to access thread\_local variables

[**-fenable-matrix**](#fenable)

Enable matrix data type and related builtin functions

[**-fexceptions**](#fexceptions)

Enable support for exception handling

[**-fexperimental-new-constant-interpreter**](#fexperimental)

Enable the experimental new constant interpreter

[**-fexperimental-relative-c**++-abi-vtables](#fexperimental~2)

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

[**-fexperimental-strict-floating-point**](#fexperimental~3)

Enables experimental strict floating point in LLVM.

[**-fextend-arguments=**<value>](#fextend)

Controls how scalar integer arguments are extended in calls to unprototyped and varargs functions

[**-ffast-math**](#ffast)

Allow aggressive, lossy floating-point optimizations

[**-ffile-compilation-dir=**<value>](#ffile)

The compilation directory to embed in the debug info and coverage mapping.

[**-ffile-prefix-map=**<value>](#ffile~2)

remap file source paths in debug info, predefined preprocessor macros and \_\_builtin\_FILE()

[**-ffine-grained-bitfield-accesses**](#ffine)

Use separate accesses for consecutive bitfield runs with legal widths and alignments.

[**-ffinite-loops**](#ffinite)

Assume all loops are finite.

[**-ffixed-a0**](#ffixed)

Reserve the a0 register (M68k only)

[**-ffixed-a1**](#ffixed~2)

Reserve the a1 register (M68k only)

[**-ffixed-a2**](#ffixed~3)

Reserve the a2 register (M68k only)

[**-ffixed-a3**](#ffixed~4)

Reserve the a3 register (M68k only)

[**-ffixed-a4**](#ffixed~5)

Reserve the a4 register (M68k only)

[**-ffixed-a5**](#ffixed~6)

Reserve the a5 register (M68k only)

[**-ffixed-a6**](#ffixed~7)

Reserve the a6 register (M68k only)

[**-ffixed-d0**](#ffixed~8)

Reserve the d0 register (M68k only)

[**-ffixed-d1**](#ffixed~9)

Reserve the d1 register (M68k only)

[**-ffixed-d2**](#ffixed~10)

Reserve the d2 register (M68k only)

[**-ffixed-d3**](#ffixed~11)

Reserve the d3 register (M68k only)

[**-ffixed-d4**](#ffixed~12)

Reserve the d4 register (M68k only)

[**-ffixed-d5**](#ffixed~13)

Reserve the d5 register (M68k only)

[**-ffixed-d6**](#ffixed~14)

Reserve the d6 register (M68k only)

[**-ffixed-d7**](#ffixed~15)

Reserve the d7 register (M68k only)

[**-ffixed-point**](#ffixed~16)

Enable fixed point types

[**-ffixed-r19**](#ffixed~17)

Reserve register r19 (Hexagon only)

[**-ffixed-r9**](#ffixed~18)

Reserve the r9 register (ARM only)

[**-ffixed-x10**](#ffixed~19)

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

[**-ffixed-x11**](#ffixed~20)

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

[**-ffixed-x12**](#ffixed~21)

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

[**-ffixed-x13**](#ffixed~22)

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

[**-ffixed-x14**](#ffixed~23)

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

[**-ffixed-x15**](#ffixed~24)

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

[**-ffixed-x16**](#ffixed~25)

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

[**-ffixed-x17**](#ffixed~26)

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

[**-ffixed-x18**](#ffixed~27)

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

[**-ffixed-x19**](#ffixed~28)

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

[**-ffixed-x1**](#ffixed~29)

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

[**-ffixed-x20**](#ffixed~30)

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

[**-ffixed-x21**](#ffixed~31)

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

[**-ffixed-x22**](#ffixed~32)

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

[**-ffixed-x23**](#ffixed~33)

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

[**-ffixed-x24**](#ffixed~34)

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

[**-ffixed-x25**](#ffixed~35)

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

[**-ffixed-x26**](#ffixed~36)

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

[**-ffixed-x27**](#ffixed~37)

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

[**-ffixed-x28**](#ffixed~38)

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

[**-ffixed-x29**](#ffixed~39)

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

[**-ffixed-x2**](#ffixed~40)

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

[**-ffixed-x30**](#ffixed~41)

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

[**-ffixed-x31**](#ffixed~42)

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

[**-ffixed-x3**](#ffixed~43)

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

[**-ffixed-x4**](#ffixed~44)

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

[**-ffixed-x5**](#ffixed~45)

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

[**-ffixed-x6**](#ffixed~46)

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

[**-ffixed-x7**](#ffixed~47)

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

[**-ffixed-x8**](#ffixed~48)

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

[**-ffixed-x9**](#ffixed~49)

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

[**-fforce-dwarf-frame**](#fforce)

Always emit a debug frame section

[**-fforce-emit-vtables**](#fforce~2)

Emits more virtual tables to improve devirtualization

[**-fforce-enable-int128**](#fforce~3)

Enable support for int128\_t type

[**-ffp-contract=**<value>](#ffp)

Form fused FP ops (e.g. FMAs): fast (fuses across statements disregarding pragmas) | on (only fuses in the same statement unless dictated by pragmas) | off (never fuses) | fast-honor-pragmas (fuses across statements unless diectated by pragmas). Default is 'fast' for CUDA, 'fast-honor-pragmas' for HIP, and 'on' otherwise.

[**-ffp-exception-behavior=**<value>](#ffp~2)

Specifies the exception behavior of floating-point operations.

[**-ffp-model=**<value>](#ffp~3)

Controls the semantics of floating-point calculations.

[**-ffreestanding**](#ffreestanding)

Assert that the compilation takes place in a freestanding environment

[**-ffuchsia-api-level=**<value>](#ffuchsia)

Set Fuchsia API level

[**-ffunction-sections**](#ffunction)

Place each function in its own section

[**-fglobal-isel**](#fglobal)

Enables the global instruction selector

[**-fgnu-keywords**](#fgnu)

Allow GNU-extension keywords regardless of language standard

[**-fgnu-runtime**](#fgnu~2)

Generate output compatible with the standard GNU Objective-C runtime

[**-fgnu89-inline**](#fgnu89)

Use the gnu89 inline semantics

[**-fgnuc-version=**<value>](#fgnuc)

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

**-fgpu-allow-device-init** Allow device side init function in HIP (experimental)

[**-fgpu-defer-diag**](#fgpu)

Defer host/device related diagnostic messages for CUDA/HIP

[**-fgpu-exclude-wrong-side-overloads**](#fgpu~2)

Always exclude wrong side overloads in overloading resolution for CUDA/HIP

[**-fgpu-flush-denormals-to-zero**](#fgpu~3)

Flush denormal floating point values to zero in CUDA/HIP device mode.

[**-fgpu-inline-threshold=**<value>](#fgpu~4)

Inline threshold for device compilation for CUDA/HIP

[**-fgpu-rdc**](#fgpu~5)

Generate relocatable device code, also known as separate compilation mode

[**-fgpu-sanitize**](#fgpu~6)

Enable sanitizer for AMDGPU target

[**-fhip-fp32-correctly-rounded-divide-sqrt**](#fhip)

Specify that single precision floating-point divide and sqrt used in the program source are correctly rounded (HIP device compilation only)

[**-fhip-new-launch-api**](#fhip~2)

Use new kernel launching API for HIP

[**-fignore-exceptions**](#fignore)

Enable support for ignoring exception handling constructs

[**-fimplicit-module-maps**](#fimplicit)

Implicitly search the file system for module map files.

[**-finline-functions**](#finline)

Inline suitable functions

**-finline-hint-functions** Inline functions which are (explicitly or implicitly) marked inline

**-finput-charset=**<value> Specify the default character set for source files

[**-finstrument-function-entry-bare**](#finstrument)

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

[**-finstrument-functions-after-inlining**](#finstrument~2)

Like **-finstrument-functions**, but insert the calls after inlining

[**-finstrument-functions**](#finstrument~3)

Generate calls to instrument function entry and exit

[**-fintegrated-as**](#fintegrated)

Enable the integrated assembler

[**-fintegrated-cc1**](#fintegrated~2)

Run cc1 in-process

[**-fjump-tables**](#fjump)

Use jump tables for lowering switches

[**-fkeep-static-consts**](#fkeep)

Keep static const variables if unused

[**-flax-vector-conversions=**<value>](#flax)

Enable implicit vector bit-casts

[**-flegacy-pass-manager**](#flegacy)

Use the legacy pass manager in LLVM (deprecated, to be removed in a future release)

[**-flto-jobs=**<value>](#flto)

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

[**-flto**=*auto*](#flto~2)

Enable LTO in 'full' mode

[**-flto**=*jobserver*](#flto~3)

Enable LTO in 'full' mode

[**-flto=**<value>](#flto=)

Set LTO mode to either 'full' or 'thin'

[**-flto**](#flto~4)

Enable LTO in 'full' mode

[**-fmacro-prefix-map=**<value>](#fmacro)

remap file source paths in predefined preprocessor macros and \_\_builtin\_FILE()

[**-fmath-errno**](#fmath)

Require math functions to indicate errors by setting errno

[**-fmax-tokens=**<value>](#fmax)

Max total number of preprocessed tokens for **-Wmax-tokens**.

[**-fmax-type-align=**<value>](#fmax~2)

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

[**-fmemory-profile=**<directory>](#fmemory)

Enable heap memory profiling and dump results into <directory>

[**-fmemory-profile**](#fmemory~2)

Enable heap memory profiling

[**-fmerge-all-constants**](#fmerge)

Allow merging of constants

[**-fmessage-length=**<value>](#fmessage)

Format message diagnostics so that they fit within N columns

[**-fminimize-whitespace**](#fminimize)

Minimize whitespace when emitting preprocessor output

[**-fmodule-file**=*\[*<name>=\]<file>](#fmodule)

Specify the mapping of module name to precompiled module file, or load a module file if name is omitted.

[**-fmodule-map-file=**<file>](#fmodule~2)

Load this module map file

[**-fmodule-name=**<name>](#fmodule~3)

Specify the name of the module to build

[**-fmodules-cache-path=**<directory>](#fmodules)

Specify the module cache path

[**-fmodules-decluse**](#fmodules~2)

Require declaration of modules used within a module

[**-fmodules-disable-diagnostic-validation**](#fmodules~3)

Disable validation of the diagnostic options when loading the module

[**-fmodules-ignore-macro=**<value>](#fmodules~4)

Ignore the definition of the given macro when building and loading modules

[**-fmodules-prune-after=**<seconds>](#fmodules~5)

Specify the interval (in seconds) after which a module file will be considered unused

[**-fmodules-prune-interval=**<seconds>](#fmodules~6)

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

[**-fmodules-search-all**](#fmodules~7)

Search even non-imported modules to resolve references

[**-fmodules-strict-decluse**](#fmodules~8)

Like **-fmodules-decluse** but requires all headers to be in modules

[**-fmodules-ts**](#fmodules~9)

Enable support for the C++ Modules TS

[**-fmodules-user-build-path** <directory>](#fmodules~10)

Specify the module user build path

[**-fmodules-validate-input-files-content**](#fmodules~11)

Validate PCM input files based on content if mtime differs

[**-fmodules-validate-once-per-build-session**](#fmodules~12)

Don't verify input files for the modules if the module has been successfully validated or loaded during this build session

[**-fmodules-validate-system-headers**](#fmodules~13)

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

[**-fmodules**](#fmodules~14)

Enable the 'modules' language feature

[**-fms-compatibility-version=**<value>](#fms)

Dot-separated value representing the Microsoft compiler version number to report in \_MSC\_VER (0 = don't define it (default))

[**-fms-compatibility**](#fms~2)

Enable full Microsoft Visual C++ compatibility

[**-fms-extensions**](#fms~3)

Accept some non-standard constructs supported by the Microsoft compiler

[**-fms-hotpatch**](#fms~4)

Ensure that all functions can be hotpatched at runtime

[**-fmsc-version=**<value>](#fmsc)

Microsoft compiler version number to report in \_MSC\_VER (0 = don't define it (default))

**-fnew-alignment=**<align> Specifies the largest alignment guaranteed by '::operator new(size\_t)'

[**-fnew-infallible**](#fnew)

Enable treating throwing global C++ operator new as always returning valid memory (annotates with \_\_attribute\_\_((returns\_nonnull)) and throw()). This is detectable in source.

[**-fno-aapcs-bitfield-width**](#fno)

Do not follow the AAPCS standard requirement stating that volatile bit-field width is dictated by the field container type. (ARM only).

[**-fno-access-control**](#fno~2)

Disable C++ access control

[**-fno-addrsig**](#fno~3)

Don't emit an address-significance table

[**-fno-assume-sane-operator-new**](#fno~4)

Don't assume that C++'s global operator new can't alias any pointer

[**-fno-autolink**](#fno~5)

Disable generation of linker directives for automatic library linking

[**-fno-builtin-**<value>](#fno~6)

Disable implicit builtin knowledge of a specific function

[**-fno-builtin**](#fno~7)

Disable implicit builtin knowledge of functions

[**-fno-c**++-static-destructors](#fno~8)

Disable C++ static destructor registration

[**-fno-char8\_t**](#fno~9)

Disable C++ builtin type char8\_t

[**-fno-color-diagnostics**](#fno~10)

Disable colors in diagnostics

[**-fno-common**](#fno~11)

Compile common globals like normal definitions

[**-fno-complete-member-pointers**](#fno~12)

Do not require member pointer base types to be complete if they would be significant under the Microsoft ABI

**-fno-constant-cfstrings** Disable creation of CodeFoundation-type constant strings

[**-fno-coverage-mapping**](#fno~13)

Disable code coverage analysis

[**-fno-crash-diagnostics**](#fno~14)

Disable auto-generation of preprocessed source files and a script for reproduction during a clang crash

[**-fno-cuda-approx-transcendentals**](#fno~15)

Don't use approximate transcendental functions

[**-fno-cxx-modules**](#fno~16)

Disable modules for C++

[**-fno-debug-macro**](#fno~17)

Do not emit macro debug information

[**-fno-declspec**](#fno~18)

Disallow \_\_declspec as a keyword

[**-fno-delayed-template-parsing**](#fno~19)

Disable delayed template parsing

[**-fno-delete-null-pointer-checks**](#fno~20)

Do not treat usage of null pointers as undefined behavior

[**-fno-diagnostics-fixit-info**](#fno~21)

Do not include fixit information in diagnostics

[**-fno-digraphs**](#fno~22)

Disallow alternative token representations '<:', ':>', '<%', '%>', '%:', '%:%:'

[**-fno-direct-access-external-data**](#fno~23)

Use GOT indirection to reference external data symbols

[**-fno-discard-value-names**](#fno~24)

Do not discard value names in LLVM IR

[**-fno-dollars-in-identifiers**](#fno~25)

Disallow '$' in identifiers

[**-fno-double-square-bracket-attributes**](#fno~26)

Disable '\[\[]]' attributes in all C and C++ language modes

**-fno-elide-constructors** Disable C++ copy constructor elision

[**-fno-elide-type**](#fno~27)

Do not elide types when printing diagnostics

[**-fno-eliminate-unused-debug-types**](#fno~28)

Emit debug info for defined but unused types

[**-fno-exceptions**](#fno~29)

Disable support for exception handling

[**-fno-experimental-relative-c**++-abi-vtables](#fno~30)

Do not use the experimental C++ class ABI for classes with virtual tables

[**-fno-fine-grained-bitfield-accesses**](#fno~31)

Use large-integer access for consecutive bitfield runs.

[**-fno-finite-loops**](#fno~32)

Do not assume that any loop is finite.

[**-fno-fixed-point**](#fno~33)

Disable fixed point types

[**-fno-force-enable-int128**](#fno~34)

Disable support for int128\_t type

[**-fno-global-isel**](#fno~35)

Disables the global instruction selector

[**-fno-gnu-inline-asm**](#fno~36)

Disable GNU style inline asm

[**-fno-gpu-allow-device-init**](#fno~37)

Don't allow device side init function in HIP (experimental)

[**-fno-gpu-defer-diag**](#fno~38)

Don't defer host/device related diagnostic messages for CUDA/HIP

[**-fno-gpu-exclude-wrong-side-overloads**](#fno~39)

Exclude wrong side overloads only if there are same side overloads in overloading resolution for CUDA/HIP

[**-fno-hip-fp32-correctly-rounded-divide-sqrt**](#fno~40)

Don't specify that single precision floating-point divide and sqrt used in the program source are correctly rounded (HIP device compilation only)

**-fno-hip-new-launch-api** Don't use new kernel launching API for HIP

[**-fno-integrated-as**](#fno~41)

Disable the integrated assembler

[**-fno-integrated-cc1**](#fno~42)

Spawn a separate process for each cc1

[**-fno-jump-tables**](#fno~43)

Do not use jump tables for lowering switches

**-fno-keep-static-consts** Don't keep static const variables if unused

[**-fno-legacy-pass-manager**](#fno~44)

Use the new pass manager in LLVM

[**-fno-lto**](#fno~45)

Disable LTO mode (default)

[**-fno-memory-profile**](#fno~46)

Disable heap memory profiling

[**-fno-merge-all-constants**](#fno~47)

Disallow merging of constants

[**-fno-new-infallible**](#fno~48)

Disable treating throwing global C++ operator new as always returning valid memory (annotates with \_\_attribute\_\_((returns\_nonnull)) and throw()). This is detectable in source.

[**-fno-objc-infer-related-result-type**](#fno~49)

do not infer Objective-C related result type based on method family

[**-fno-offload-lto**](#fno~50)

Disable LTO mode (default) for offload compilation

[**-fno-openmp-extensions**](#fno~51)

Disable all Clang extensions for OpenMP directives and clauses

[**-fno-operator-names**](#fno~52)

Do not treat C++ operator name keywords as synonyms for operators

[**-fno-pch-codegen**](#fno~53)

Do not generate code for uses of this PCH that assumes an explicit object file will be built for the PCH

[**-fno-pch-debuginfo**](#fno~54)

Do not generate debug info for types in an object file built from this PCH and do not generate them elsewhere

[**-fno-plt**](#fno~55)

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

[**-fno-preserve-as-comments**](#fno~56)

Do not preserve comments in inline assembly

[**-fno-profile-generate**](#fno~57)

Disable generation of profile instrumentation.

[**-fno-profile-instr-generate**](#fno~58)

Disable generation of profile instrumentation.

[**-fno-profile-instr-use**](#fno~59)

Disable using instrumentation data for profile-guided optimization

[**-fno-pseudo-probe-for-profiling**](#fno~60)

Do not emit pseudo probes for sample profiling

[**-fno-register-global-dtors-with-atexit**](#fno~61)

Don't use atexit or \_\_cxa\_atexit to register global destructors

[**-fno-rtlib-add-rpath**](#fno~62)

Do not add **-rpath** with architecture-specific resource directory to the linker flags

[**-fno-rtti-data**](#fno~63)

Disable generation of RTTI data

[**-fno-rtti**](#fno~64)

Disable generation of rtti information

[**-fno-sanitize-address-outline-instrumentation**](#fno~65)

Use default code inlining logic for the address sanitizer

[**-fno-sanitize-address-poison-custom-array-cookie**](#fno~66)

Disable poisoning array cookies when using custom operator new\[] in AddressSanitizer

[**-fno-sanitize-address-use-after-scope**](#fno~67)

Disable use-after-scope detection in AddressSanitizer

[**-fno-sanitize-address-use-odr-indicator**](#fno~68)

Disable ODR indicator globals

[**-fno-sanitize-cfi-canonical-jump-tables**](#fno~69)

Do not make the jump table addresses canonical in the symbol table

[**-fno-sanitize-cfi-cross-dso**](#fno~70)

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

[**-fno-sanitize-coverage=**<value>](#fno~71)

Disable features of coverage instrumentation for Sanitizers

[**-fno-sanitize-hwaddress-experimental-aliasing**](#fno~72)

Disable aliasing mode in HWAddressSanitizer

[**-fno-sanitize-ignorelist**](#fno~73)

Don't use ignorelist file for sanitizers

[**-fno-sanitize-memory-param-retval**](#fno~74)

Disable detection of uninitialized parameters and return values

[**-fno-sanitize-memory-track-origins**](#fno~75)

Disable origins tracking in MemorySanitizer

[**-fno-sanitize-memory-use-after-dtor**](#fno~76)

Disable use-after-destroy detection in MemorySanitizer

[**-fno-sanitize-recover=**<value>](#fno~77)

Disable recovery for specified sanitizers

[**-fno-sanitize-stats**](#fno~78)

Disable sanitizer statistics gathering.

[**-fno-sanitize-thread-atomics**](#fno~79)

Disable atomic operations instrumentation in ThreadSanitizer

[**-fno-sanitize-thread-func-entry-exit**](#fno~80)

Disable function entry/exit instrumentation in ThreadSanitizer

[**-fno-sanitize-thread-memory-access**](#fno~81)

Disable memory access instrumentation in ThreadSanitizer

[**-fno-sanitize-trap=**<value>](#fno~82)

Disable trapping for specified sanitizers

[**-fno-sanitize-trap**](#fno~83)

Disable trapping for all sanitizers

[**-fno-short-wchar**](#fno~84)

Force wchar\_t to be an unsigned int

[**-fno-show-column**](#fno~85)

Do not include column number on diagnostics

[**-fno-show-source-location**](#fno~86)

Do not include source location information with diagnostics

[**-fno-signed-char**](#fno~87)

char is unsigned

[**-fno-signed-zeros**](#fno~88)

Allow optimizations that ignore the sign of floating point zeros

[**-fno-spell-checking**](#fno~89)

Disable spell-checking

[**-fno-split-machine-functions**](#fno~90)

Disable late function splitting using profile information (x86 ELF)

[**-fno-split-stack**](#fno~91)

Wouldn't use segmented stack

[**-fno-stack-clash-protection**](#fno~92)

Disable stack clash protection

[**-fno-stack-protector**](#fno~93)

Disable the use of stack protectors

[**-fno-standalone-debug**](#fno~94)

Limit debug information produced to reduce size of debug binary

[**-fno-strict-float-cast-overflow**](#fno~95)

Relax language rules and try to match the behavior of the target's native float-to-int conversion instructions

[**-fno-strict-return**](#fno~96)

Don't treat control flow paths that fall off the end of a non-void function as unreachable

[**-fno-sycl**](#fno~97)

Disables SYCL kernels compilation for device

[**-fno-temp-file**](#fno~98)

Directly create compilation output files. This may lead to incorrect incremental builds if the compiler crashes

**-fno-threadsafe-statics** Do not emit code to make initialization of local statics thread safe

[**-fno-trigraphs**](#fno~99)

Do not process trigraph sequences

[**-fno-unique-section-names**](#fno~100)

Don't use unique names for text and data sections

[**-fno-unroll-loops**](#fno~101)

Turn off loop unroller

[**-fno-use-cxa-atexit**](#fno~102)

Don't use \_\_cxa\_atexit for calling destructors

[**-fno-use-init-array**](#fno~103)

Use .ctors/.dtors instead of .init\_array/.fini\_array

[**-fno-visibility-inlines-hidden-static-local-var**](#fno~104)

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

[**-fno-xray-function-index**](#fno~105)

Omit function index section at the expense of single-function patching performance

[**-fno-zero-initialized-in-bss**](#fno~106)

Don't place zero initialized data in BSS

[**-fobjc-arc-exceptions**](#fobjc)

Use EH-safe code when synthesizing retains and releases in **-fobjc-arc**

[**-fobjc-arc**](#fobjc~2)

Synthesize retain and release calls for Objective-C pointers

[**-fobjc-disable-direct-methods-for-testing**](#fobjc~3)

Ignore attribute objc\_direct so that direct methods can be tested

[**-fobjc-encode-cxx-class-template-spec**](#fobjc~4)

Fully encode c++ class template specialization

[**-fobjc-exceptions**](#fobjc~5)

Enable Objective-C exceptions

[**-fobjc-runtime=**<value>](#fobjc~6)

Specify the target Objective-C runtime kind and version

[**-fobjc-weak**](#fobjc~7)

Enable ARC-style weak references in Objective-C

[**-foffload-lto=**<value>](#foffload)

Set LTO mode to either 'full' or 'thin' for offload compilation

[**-foffload-lto**](#foffload~2)

Enable LTO in 'full' mode for offload compilation

[**-fopenmp-enable-irbuilder**](#fopenmp)

Use the experimental OpenMP-IR-Builder codegen path.

[**-fopenmp-extensions**](#fopenmp~2)

Enable all Clang extensions for OpenMP directives and clauses

**-fopenmp-implicit-rpath** Set rpath on OpenMP executables

[**-fopenmp-new-driver**](#fopenmp~3)

Use the new driver for OpenMP offloading.

[**-fopenmp-simd**](#fopenmp~4)

Emit OpenMP code only for SIMD-based constructs.

[**-fopenmp-target-debug**](#fopenmp~5)

Enable debugging in the OpenMP offloading device RTL

[**-fopenmp-target-new-runtime**](#fopenmp~6)

Use the new bitcode library for OpenMP offloading

[**-fopenmp-targets=**<value>](#fopenmp~7)

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

[**-fopenmp-version=**<value>](#fopenmp~8)

Set OpenMP version (e.g. 45 for OpenMP 4.5, 50 for OpenMP 5.0). Default value is 50.

[**-fopenmp**](#fopenmp~9)

Parse OpenMP pragmas and generate parallel code.

[**-foptimization-record-file=**<file>](#foptimization)

Specify 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>](#foptimization~2)

Only include passes which match a specified regular expression in the generated optimization record (by default, include all passes)

[**-forder-file-instrumentation**](#forder)

Generate instrumented code to collect order file into default.profraw file (overridden by '=' form of option or LLVM\_PROFILE\_FILE env var)

[**-fpack-struct=**<value>](#fpack)

Specify the default maximum struct packing alignment

[**-fpascal-strings**](#fpascal)

Recognize and construct Pascal-style string literals

**-fpass-plugin=**<dsopath> Load pass plugin from a dynamic shared object file (only with new pass manager).

[**-fpatchable-function-entry=**<N,M>](#fpatchable)

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

[**-fpcc-struct-return**](#fpcc)

Override the default ABI to return all structs on the stack

[**-fpch-codegen**](#fpch)

Generate code for uses of this PCH that assumes an explicit object file will be built for the PCH

[**-fpch-debuginfo**](#fpch~2)

Generate debug info for types in an object file built from this PCH and do not generate them elsewhere

[**-fpch-instantiate-templates**](#fpch~3)

Instantiate templates already while building a PCH

[**-fpch-validate-input-files-content**](#fpch~4)

Validate PCH input files based on content if mtime differs

[**-fplugin-arg-**<name>-<arg>](#fplugin)

Pass <arg> to plugin <name>

[**-fplugin=**<dsopath>](#fplugin=)

Load the named plugin (dynamic shared object)

[**-fprebuilt-implicit-modules**](#fprebuilt)

Look up implicit modules in the prebuilt module path

[**-fprebuilt-module-path=**<directory>](#fprebuilt~2)

Specify the prebuilt module path

[**-fproc-stat-report=**<value>](#fproc)

Save subprocess statistics to the given file

[**-fproc-stat-report**<value>](#fproc~2)

Print subprocess statistics

[**-fprofile-exclude-files=**<value>](#fprofile)

Instrument only functions from files where names don't match all the regexes separated by a semi-colon

[**-fprofile-filter-files=**<value>](#fprofile~2)

Instrument only functions from files where names match any regex separated by a semi-colon

[**-fprofile-generate=**<directory>](#fprofile~3)

Generate instrumented code to collect execution counts into <directory>/default.profraw (overridden by LLVM\_PROFILE\_FILE env var)

[**-fprofile-generate**](#fprofile~4)

Generate instrumented code to collect execution counts into default.profraw (overridden by LLVM\_PROFILE\_FILE env var)

[**-fprofile-instr-generate=**<file>](#fprofile~5)

Generate instrumented code to collect execution counts into <file> (overridden by LLVM\_PROFILE\_FILE env var)

[**-fprofile-instr-generate**](#fprofile~6)

Generate 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>](#fprofile~7)

Use instrumentation data for profile-guided optimization

[**-fprofile-list=**<value>](#fprofile~8)

Filename defining the list of functions/files to instrument

[**-fprofile-remapping-file=**<file>](#fprofile~9)

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

[**-fprofile-sample-accurate**](#fprofile~10)

Specifies that the sample profile is accurate

[**-fprofile-sample-use=**<value>](#fprofile~11)

Enable sample-based profile guided optimizations

[**-fprofile-update=**<method>](#fprofile~12)

Set update method of profile counters (atomic,prefer-atomic,single)

[**-fprofile-use=**<pathname>](#fprofile~13)

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

[**-fprotect-parens**](#fprotect)

Determines whether the optimizer honors parentheses when floating-point expressions are evaluated

[**-fpseudo-probe-for-profiling**](#fpseudo)

Emit pseudo probes for sample profiling

[**-freciprocal-math**](#freciprocal)

Allow division operations to be reassociated

[**-freg-struct-return**](#freg)

Override the default ABI to return small structs in registers

[**-fregister-global-dtors-with-atexit**](#fregister)

Use atexit or \_\_cxa\_atexit to register global destructors

[**-frelaxed-template-template-args**](#frelaxed)

Enable C++17 relaxed template template argument matching

[**-freroll-loops**](#freroll)

Turn on loop reroller

[**-fropi**](#fropi)

Generate read-only position independent code (ARM only)

[**-frtlib-add-rpath**](#frtlib)

Add **-rpath** with architecture-specific resource directory to the linker flags

[**-frwpi**](#frwpi)

Generate read-write position independent code (ARM only)

[**-fsanitize-address-destructor=**<value>](#fsanitize)

Set destructor type used in ASan instrumentation

[**-fsanitize-address-field-padding=**<value>](#fsanitize~2)

Level of field padding for AddressSanitizer

[**-fsanitize-address-globals-dead-stripping**](#fsanitize~3)

Enable linker dead stripping of globals in AddressSanitizer

[**-fsanitize-address-outline-instrumentation**](#fsanitize~4)

Always generate function calls for address sanitizer instrumentation

[**-fsanitize-address-poison-custom-array-cookie**](#fsanitize~5)

Enable poisoning array cookies when using custom operator new\[] in AddressSanitizer

[**-fsanitize-address-use-after-return=**<mode>](#fsanitize~6)

Select the mode of detecting stack use-after-return in AddressSanitizer: never | runtime (default) | always

[**-fsanitize-address-use-after-scope**](#fsanitize~7)

Enable use-after-scope detection in AddressSanitizer

[**-fsanitize-address-use-odr-indicator**](#fsanitize~8)

Enable 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>](#fsanitize~9)

Alias for **-fsanitize-ignorelist=**

[**-fsanitize-cfi-canonical-jump-tables**](#fsanitize~10)

Make the jump table addresses canonical in the symbol table

[**-fsanitize-cfi-cross-dso**](#fsanitize~11)

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

[**-fsanitize-cfi-icall-generalize-pointers**](#fsanitize~12)

Generalize pointers in CFI indirect call type signature checks

[**-fsanitize-coverage-allowlist=**<value>](#fsanitize~13)

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

[**-fsanitize-coverage-blacklist=**<value>](#fsanitize~14)

Deprecated, use **-fsanitize-coverage-ignorelist=** instead

[**-fsanitize-coverage-ignorelist=**<value>](#fsanitize~15)

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

[**-fsanitize-coverage-whitelist=**<value>](#fsanitize~16)

Deprecated, use **-fsanitize-coverage-allowlist=** instead

[**-fsanitize-coverage=**<value>](#fsanitize~17)

Specify the type of coverage instrumentation for Sanitizers

[**-fsanitize-hwaddress-abi=**<value>](#fsanitize~18)

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

[**-fsanitize-hwaddress-experimental-aliasing**](#fsanitize~19)

Enable aliasing mode in HWAddressSanitizer

[**-fsanitize-ignorelist=**<value>](#fsanitize~20)

Path to ignorelist file for sanitizers

[**-fsanitize-memory-param-retval**](#fsanitize~21)

Enable detection of uninitialized parameters and return values

[**-fsanitize-memory-track-origins=**<value>](#fsanitize~22)

Enable origins tracking in MemorySanitizer

[**-fsanitize-memory-track-origins**](#fsanitize~23)

Enable origins tracking in MemorySanitizer

[**-fsanitize-memory-use-after-dtor**](#fsanitize~24)

Enable use-after-destroy detection in MemorySanitizer

[**-fsanitize-recover=**<value>](#fsanitize~25)

Enable recovery for specified sanitizers

[**-fsanitize-stats**](#fsanitize~26)

Enable sanitizer statistics gathering.

[**-fsanitize-system-blacklist=**<value>](#fsanitize~27)

Alias for **-fsanitize-system-ignorelist=**

[**-fsanitize-system-ignorelist=**<value>](#fsanitize~28)

Path to system ignorelist file for sanitizers

[**-fsanitize-thread-atomics**](#fsanitize~29)

Enable atomic operations instrumentation in ThreadSanitizer (default)

[**-fsanitize-thread-func-entry-exit**](#fsanitize~30)

Enable function entry/exit instrumentation in ThreadSanitizer (default)

[**-fsanitize-thread-memory-access**](#fsanitize~31)

Enable memory access instrumentation in ThreadSanitizer (default)

**-fsanitize-trap=**<value> Enable trapping for specified sanitizers

[**-fsanitize-trap**](#fsanitize~32)

Enable trapping for all sanitizers

[**-fsanitize-undefined-strip-path-components=**<number>](#fsanitize~33)

Strip (or keep only, if negative) a given number of path components when emitting check metadata.

[**-fsanitize=**<check>](#fsanitize=)

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

[**-fsave-optimization-record=**<format>](#fsave)

Generate an optimization record file in a specific format

[**-fsave-optimization-record**](#fsave~2)

Generate a YAML optimization record file

[**-fseh-exceptions**](#fseh)

Use SEH style exceptions

[**-fshort-enums**](#fshort)

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

[**-fshort-wchar**](#fshort~2)

Force wchar\_t to be a short unsigned int

[**-fshow-overloads=**<value>](#fshow)

Which overload candidates to show when overload resolution fails: best|all; defaults to all

**-fshow-skipped-includes** Show skipped includes in **-H** output.

[**-fsigned-char**](#fsigned)

char is signed

[**-fsized-deallocation**](#fsized)

Enable C++14 sized global deallocation functions

[**-fsjlj-exceptions**](#fsjlj)

Use SjLj style exceptions

[**-fslp-vectorize**](#fslp)

Enable the superword-level parallelism vectorization passes

[**-fsplit-dwarf-inlining**](#fsplit)

Provide 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**](#fsplit~2)

Enables splitting of the LTO unit

[**-fsplit-machine-functions**](#fsplit~3)

Enable late function splitting using profile information (x86 ELF)

[**-fsplit-stack**](#fsplit~4)

Use segmented stack

[**-fstack-clash-protection**](#fstack)

Enable stack clash protection

[**-fstack-protector-all**](#fstack~2)

Enable stack protectors for all functions

[**-fstack-protector-strong**](#fstack~3)

Enable 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 alloca or the taking of an address from a local variable

[**-fstack-protector**](#fstack~4)

Enable stack protectors for some functions vulnerable to stack smashing. This uses a loose heuristic which considers functions vulnerable if they contain a char (or 8bit integer) array or constant sized calls to alloca , which are of greater size than ssp-buffer-size (default: 8 bytes). All variable sized 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**](#fstack~5)

Emit section containing metadata on function stack sizes

[**-fstack-usage**](#fstack~6)

Emit .su file containing information on function stack sizes

[**-fstandalone-debug**](#fstandalone)

Emit full debug info for all types used by the program

[**-fstrict-enums**](#fstrict)

Enable optimizations based on the strict definition of an enum's value range

[**-fstrict-float-cast-overflow**](#fstrict~2)

Assume that overflowing float-to-int casts are undefined (default)

[**-fstrict-vtable-pointers**](#fstrict~3)

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

[**-fswift-async-fp=**<option>](#fswift)

Control emission of Swift async extended frame info (option: auto, always, never)

[**-fsycl**](#fsycl)

Enables SYCL kernels compilation for device

[**-fsystem-module**](#fsystem)

Build this module as a system module. Only used with **-emit-module**

[**-fthin-link-bitcode=**<value>](#fthin)

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

**-fthinlto-index=**<value> Perform ThinLTO importing using provided function summary index

[**-ftime-report=**<value>](#ftime)

(For new pass manager) "per-pass": one report for each pass; "per-pass-run": one report for each pass invocation

[**-ftime-trace-granularity=**<value>](#ftime~2)

Minimum time granularity (in microseconds) traced by time profiler

[**-ftime-trace**](#ftime~3)

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

**-ftrap-function=**<value> Issue call to specified function rather than a trap instruction

[**-ftrapv-handler=**<function name>](#ftrapv)

Specify the function to be called on overflow

[**-ftrapv**](#ftrapv~2)

Trap on integer overflow

[**-ftrigraphs**](#ftrigraphs)

Process trigraph sequences

[**-ftrivial-auto-var-init-stop-after=**<value>](#ftrivial)

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

[**-ftrivial-auto-var-init=**<value>](#ftrivial~2)

Initialize trivial automatic stack variables: uninitialized (default) | pattern

[**-funique-basic-block-section-names**](#funique)

Use unique names for basic block sections (ELF Only)

[**-funique-internal-linkage-names**](#funique~2)

Uniqueify Internal Linkage Symbol Names by appending the MD5 hash of the module path

[**-funroll-loops**](#funroll)

Turn on loop unroller

[**-fuse-cuid=**<value>](#fuse)

Method to generate ID's for compilation units for single source offloading languages CUDA and HIP: 'hash' (ID's generated by hashing file path and command line options) | 'random' (ID's generated as random numbers) | 'none' (disabled). Default is 'hash'. This option will be overridden by option '-cuid=\[ID]' if it is specified.

[**-fuse-line-directives**](#fuse~2)

Use #line in preprocessed output

[**-fvalidate-ast-input-files-content**](#fvalidate)

Compute and store the hash of input files used to build an AST. Files with mismatching mtime's are considered valid if both contents is identical

[**-fveclib=**<value>](#fveclib=)

Use the given vector functions library

[**-fvectorize**](#fvectorize)

Enable the loop vectorization passes

[**-fverbose-asm**](#fverbose)

Generate verbose assembly output

[**-fvirtual-function-elimination**](#fvirtual)

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

[**-fvisibility-dllexport=**<value>](#fvisibility)

The visibility for dllexport definitions \[-fvisibility-from-dllstorageclass]

[**-fvisibility-externs-dllimport=**<value>](#fvisibility~2)

The visibility for dllimport external declarations \[-fvisibility-from-dllstorageclass]

[**-fvisibility-externs-nodllstorageclass=**<value>](#fvisibility~3)

The visibility for external declarations without an explicit DLL dllstorageclass \[-fvisibility-from-dllstorageclass]

[**-fvisibility-from-dllstorageclass**](#fvisibility~4)

Set the visibility of symbols in the generated code from their DLL storage class

[**-fvisibility-global-new-delete-hidden**](#fvisibility~5)

Give global C++ operator new and delete declarations hidden visibility

[**-fvisibility-inlines-hidden-static-local-var**](#fvisibility~6)

When **-fvisibility-inlines-hidden** is enabled, static variables in inline C++ member functions will also be given hidden visibility by default

[**-fvisibility-inlines-hidden**](#fvisibility~7)

Give inline C++ member functions hidden visibility by default

[**-fvisibility-ms-compat**](#fvisibility~8)

Give global types 'default' visibility and global functions and variables 'hidden' visibility by default

[**-fvisibility-nodllstorageclass=**<value>](#fvisibility~9)

The visibility for defintiions without an explicit DLL export class \[-fvisibility-from-dllstorageclass]

[**-fvisibility=**<value>](#fvisibility=)

Set the default symbol visibility for all global declarations

[**-fwasm-exceptions**](#fwasm)

Use WebAssembly style exceptions

**-fwhole-program-vtables** Enables whole-program vtable optimization. Requires **-flto**

[**-fwrapv**](#fwrapv)

Treat signed integer overflow as two's complement

[**-fwritable-strings**](#fwritable)

Store string literals as writable data

[**-fxl-pragma-pack**](#fxl)

Enable IBM XL #pragma pack handling

[**-fxray-always-emit-customevents**](#fxray)

Always emit \_\_xray\_customevent(...) calls even if the containing function is not always instrumented

[**-fxray-always-emit-typedevents**](#fxray~2)

Always emit \_\_xray\_typedevent(...) calls even if the containing function is not always instrumented

[**-fxray-always-instrument=** <value>](#fxray~3)

DEPRECATED: Filename defining the whitelist for imbuing the 'always instrument' XRay attribute.

[**-fxray-attr-list=** <value>](#fxray~4)

Filename defining the list of functions/types for imbuing XRay attributes.

[**-fxray-function-groups=**<value>](#fxray~5)

Only instrument 1 of N groups

[**-fxray-ignore-loops**](#fxray~6)

Don't instrument functions with loops unless they also meet the minimum function size

[**-fxray-instruction-threshold=** <value>](#fxray~7)

Sets the minimum function size to instrument with XRay

[**-fxray-instrumentation-bundle=** <value>](#fxray~8)

Select which XRay instrumentation points to emit. Options: all, none, function-entry, function-exit, function, custom. Default is 'all'. 'function' includes both 'function-entry' and 'function-exit'.

[**-fxray-instrument**](#fxray~9)

Generate XRay instrumentation sleds on function entry and exit

[**-fxray-link-deps**](#fxray~10)

Tells clang to add the link dependencies for XRay.

[**-fxray-modes=** <value>](#fxray~11)

List of modes to link in by default into XRay instrumented binaries.

[**-fxray-never-instrument=** <value>](#fxray~12)

DEPRECATED: Filename defining the whitelist for imbuing the 'never instrument' XRay attribute.

[**-fxray-selected-function-group=**<value>](#fxray~13)

When using **-fxray-function-groups**, select which group of functions to instrument. Valid range is 0 to fxray-function-groups - 1

[**-fzvector**](#fzvector)

Enable System z vector language extension

[**-F** <value>](#F)

Add directory to framework include search path

**--gcc-toolchain=**<value> Search for GCC installation in the specified directory on targets which commonly use GCC. The directory usually contains 'lib{,32,64}/gcc{,-cross}/$triple' and 'include'. If specified, sysroot is skipped for GCC detection. Note: executables (e.g. ld) used by the compiler are not overridden by the selected GCC installation

[**-gcodeview-ghash**](#gcodeview)

Emit type record hashes in a .debug$H section

[**-gcodeview**](#gcodeview~2)

Generate CodeView debug information

[**-gdwarf-2**](#gdwarf)

Generate source-level debug information with dwarf version 2

[**-gdwarf-3**](#gdwarf~2)

Generate source-level debug information with dwarf version 3

[**-gdwarf-4**](#gdwarf~3)

Generate source-level debug information with dwarf version 4

[**-gdwarf-5**](#gdwarf~4)

Generate source-level debug information with dwarf version 5

[**-gdwarf32**](#gdwarf32)

Enables DWARF32 format for ELF binaries, if debug information emission is enabled.

[**-gdwarf64**](#gdwarf64)

Enables DWARF64 format for ELF binaries, if debug information emission is enabled.

[**-gdwarf**](#gdwarf~5)

Generate source-level debug information with the default dwarf version

[**-gembed-source**](#gembed)

Embed source text in DWARF debug sections

[**-gline-directives-only**](#gline)

Emit debug line info directives only

[**-gline-tables-only**](#gline~2)

Emit debug line number tables only

[**-gmodules**](#gmodules)

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

[**-gno-embed-source**](#gno)

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

**-gno-inline-line-tables** Don't emit inline line tables.

[**--gpu-bundle-output**](#gpu~2)

Bundle output files of HIP device compilation

[**--gpu-instrument-lib=**<value>](#gpu~3)

Instrument device library for HIP, which is a LLVM bitcode containing \_\_cyg\_profile\_func\_enter and \_\_cyg\_profile\_func\_exit

[**--gpu-max-threads-per-block=**<value>](#gpu~4)

Default max threads per block for kernel launch bounds for HIP

[**-gsplit-dwarf=**<value>](#gsplit)

Set DWARF fission mode to either 'split' or 'single'

[**-gz=**<value>](#gz=)

DWARF debug sections compression type

[**-G** <size>](#G)

Put objects of at most <size> bytes into small data section (MIPS / Hexagon)

[**-g**](#g)

Generate source-level debug information

[**--help-hidden**](#help)

Display help for hidden options

[**-help**](#help~2)

Display available options

[**--hip-device-lib=**<value>](#hip)

HIP device library

[**--hip-link**](#hip~2)

Link clang-offload-bundler bundles for HIP

[**--hip-path=**<value>](#hip~3)

HIP runtime installation path, used for finding HIP version and adding HIP include path.

[**--hip-version=**<value>](#hip~4)

HIP version in the format of major.minor.patch

[**--hipspv-pass-plugin=**<dsopath>](#hipspv)

path to a pass plugin for HIP to SPIR-V passes.

[**-H**](#H)

Show header includes and nesting depth

[**-I-**](#I)

Restrict all prior **-I** flags to double-quoted inclusion and remove current directory from include path

[**-ibuiltininc**](#ibuiltininc)

Enable builtin #include directories even when **-nostdinc** is used before or after **-ibuiltininc**. Using **-nobuiltininc** after the option disables it

[**-idirafter** <value>](#idirafter)

Add directory to AFTER include search path

[**-iframeworkwithsysroot** <directory>](#iframeworkwithsysroot)

Add directory to SYSTEM framework search path, absolute paths are relative to **-isysroot**

[**-iframework** <value>](#iframework)

Add directory to SYSTEM framework search path

[**-imacros** <file>](#imacros)

Include macros from file before parsing

[**-include-pch** <file>](#include)

Include precompiled header file

[**-include** <file>](#include~2)

Include file before parsing

[**-index-header-map**](#index)

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

[**-iprefix** <dir>](#iprefix)

Set the **-iwithprefix**/-iwithprefixbefore prefix

[**-iquote** <directory>](#iquote)

Add directory to QUOTE include search path

[**-isysroot** <dir>](#isysroot)

Set the system root directory (usually /)

[**-isystem-after** <directory>](#isystem)

Add directory to end of the SYSTEM include search path

[**-isystem** <directory>](#isystem~2)

Add directory to SYSTEM include search path

[**-ivfsoverlay** <value>](#ivfsoverlay)

Overlay the virtual filesystem described by file over the real file system

[**-iwithprefixbefore** <dir>](#iwithprefixbefore)

Set directory to include search path with prefix

[**-iwithprefix** <dir>](#iwithprefix)

Set directory to SYSTEM include search path with prefix

[**-iwithsysroot** <directory>](#iwithsysroot)

Add directory to SYSTEM include search path, absolute paths are relative to **-isysroot**

[**-I** <dir>](#I~2)

Add directory to the end of the list of include search paths

[**--libomptarget-amdgcn-bc-path=**<value>](#libomptarget)

Path to libomptarget-amdgcn bitcode library

[**--libomptarget-nvptx-bc-path=**<value>](#libomptarget~2)

Path to libomptarget-nvptx bitcode library

[**-L** <dir>](#L)

Add directory to library search path

[**-mabi**=*vec-default*](#mabi)

Enable the default Altivec ABI on AIX (AIX only). Uses only volatile vector registers.

[**-mabi**=*vec-extabi*](#mabi~2)

Enable the extended Altivec ABI on AIX (AIX only). Uses volatile and nonvolatile vector registers

[**-mabicalls**](#mabicalls)

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

[**-maix-struct-return**](#maix)

Return all structs in memory (PPC32 only)

[**-malign-branch-boundary=**<value>](#malign)

Specify the boundary's size to align branches

[**-malign-branch=**<value>](#malign~2)

Specify types of branches to align

[**-malign-double**](#malign~3)

Align doubles to two words in structs (x86 only)

[**-mamdgpu-ieee**](#mamdgpu)

Sets the IEEE bit in the expected default floating point mode register. Floating point opcodes that support exception flag gathering quiet and propagate signaling NaN inputs per IEEE 754-2008. This option changes the ABI. (AMDGPU only)

[**-mbackchain**](#mbackchain)

Link stack frames through backchain on System Z

[**-mbranch-protection=**<value>](#mbranch)

Enforce targets of indirect branches and function returns

[**-mbranches-within-32B-boundaries**](#mbranches)

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

[**-mcmodel**=*medany*](#mcmodel)

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

[**-mcmodel**=*medlow*](#mcmodel~2)

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

[**-mcmse**](#mcmse)

Allow use of CMSE (Armv8-M Security Extensions)

[**-mcode-object-v3**](#mcode)

Legacy option to specify code object ABI V3 (AMDGPU only)

[**-mcode-object-version=**<version>](#mcode~2)

Specify code object ABI version. Defaults to 3. (AMDGPU only)

[**-mcrc**](#mcrc)

Allow use of CRC instructions (ARM/Mips only)

[**-mcumode**](#mcumode)

Specify CU wavefront execution mode (AMDGPU only)

[**-mdouble=**<value>](#mdouble=)

Force double to be 32 bits or 64 bits

[**-MD**](#MD)

Write a depfile containing user and system headers

[**-meabi** <value>](#meabi)

Set EABI type, e.g. 4, 5 or gnu (default depends on triple)

[**-membedded-data**](#membedded)

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

[**-menable-experimental-extensions**](#menable)

Enable use of experimental RISC-V extensions.

**-menable-unsafe-fp-math** Allow unsafe floating-point math optimizations which may decrease precision

[**-mexec-model=**<value>](#mexec)

Execution model (WebAssembly only)

[**-mexecute-only**](#mexecute)

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

[**-mextern-sdata**](#mextern)

Assume that externally defined data is in the small data if it meets the **-G** <size> threshold (MIPS)

[**-mfentry**](#mfentry)

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

[**-mfix-cmse-cve-2021-35465**](#mfix)

Work around VLLDM erratum CVE-2021-35465 (ARM only)

**-mfix-cortex-a53-835769** Workaround Cortex-A53 erratum 835769 (AArch64 only)

[**-mfp32**](#mfp32)

Use 32-bit floating point registers (MIPS only)

[**-mfp64**](#mfp64)

Use 64-bit floating point registers (MIPS only)

[**-mfpxx**](#mfpxx)

Avoid FPU mode dependent operations when used with the O32 ABI

[**-MF** <file>](#MF)

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

[**-mgeneral-regs-only**](#mgeneral)

Generate code which only uses the general purpose registers (AArch64/x86 only)

[**-mglobal-merge**](#mglobal)

Enable merging of globals

[**-mgpopt**](#mgpopt)

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

[**-MG**](#MG)

Add missing headers to depfile

[**-mharden-sls=**<value>](#mharden)

Select straight-line speculation hardening scope

[**-mhvx-ieee-fp**](#mhvx)

Enable Hexagon HVX IEEE floating-point

[**-mhvx-length=**<value>](#mhvx~2)

Set Hexagon Vector Length

[**-mhvx-qfloat**](#mhvx~3)

Enable Hexagon HVX QFloat instructions

[**-mhvx=**<value>](#mhvx=)

Enable Hexagon Vector eXtensions

[**-mhvx**](#mhvx~4)

Enable Hexagon Vector eXtensions

[**-miamcu**](#miamcu)

Use Intel MCU ABI

[**-mibt-seal**](#mibt)

Optimize fcf-protection=branch/full (requires LTO).

[**-mignore-xcoff-visibility**](#mignore)

Not emit the visibility attribute for asm in AIX OS or give all symbols 'unspecified' visibility in XCOFF object file

[**--migrate**](#migrate)

Run the migrator

[**-mincremental-linker-compatible**](#mincremental)

(integrated-as) Emit an object file which can be used with an incremental linker

**-mindirect-jump=**<value> Change indirect jump instructions to inhibit speculation

[**-mios-version-min=**<value>](#mios)

Set iOS deployment target

[**-mips1**](#mips1)

Equivalent to **-march**=*mips1*

[**-mips2**](#mips2)

Equivalent to **-march**=*mips2*

[**-mips32r2**](#mips32r2)

Equivalent to **-march**=*mips32r2*

[**-mips32r3**](#mips32r3)

Equivalent to **-march**=*mips32r3*

[**-mips32r5**](#mips32r5)

Equivalent to **-march**=*mips32r5*

[**-mips32r6**](#mips32r6)

Equivalent to **-march**=*mips32r6*

[**-mips32**](#mips32)

Equivalent to **-march**=*mips32*

[**-mips3**](#mips3)

Equivalent to **-march**=*mips3*

[**-mips4**](#mips4)

Equivalent to **-march**=*mips4*

[**-mips5**](#mips5)

Equivalent to **-march**=*mips5*

[**-mips64r2**](#mips64r2)

Equivalent to **-march**=*mips64r2*

[**-mips64r3**](#mips64r3)

Equivalent to **-march**=*mips64r3*

[**-mips64r5**](#mips64r5)

Equivalent to **-march**=*mips64r5*

[**-mips64r6**](#mips64r6)

Equivalent to **-march**=*mips64r6*

[**-mips64**](#mips64)

Equivalent to **-march**=*mips64*

[**-MJ** <value>](#MJ)

Write a compilation database entry per input

[**-mllvm** <value>](#mllvm)

Additional arguments to forward to LLVM's option processing

[**-mlocal-sdata**](#mlocal)

Extend the **-G** behaviour to object local data (MIPS)

[**-mlong-calls**](#mlong)

Generate branches with extended addressability, usually via indirect jumps.

[**-mlong-double-128**](#mlong~2)

Force long double to be 128 bits

[**-mlong-double-64**](#mlong~3)

Force long double to be 64 bits

[**-mlong-double-80**](#mlong~4)

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

[**-mlvi-cfi**](#mlvi)

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

[**-mlvi-hardening**](#mlvi~2)

Enable all mitigations for Load Value Injection (LVI)

[**-mmacosx-version-min=**<value>](#mmacosx)

Set Mac OS X deployment target

[**-mmadd4**](#mmadd4)

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

[**-mmark-bti-property**](#mmark)

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

[**-MMD**](#MMD)

Write a depfile containing user headers

[**-mmemops**](#mmemops)

Enable generation of memop instructions

[**-mms-bitfields**](#mms)

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

[**-mmsa**](#mmsa)

Enable MSA ASE (MIPS only)

[**-mmt**](#mmt)

Enable MT ASE (MIPS only)

[**-MM**](#MM)

Like **-MMD**, but also implies **-E** and writes to stdout by default

[**-mno-abicalls**](#mno)

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

[**-mno-bti-at-return-twice**](#mno~2)

Do not add a BTI instruction after a setjmp or other return-twice construct (Arm/AArch64 only)

[**-mno-code-object-v3**](#mno~3)

Legacy option to specify code object ABI V2 (AMDGPU only)

[**-mno-crc**](#mno~4)

Disallow use of CRC instructions (Mips only)

[**-mno-cumode**](#mno~5)

Specify WGP wavefront execution mode (AMDGPU only)

[**-mno-embedded-data**](#mno~6)

Do not place constants in the .rodata section instead of the .sdata if they meet the **-G** <size> threshold (MIPS)

[**-mno-execute-only**](#mno~7)

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

[**-mno-extern-sdata**](#mno~8)

Do not assume that externally defined data is in the small data if it meets the **-G** <size> threshold (MIPS)

[**-mno-fix-cmse-cve-2021-35465**](#mno~9)

Don't work around VLLDM erratum CVE-2021-35465 (ARM only)

[**-mno-fix-cortex-a53-835769**](#mno~10)

Don't workaround Cortex-A53 erratum 835769 (AArch64 only)

[**-mno-global-merge**](#mno~11)

Disable merging of globals

[**-mno-gpopt**](#mno~12)

Do not use GP relative accesses for symbols known to be in a small data section (MIPS)

[**-mno-hvx-ieee-fp**](#mno~13)

Disable Hexagon HVX IEEE floating-point

[**-mno-hvx-qfloat**](#mno~14)

Disable Hexagon HVX QFloat instructions

[**-mno-hvx**](#mno~15)

Disable Hexagon Vector eXtensions

[**-mno-implicit-float**](#mno~16)

Don't generate implicit floating point instructions

[**-mno-incremental-linker-compatible**](#mno~17)

(integrated-as) Emit an object file which cannot be used with an incremental linker

[**-mno-local-sdata**](#mno~18)

Do not extend the **-G** behaviour to object local data (MIPS)

[**-mno-long-calls**](#mno~19)

Restore the default behaviour of not generating long calls

[**-mno-lvi-cfi**](#mno~20)

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

[**-mno-lvi-hardening**](#mno~21)

Disable mitigations for Load Value Injection (LVI)

[**-mno-madd4**](#mno~22)

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

[**-mno-memops**](#mno~23)

Disable generation of memop instructions

[**-mno-movt**](#mno~24)

Disallow use of movt/movw pairs (ARM only)

[**-mno-ms-bitfields**](#mno~25)

Do not set the default structure layout to be compatible with the Microsoft compiler standard

[**-mno-msa**](#mno~26)

Disable MSA ASE (MIPS only)

[**-mno-mt**](#mno~27)

Disable MT ASE (MIPS only)

[**-mno-neg-immediates**](#mno~28)

Disallow converting instructions with negative immediates to their negation or inversion.

[**-mno-nvj**](#mno~29)

Disable generation of new-value jumps

[**-mno-nvs**](#mno~30)

Disable generation of new-value stores

[**-mno-odd-spreg**](#mno~31)

Disable odd single-precision floating point registers

[**-mno-outline-atomics**](#mno~32)

Don't generate local calls to out-of-line atomic operations

[**-mno-outline**](#mno~33)

Disable function outlining (AArch64 only)

[**-mno-packets**](#mno~34)

Disable generation of instruction packets

[**-mno-relax-pic-calls**](#mno~35)

Do not produce relaxation hints for linkers to try optimizing PIC call sequences into direct calls (MIPS only)

[**-mno-relax**](#mno~36)

Disable linker relaxation

[**-mno-restrict-it**](#mno~37)

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

[**-mno-save-restore**](#mno~38)

Disable using library calls for save and restore

[**-mno-seses**](#mno~39)

Disable speculative execution side effect suppression (SESES)

[**-mno-stack-arg-probe**](#mno~40)

Disable stack probes which are enabled by default

[**-mno-tgsplit**](#mno~41)

Disable threadgroup split execution mode (AMDGPU only)

[**-mno-tls-direct-seg-refs**](#mno~42)

Disable direct TLS access through segment registers

[**-mno-unaligned-access**](#mno~43)

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

[**-mno-wavefrontsize64**](#mno~44)

Specify wavefront size 32 mode (AMDGPU only)

[**-mnocrc**](#mnocrc)

Disallow use of CRC instructions (ARM only)

[**-mnop-mcount**](#mnop)

Generate mcount/\_\_fentry\__ calls as nops. To activate they need to be patched in.

[**-mnvj**](#mnvj)

Enable generation of new-value jumps

[**-mnvs**](#mnvs)

Enable generation of new-value stores

[**-modd-spreg**](#modd)

Enable odd single-precision floating point registers

[**-module-dependency-dir** <value>](#module)

Directory to dump module dependencies to

[**-module-file-info**](#module~2)

Provide information about a particular module file

[**-momit-leaf-frame-pointer**](#momit)

Omit frame pointer setup for leaf functions

[**-moutline-atomics**](#moutline)

Generate local calls to out-of-line atomic operations

[**-moutline**](#moutline~2)

Enable function outlining (AArch64 only)

[**-mpacked-stack**](#mpacked)

Use packed stack layout (SystemZ only).

[**-mpackets**](#mpackets)

Enable generation of instruction packets

[**-mpad-max-prefix-size=**<value>](#mpad)

Specify maximum number of prefixes to use for padding

[**-mprefer-vector-width=**<value>](#mprefer)

Specifies preferred vector width for auto-vectorization. Defaults to 'none' which allows target specific decisions.

[**-MP**](#MP)

Create phony target for each dependency (other than main file)

[**-mqdsp6-compat**](#mqdsp6)

Enable hexagon-qdsp6 backward compatibility

[**-MQ** <value>](#MQ)

Specify name of main file output to quote in depfile

[**-mrecord-mcount**](#mrecord)

Generate a \_\_mcount\_loc section entry for each \_\_fentry\__ call.

[**-mrelax-all**](#mrelax)

(integrated-as) Relax all machine instructions

[**-mrelax-pic-calls**](#mrelax~2)

Produce relaxation hints for linkers to try optimizing PIC call sequences into direct calls (MIPS only)

[**-mrelax**](#mrelax~3)

Enable linker relaxation

[**-mrestrict-it**](#mrestrict)

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

[**-mrtd**](#mrtd)

Make StdCall calling convention the default

[**-msave-restore**](#msave)

Enable using library calls for save and restore

[**-mseses**](#mseses)

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

[**-msign-return-address=**<value>](#msign)

Select return address signing scope

[**-mskip-rax-setup**](#mskip)

Skip setting up RAX register when passing variable arguments (x86 only)

[**-msmall-data-limit=**<value>](#msmall)

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

[**-msoft-float**](#msoft)

Use software floating point

[**-mstack-alignment=**<value>](#mstack)

Set the stack alignment

[**-mstack-arg-probe**](#mstack~2)

Enable stack probes

[**-mstack-probe-size=**<value>](#mstack~3)

Set the stack probe size

[**-mstack-protector-guard-offset=**<value>](#mstack~4)

Use the given offset for addressing the stack-protector guard

[**-mstack-protector-guard-reg=**<value>](#mstack~5)

Use the given reg for addressing the stack-protector guard

[**-mstack-protector-guard=**<value>](#mstack~6)

Use the given guard (global, tls) for addressing the stack-protector guard

[**-mstackrealign**](#mstackrealign)

Force realign the stack at entry to every function

[**-mstrict-align**](#mstrict)

Force all memory accesses to be aligned (same as mno-unaligned-access)

[**-msve-vector-bits=**<value>](#msve)

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

[**-msvr4-struct-return**](#msvr4)

Return small structs in registers (PPC32 only)

[**-mtargetos=**<value>](#mtargetos=)

Set the deployment target to be the specified OS and OS version

[**-mtgsplit**](#mtgsplit)

Enable threadgroup split execution mode (AMDGPU only)

[**-mthread-model** <value>](#mthread)

The thread model to use, e.g. posix, single (posix by default)

[**-mtls-direct-seg-refs**](#mtls)

Enable direct TLS access through segment registers (default)

[**-mtls-size=**<value>](#mtls~2)

Specify bit size of immediate TLS offsets (AArch64 ELF only): 12 (for 4KB) | 24 (for 16MB, default) | 32 (for 4GB) | 48 (for 256TB, needs **-mcmodel**=*large*)

[**-mtp=**<value>](#mtp=)

Thread pointer access method (AArch32/AArch64 only)

[**-mtune=**<value>](#mtune=)

Only supported on X86 and RISC-V. Otherwise accepted for compatibility with GCC.

[**-MT** <value>](#MT)

Specify name of main file output in depfile

[**-munaligned-access**](#munaligned)

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

[**-munsafe-fp-atomics**](#munsafe)

Enable unsafe floating point atomic instructions (AMDGPU only)

[**-mvscale-max=**<value>](#mvscale)

Specify the vscale maximum. Defaults to the vector length agnostic value of "0". (AArch64 only)

[**-mvscale-min=**<value>](#mvscale~2)

Specify the vscale minimum. Defaults to "1". (AArch64 only)

[**-MV**](#MV)

Use NMake/Jom format for the depfile

[**-mwavefrontsize64**](#mwavefrontsize64)

Specify wavefront size 64 mode (AMDGPU only)

[**-M**](#M)

Like **-MD**, but also implies **-E** and writes to stdout by default

[**-no-canonical-prefixes**](#no)

Use relative paths for invoking subcommands

[**--no-cuda-include-ptx=**<value>](#no~2)

Do not include PTX for the following GPU architecture (e.g. sm\_35) or 'all'. May be specified more than once.

**--no-cuda-version-check** Don't error out if the detected version of the CUDA install is too low for the requested CUDA gpu architecture.

[**--no-gpu-bundle-output**](#no~3)

Do not bundle output files of HIP device compilation

[**--no-offload-arch=**<value>](#no~4)

Remove 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>](#no~5)

Treat all #include paths starting with <prefix> as not including a system header.

[**-nobuiltininc**](#nobuiltininc)

Disable builtin #include directories

[**-nogpuinc**](#nogpuinc)

Do not add include paths for CUDA/HIP and do not include the default CUDA/HIP wrapper headers

[**-nogpulib**](#nogpulib)

Do not link device library for CUDA/HIP device compilation

[**-nohipwrapperinc**](#nohipwrapperinc)

Do not include the default HIP wrapper headers and include paths

[**-nostdinc**++](#nostdinc)

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

[**-ObjC**++](#ObjC)

Treat source input files as Objective-C++ inputs

[**-objcmt-allowlist-dir-path=**<value>](#objcmt)

Only modify files with a filename contained in the provided directory path

**-objcmt-atomic-property** Make migration to 'atomic' properties

[**-objcmt-migrate-all**](#objcmt~2)

Enable migration to modern ObjC

[**-objcmt-migrate-annotation**](#objcmt~3)

Enable migration to property and method annotations

[**-objcmt-migrate-designated-init**](#objcmt~4)

Enable migration to infer NS\_DESIGNATED\_INITIALIZER for initializer methods

[**-objcmt-migrate-instancetype**](#objcmt~5)

Enable migration to infer instancetype for method result type

[**-objcmt-migrate-literals**](#objcmt~6)

Enable migration to modern ObjC literals

[**-objcmt-migrate-ns-macros**](#objcmt~7)

Enable migration to NS\_ENUM/NS\_OPTIONS macros

[**-objcmt-migrate-property-dot-syntax**](#objcmt~8)

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

[**-objcmt-migrate-property**](#objcmt~9)

Enable migration to modern ObjC property

[**-objcmt-migrate-protocol-conformance**](#objcmt~10)

Enable migration to add protocol conformance on classes

[**-objcmt-migrate-readonly-property**](#objcmt~11)

Enable migration to modern ObjC readonly property

[**-objcmt-migrate-readwrite-property**](#objcmt~12)

Enable migration to modern ObjC readwrite property

[**-objcmt-migrate-subscripting**](#objcmt~13)

Enable migration to modern ObjC subscripting

[**-objcmt-ns-nonatomic-iosonly**](#objcmt~14)

Enable migration to use NS\_NONATOMIC\_IOSONLY macro for setting property's 'atomic' attribute

[**-objcmt-returns-innerpointer-property**](#objcmt~15)

Enable migration to annotate property with NS\_RETURNS\_INNER\_POINTER

[**-objcmt-whitelist-dir-path=**<value>](#objcmt~16)

Alias for **-objcmt-allowlist-dir-path**

[**-ObjC**](#ObjC~2)

Treat source input files as Objective-C inputs

[**-object-file-name=**<file>](#object)

Set the output <file> for debug infos

[**--offload-arch=**<value>](#offload)

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 pre-defined string followed by a plus or minus sign (e.g. gfx908:xnack+:sramecc-). May be specified more than once.

[**--offload=**<value>](#offload=)

Specify comma-separated list of offloading target triples (CUDA and HIP only)

[**-o** <file>](#o)

Write output to <file>

[**-pedantic**](#pedantic)

Warn on language extensions

[**-pg**](#pg)

Enable mcount instrumentation

[**-pipe**](#pipe)

Use pipes between commands, when possible

[**--precompile**](#precompile)

Only precompile the input

**-print-effective-triple** Print the effective target triple

**-print-file-name=**<file> Print the full library path of <file>

[**-print-ivar-layout**](#print)

Enable Objective-C Ivar layout bitmap print trace

**-print-libgcc-file-name** Print the library path for the currently used compiler runtime library ("libgcc.a" or "libclang\_rt.builtins.\*.a")

[**-print-multiarch**](#print~2)

Print the multiarch target triple

**-print-prog-name=**<name> Print the full program path of <name>

[**-print-resource-dir**](#print~3)

Print the resource directory pathname

**-print-rocm-search-dirs** Print the paths used for finding ROCm installation

[**-print-runtime-dir**](#print~4)

Print the directory pathname containing clangs runtime libraries

[**-print-search-dirs**](#print~5)

Print the paths used for finding libraries and programs

[**-print-supported-cpus**](#print~6)

Print supported cpu models for the given target (if target is not specified, it will print the supported cpus for the default target)

[**-print-target-triple**](#print~7)

Print the normalized target triple

[**-print-targets**](#print~8)

Print the registered targets

[**-pthread**](#pthread)

Support POSIX threads in generated code

[**--ptxas-path=**<value>](#ptxas)

Path to ptxas (used for compiling CUDA code)

[**-P**](#P)

Disable linemarker output in **-E** mode

[**-Qn**](#Qn)

Do not emit metadata containing compiler name and version

[**-Qunused-arguments**](#Qunused)

Don't emit warning for unused driver arguments

[**-Qy**](#Qy)

Emit metadata containing compiler name and version

[**-relocatable-pch**](#relocatable)

Whether to build a relocatable precompiled header

[**-resource-dir** <value>](#resource)

The directory which holds the compiler resource files

[**-rewrite-legacy-objc**](#rewrite)

Rewrite Legacy Objective-C source to C++

[**-rewrite-objc**](#rewrite~2)

Rewrite Objective-C source to C++

[**--rocm-device-lib-path=**<value>](#rocm)

ROCm device library path. Alternative to rocm-path.

[**--rocm-path=**<value>](#rocm~2)

ROCm installation path, used for finding and automatically linking required bitcode libraries.

**-Rpass-analysis=**<value> Report transformation analysis from optimization passes whose name matches the given POSIX regular expression

[**-Rpass-missed=**<value>](#Rpass)

Report missed transformations by optimization passes whose name matches the given POSIX regular expression

[**-Rpass=**<value>](#Rpass=)

Report transformations performed by optimization passes whose name matches the given POSIX regular expression

[**-rtlib=**<value>](#rtlib=)

Compiler runtime library to use

[**-R**<remark>](#R)

Enable the specified remark

[**-save-stats=**<value>](#save)

Save llvm statistics.

[**-save-stats**](#save~2)

Save llvm statistics.

[**-save-temps=**<value>](#save~3)

Save intermediate compilation results.

[**-save-temps**](#save~4)

Save intermediate compilation results

[**-serialize-diagnostics** <value>](#serialize)

Serialize compiler diagnostics to a file

[**-shared-libsan**](#shared)

Dynamically link the sanitizer runtime

[**--start-no-unused-arguments**](#start)

Don't emit warnings about unused arguments for the following arguments

[**-static-libsan**](#static)

Statically link the sanitizer runtime

[**-static-openmp**](#static~2)

Use the static host OpenMP runtime while linking.

[**-std=**<value>](#std=)

Language standard to compile for

[**-stdlib**++-isystem <directory>](#stdlib)

Use directory as the C++ standard library include path

[**-stdlib=**<value>](#stdlib=)

C++ standard library to use

[**-sycl-std=**<value>](#sycl)

SYCL language standard to compile for.

[**--system-header-prefix=**<prefix>](#system)

Treat all #include paths starting with <prefix> as including a system header.

[**-S**](#S)

Only run preprocess and compilation steps

[**--target=**<value>](#target=)

Generate code for the given target

[**-Tbss** <addr>](#Tbss)

Set starting address of BSS to <addr>

[**-Tdata** <addr>](#Tdata)

Set starting address of DATA to <addr>

[**-time**](#time)

Time individual commands

[**-traditional-cpp**](#traditional)

Enable some traditional CPP emulation

[**-trigraphs**](#trigraphs)

Process trigraph sequences

[**-Ttext** <addr>](#Ttext)

Set starting address of TEXT to <addr>

[**-T** <script>](#T)

Specify <script> as linker script

[**-undef**](#undef)

undef all system defines

[**-unwindlib=**<value>](#unwindlib=)

Unwind library to use

[**-U** <macro>](#U)

Undefine macro <macro>

[**--verify-debug-info**](#verify)

Verify the binary representation of debug output

[**-verify-pch**](#verify~2)

Load and verify that a pre-compiled header file is not stale

[**--version**](#version)

Print version information

[**-v**](#v)

Show commands to run and use verbose output

[**-Wa**,<arg>](#Wa)

Pass the comma separated arguments in <arg> to the assembler

[**-Wdeprecated**](#Wdeprecated)

Enable warnings for deprecated constructs and define \_\_DEPRECATED

[**-Wl**,<arg>](#Wl)

Pass the comma separated arguments in <arg> to the linker

[**-Wlarge-by-value-copy**](#Wlarge)

Warn if a function definition returns or accepts an object larger in bytes than a given value

[**-working-directory** <value>](#working)

Resolve file paths relative to the specified directory

[**-Wp**,<arg>](#Wp)

Pass the comma separated arguments in <arg> to the preprocessor

[**-Wundef-prefix=**<arg>](#Wundef)

Enable warnings for undefined macros with a prefix in the comma separated list <arg>

[**-W**<warning>](#W)

Enable the specified warning

[**-w**](#w)

Suppress all warnings

[**-Xanalyzer** <arg>](#Xanalyzer)

Pass <arg> to the static analyzer

[**-Xarch\_device** <arg>](#Xarch_device)

Pass <arg> to the CUDA/HIP device compilation

[**-Xarch\_host** <arg>](#Xarch_host)

Pass <arg> to the CUDA/HIP host compilation

[**-Xassembler** <arg>](#Xassembler)

Pass <arg> to the assembler

[**-Xclang** <arg>](#Xclang)

Pass <arg> to the clang compiler

[**-Xcuda-fatbinary** <arg>](#Xcuda)

Pass <arg> to fatbinary invocation

[**-Xcuda-ptxas** <arg>](#Xcuda~2)

Pass <arg> to the ptxas assembler

[**-Xlinker** <arg>](#Xlinker)

Pass <arg> to the linker

[**-Xopenmp-target=**<triple> <arg>](#Xopenmp)

Pass <arg> to the target offloading toolchain identified by <triple>.

[**-Xopenmp-target** <arg>](#Xopenmp~2)

Pass <arg> to the target offloading toolchain.

[**-Xpreprocessor** <arg>](#Xpreprocessor)

Pass <arg> to the preprocessor

[**-x** <language>](#x)

Treat subsequent input files as having type <language>

[**-z** <arg>](#z)

Pass **-z** <arg> to the linker

October 2026 Wolfi

---

Document: clang(1) from clang-14 14.0.6-r11 (Chainguard OS)
Source: https://github.com/llvm/llvm-project