CLANG-22(1)

👑 clang-22 👑

okay bestie, welcome to CLANG-22(1) — yes that's the User Commands section, section 1, you're in the right place 💅. This is the clang LLVM compiler for oneAPI and she is that girl. Buckle up, this page is a whole saga (it comes in 14 parts, we're on part 1, don't you dare skip ahead).

---

🌸 NAME 🌸

clang-22 — clang LLVM compiler for oneAPI ✨

---

✨ DESCRIPTION ✨

OVERVIEW: clang LLVM compiler 🫶

USAGE:

clang-22 [options] file...

Like, you give her some file...s and some [options] and she does her little compiler thing. iconic.

---

💖 OPTIONS 💖

okay so this is the big list, stay with me, we're going through ALL of them, no skipping (iykyk 😭):

• -### — Print (but do not run) the commands that would be run for this compilation. It's giving "let me show you my outfit before I leave the house" 👀
• --analyzer-output <value> — the report output format for the static analyzer. Pick your fighter: html, plist, plist-multi-file, plist-html, sarif, sarif-html, or text.
• --analyze — Run the static analyzer. she's judging your code (lovingly) 🔍
• -B <prefix> — Search $prefix$file for executables, libraries, and data files. If $prefix is a directory, search $prefix/$file instead.
• -b <arg> — Pass -b <arg> to the linker on AIX.
• -CC — Include comments from within macros in the preprocessed output. yes comments inside macros, she sees everything 💅
• -cl-denorms-are-zero — OpenCL only. Allow denormals to be flushed to zero.
• -cl-ext=<value> — OpenCL only. Enable or disable OpenCL extensions/optional features. The argument is a comma-separated sequence of one or more extension names, each prefixed by + or -.
• -cl-fast-relaxed-math — OpenCL only. Sets -cl-finite-math-only and -cl-unsafe-math-optimizations, and defines __FAST_RELAXED_MATH__.
• -cl-finite-math-only — OpenCL only. Allow floating-point optimizations that assume arguments and results are not NaNs or +-Inf.
• -cl-fp32-correctly-rounded-divide-sqrt — OpenCL only. Specify that single precision floating-point divide and sqrt used in the program source are correctly rounded. precision queen 👑
• -cl-kernel-arg-info — OpenCL only. Generate kernel argument metadata.
• -cl-mad-enable — OpenCL only. Allow use of less precise MAD computations in the generated binary.
• -cl-no-signed-zeros — OpenCL only. Allow use of less precise no signed zeros computations in the generated binary.
• -cl-no-stdinc — OpenCL only. Disables all standard includes containing non-native compiler types and functions.
• -cl-opt-disable — OpenCL only. This option disables all optimizations. By default optimizations are enabled.
• -cl-single-precision-constant — OpenCL only. Treat double precision floating-point constant as single precision constant.
• -cl-std=<value> — OpenCL language standard to compile for.
• -cl-strict-aliasing — OpenCL only. This option is added for compatibility with OpenCL 1.0.
• -cl-uniform-work-group-size — OpenCL only. Defines that the global work-size be a multiple of the work-group size specified to clEnqueueNDRangeKernel.
• -cl-unsafe-math-optimizations — OpenCL only. Allow unsafe floating-point optimizations. Also implies -cl-no-signed-zeros and -cl-mad-enable. ⚠️ unsafe is right there in the name bestie.
• -clangir-disable-passes — Disable CIR transformations pipeline.
• -clangir-disable-verifier — ClangIR: Disable MLIR module verifier.
• --config=<file> — Specify configuration file.
• --cuda-compile-host-device — Compile CUDA code for both host and device (this is the default, she's an overachiever). Has no effect on non-CUDA compilations.
• --cuda-device-only — Compile CUDA code for device only.
• --cuda-feature=<value> — Manually specify the CUDA feature to use.
• --cuda-host-only — Compile CUDA code for host only. Has no effect on non-CUDA compilations.
• --cuda-include-ptx=<value> — Include PTX for the following GPU architecture (e.g. sm_35) or 'all'. May be specified more than once.
• --cuda-noopt-device-debug — Enable device-side debug info generation. Disables ptxas optimizations.
• --cuda-path-ignore-env — Ignore environment variables to detect CUDA installation.
• --cuda-path=<value> — CUDA installation path.
• -cuid=<value> — 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> — Add directory to the C++ SYSTEM include search path.
• -C — Include comments in preprocessed output.
• -c — Only run preprocess, compile, and assemble steps. short and efficient, we respect her 🎀
• -darwin-target-variant-triple <value> — Specify the darwin target variant triple.
• -darwin-target-variant <value> — Generate code for an additional runtime variant of the deployment target.
• -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> — Filename (or -) to write dependency output to.
• -dI — Print include directives in -E mode in addition to normal output.
• -dM — Print macro definitions in -E mode instead of normal output.
• -dsym-dir <dir> — Directory to output dSYM's (if any) to.
• -dumpdir <dumppfx> — Use <dumpfpx> as a prefix to form auxiliary and dump file names.
• -dumpmachine — Display the compiler's target processor.
• -dumpversion — Display the version of the compiler.
• -D <macro>=<value> — Define <macro> to <value> (or 1 if <value> omitted).
• --embed-dir=<dir> — Add directory to embed search path.
• -emit-ast — Emit Clang AST files for source inputs.
• -emit-cir — Build ASTs and then lower to ClangIR.
• --emit-extension-symbol-graphs — Generate additional symbol graphs for extended modules.
• -emit-interface-stubs — Generate Interface Stub Files.
• -emit-llvm — Use the LLVM representation for assembler and object files.
• -emit-merged-ifs — Generate Interface Stub Files, emit merged text not binary.
• --emit-static-lib — Enable linker job to emit a static library.
• -emit-symbol-graph — Generate Extract API information as a side effect of compilation.
• --end-no-unused-arguments — Start emitting warnings for unused driver arguments.
• --extract-api-ignores=<value> — Comma separated list of files containing a new line separated list of API symbols to ignore when extracting API information.
• -extract-api — Extract API information.
• -E — Only run the preprocessor.
• -faapcs-bitfield-load — Follows the AAPCS standard that all volatile bit-field write generates at least one load. (ARM only).
• -faapcs-bitfield-width — Follow the AAPCS standard requirement stating that volatile bit-field width is dictated by the field container type. (ARM only).
• -faarch64-jump-table-hardening — Use hardened lowering for jump-table dispatch. 🛡️
• -faddrsig — Emit an address-significance table.
• -falign-loops=<N> — N must be a power of two. Align loops to the boundary.
• -faligned-allocation — Enable C++17 aligned allocation functions.
• -falloc-token-max=<N> — Limit to maximum N allocation tokens (0 = target SIZE_MAX).
• -fallow-editor-placeholders — Treat editor placeholders as valid source code.
• -fallow-runtime-check-skip-hot-cutoff=<value> — Exclude __builtin_allow_runtime_check for the top hottest code responsible for the given fraction of PGO counters (0.0 [default] = skip none; 1.0 = skip all). Argument format: <value>.
• -faltivec-src-compat=<value> — 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 — Use ANSI escape codes for diagnostics. colorful errors, we love to see it 🌈
• -fapinotes-modules — Enable module-based external API notes support.
• -fapinotes-swift-version=<version> — Specify the Swift version to use when filtering API notes.
• -fapinotes — Enable external API notes support.
• -fapple-kext — Use Apple's kernel extensions ABI.
• -fapple-link-rtlib — Force linking the clang builtins runtime library.
• -fapple-pragma-pack — Enable Apple gcc-compatible #pragma pack handling.
• -fapplication-extension — Restrict code to those available for App Extensions.
• -fapprox-func — Allow certain math function calls to be replaced with an approximately equivalent calculation.
• -fassume-nothrow-exception-dtor — Assume that exception objects' destructors are non-throwing.
• -fasync-exceptions — Enable EH Asynchronous exceptions.
• -fatomic-fine-grained-memory — May have atomic operations on fine-grained memory.
• -fatomic-ignore-denormal-mode — Allow atomic operations to ignore denormal mode.
• -fatomic-remote-memory — May have atomic operations on remote memory.
• -fauto-import — MinGW specific. Enable code generation support for automatic dllimport, and enable support for it in the linker. Enabled by default.
• -fbasic-block-address-map — Emit the basic block address map section.
• -fbasic-block-sections=<value> — Place each function's basic blocks in unique sections (ELF Only).
• -fbinutils-version=<major.minor> — 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 — Enable the 'blocks' language feature.
• -fborland-extensions — Accept non-standard constructs supported by the Borland compiler.
• -fbuild-session-file=<file> — Use the last modification time of <file> as the build session timestamp.
• -fbuild-session-timestamp=<time since Epoch in seconds> — Time when the current build session started.
• -fbuiltin-module-map — Load the clang builtins module map file.
• -fc++-abi=<value> — C++ ABI to use. This will override the target C++ ABI.
• -fc++-static-destructors=<value> — Controls which variables C++ static destructors are registered for.
• -fcall-saved-x10 — Make the x10 register call-saved (AArch64 only).
• -fcall-saved-x11 — Make the x11 register call-saved (AArch64 only).
• -fcall-saved-x12 — Make the x12 register call-saved (AArch64 only).

---

okay that's the vibe so far, and there is so much more coming in the next parts — don't go anywhere 💖

• -fcall-saved-x13 — makes the x13 register call-saved 💅 (AArch64 only)
• -fcall-saved-x14 — makes the x14 register call-saved 💅 (AArch64 only)
• -fcall-saved-x15 — makes the x15 register call-saved 💅 (AArch64 only)
• -fcall-saved-x18 — makes the x18 register call-saved 💅 (AArch64 only)
• -fcall-saved-x8 — makes the x8 register call-saved 💅 (AArch64 only)
• -fcall-saved-x9 — makes the x9 register call-saved 💅 (AArch64 only)
• -fcaret-diagnostics-max-lines=<value> — caps how many source lines get shown in a caret diagnostic. Set it to 0 and there's, like, no limit at all ✨
• -fcf-protection=<value> — instruments control-flow architecture protection 🛡️
• -fcf-protection — turns cf-protection on in 'full' mode, periodt 💅
• -fchar8_t — enables the C++ builtin type char8_t 🌸
• -fcheck-new — don't assume C++ operator new might not return NULL 🫶
• -fclang-abi-compat=<version> — tries to match the ABI of Clang <version> 👑
• -fclangir — uses the ClangIR pipeline to compile 🔥
• -fcodegen-data-generate=<path> — emits codegen data into the object file. LLD for MachO (currently) merges them into the <path> you specified 💾
• -fcodegen-data-generate — emits codegen data into the object file. LLD for MachO (currently) merges them into default.cgdata 💾
• -fcodegen-data-use=<path> — uses codegen data read from the <path> you gave it 📖
• -fcodegen-data-use — uses codegen data read from default.cgdata to optimize the binary 📖
• -fcolor-diagnostics — enables colors in diagnostics 🌈✨
• -fcomment-block-commands=<arg> — treats each comma separated argument inside <arg> as a documentation comment block command 📝
• -fcommon — places uninitialized global variables in a common block 🧱
• -fcomplete-member-pointers — requires member pointer base types to be complete if they'd be significant under the Microsoft ABI 💅
• -fcomplex-arithmetic=<value> — controls the calculation methods used for complex number multiplication and division 🧮
• -fconstexpr-backtrace-limit=<value> — sets the max number of entries to print in a constexpr evaluation backtrace (0 = no limit) 💀
• -fconstexpr-depth=<value> — sets the max depth of recursive constexpr function calls 🌀
• -fconstexpr-steps=<value> — sets the max number of steps in constexpr function evaluation (0 = no limit) 🌀
• -fconvergent-functions — assumes all functions may be convergent 🤝
• -fcoro-aligned-allocation — prefers aligned allocation for C++ Coroutines 🎀
• -fcoroutines — enables support for the C++ Coroutines 🎀
• -fcoverage-compilation-dir=<value> — the compilation directory to embed in the coverage mapping 📂
• -fcoverage-mapping — generates coverage mapping so you can do code coverage analysis 📊
• -fcoverage-mcdc — enables MC/DC criteria when generating code coverage 📊
• -fcoverage-prefix-map=<old>=<new> — remaps file source paths <old> to <new> in coverage mapping. Heads up bestie: if there are multiple options, prefix replacement is applied in reverse order, starting from the last one 🙈
• -fcrash-diagnostics-dir=<dir> — puts crash-report files in <dir> 💥
• -fcrash-diagnostics=<value> — sets the level of crash diagnostic reporting (option: off, compiler, all) 💥
• -fcrash-diagnostics — enables crash diagnostic reporting (this is the default btw) 💥
• -fcs-profile-generate=<directory> — generates instrumented code to collect context sensitive execution counts into <directory>/default.profraw (overridden by the LLVM_PROFILE_FILE env var) 📈
• -fcs-profile-generate — generates instrumented code to collect context sensitive execution counts into default.profraw (overridden by the LLVM_PROFILE_FILE env var) 📈
• -fcuda-prec-sqrt — specifies that sqrt is correctly rounded (for CUDA devices) 🎯
• -fcuda-short-ptr — uses 32-bit pointers for accessing const/local/shared address spaces 🎯
• -fcx-fortran-rules — range reduction is enabled for complex arithmetic operations 🧮
• -fcx-limited-range — basic algebraic expansions of complex arithmetic operations involving are enabled 🧮
• -fcxx-exceptions — enables C++ exceptions 🚨
• -fcxx-modules — enables modules for C++ 📦
• -fdata-sections — places each data in its own section 🗂️
• -fdebug-compilation-dir=<value> — the compilation directory to embed in the debug info 🐛
• -fdebug-default-version=<value> — the default DWARF version to use, if a -g option caused DWARF debug info to be produced 🐛
• -fdebug-info-for-profiling — emits extra debug info to make the sample profile more accurate 🎯
• -fdebug-macro — emits macro debug information 🐛
• -fdebug-prefix-map=<old>=<new> — for paths in debug info, remaps directory <old> to <new>. If multiple options match a path, the last option wins 👑
• -fdebug-ranges-base-address — uses DWARF base address selection entries in .debug_ranges 🐛
• -fdebug-types-section — places debug types in their own section (ELF Only) 🐛
• -fdeclspec — allows __declspec as a keyword 💅
• -fdefer-ts — enables support for the C '_Defer' Technical Specification ⏳
• -fdefine-target-os-macros — enables predefined target OS macros 🌍
• -fdelayed-template-parsing — parses templated function definitions at the end of the translation unit ⏰
• -fdelete-null-pointer-checks — treats usage of null pointers as undefined behavior (and yes, this is the default) 💀
• -fdevirtualize-speculatively — enables speculative devirtualization optimization 🔮
• -fdiagnostics-absolute-paths — prints absolute paths in diagnostics 📍
• -fdiagnostics-color=<value> — when to use colors in diagnostics 🌈
• -fdiagnostics-hotness-threshold=<value> — prevents optimization remarks from being output if they don't have at least this profile count. Use 'auto' to apply the threshold from the profile summary 🔥
• -fdiagnostics-misexpect-tolerance=<value> — prevents misexpect diagnostics from being output if the profile counts are within N% of the expected 🙈
• -fdiagnostics-parseable-fixits — prints fix-its in machine parseable form 🤖
• -fdiagnostics-print-source-range-info — prints source range spans in numeric form 🔢
• -fdiagnostics-show-hotness — enables profile hotness information in the diagnostic line 🔥
• -fdiagnostics-show-note-include-stack — displays include stacks for diagnostic notes 📚
• -fdiagnostics-show-option — prints the option name along with mappable diagnostics 🏷️
• -fdiagnostics-show-template-tree — prints a template comparison tree for differing templates 🌳
• -fdigraphs — enables alternative token representations '<:', ':>', '<%', '%>', '%:', '%:%:' (this one's the default btw) ✨
• -fdirect-access-external-data — don't use GOT indirection to reference external data symbols 🚀
• -fdisable-block-signature-string — disable block signature string 🙅
• -fdiscard-value-names — discards value names in LLVM IR 🗑️
• -fdollars-in-identifiers — allows '$' in identifiers 💰
• -fdriver-only — only runs the driver 🚗
• -fdwarf-exceptions — uses DWARF style exceptions 🐛
• -feliminate-unused-debug-types — do not emit debug info for defined but unused types 🚫
• -fembed-bitcode-marker — embeds placeholder LLVM IR data as a marker 📌
• -fembed-bitcode=<option> — embeds LLVM bitcode 💾
• -fembed-bitcode — embeds LLVM IR bitcode as data 💾
• -fembed-offload-object=<value> — embeds Offloading device-side binary into the host object file as a section 📦
• -femit-all-decls — emits all declarations, even if unused 📢
• -femit-compact-unwind-non-canonical — tries emitting Compact-Unwind for non-canonical entries. This maybe gets overridden by other constraints 🙈
• -femit-dwarf-unwind=<value> — when to emit DWARF unwind (EH frame) info 🐛
• -femulated-tls — uses emutls functions to access thread_local variables 🧵
• -fenable-matrix — enables the matrix data type and related builtin functions 🔢
• -fexceptions — enables support for exception handling 🚨
• -fexcess-precision=<value> — lets you control excess precision on targets where native support for the precision types isn't available. By default, excess precision is used to calculate intermediate results following the rules specified in ISO C99 🎯
• -fexperimental-call-graph-section — emits a call graph section 🕸️
• -fexperimental-late-parse-attributes — enables experimental late parsing of attributes 🧪
• -fexperimental-library — controls whether unstable and experimental library features are enabled. This option enables various library features that are either experimental (also known as TSes), or have been but are not stable yet in the selected Standard Library implementation. It is not recommended to use this option in production code, since neither ABI nor API stability are guaranteed. This is intended to provide a preview of features that will ship in the future for experimentation purposes 🧪
• -fexperimental-loop-fusion — enable the loop fusion pass 🔁
• -fexperimental-new-constant-interpreter — enables the experimental new constant interpreter 🧪
• -fexperimental-openacc-macro-override <value> — overrides the _OPENACC macro value for experimental testing during OpenACC support development 🧪
• -fexperimental-relative-c++-abi-vtables — uses the experimental C++ class ABI for classes with virtual tables 🧪
• -fexperimental-sanitize-metadata-ignorelist=<value> — disables sanitizer metadata for modules and functions that match the provided special case list 🙅
• -fexperimental-sanitize-metadata=<value> — specifies the type of metadata to emit for binary analysis sanitizers 🧪
• -fexperimental-strict-floating-point — enables the use of non-default rounding modes and non-default exception handling on targets that are not currently ready 😬 (like, it literally says they're not ready bestie)
• -fextend-arguments=<value> — controls how scalar integer arguments are extended in calls to unprototyped and varargs functions 📏
• -fextend-variable-liveness=<value> — extends the liveness of user variables through optimizations to prevent stale or optimized-out variable values when debugging 🐛
• -fextend-variable-liveness — alias for -fextend-variable-liveness=all 🔁
• -ffast-math — allows aggressive, lossy floating-point optimizations ⚡ (emphasis on lossy, it's giving risky)
• -ffat-lto-objects — enables fat LTO object support 🍔
• -ffile-compilation-dir=<value> — tells the compiler which compilation directory to bake into the debug info and the coverage mapping. like, so your debugger knows where home is 💅
• -ffile-prefix-map=<value> — remaps file source paths everywhere it matters: debug info, coverage mapping, predefined preprocessor macros, and __builtin_FILE(). it also implies -ffile-reproducible, so you get that for free ✨
• -ffile-reproducible — uses the target's platform-specific path separator character when it expands the __FILE__ macro. yes bestie, that's the whole thing 🎀
• -ffine-grained-bitfield-accesses — uses separate accesses for consecutive bitfield runs whose widths and alignments are legal. small bites, cuter bites 🍓
• -ffinite-loops — assumes all non-trivial loops are finite. bold assumption, hope it's right 😭
• -ffinite-math-only — allows floating-point optimizations that assume arguments and results are not NaNs or +-inf. and it defines the __FINITE_MATH_ONLY__ preprocessor macro. so if your math is cursed, this is gonna be a whole situation 💀
• -ffixed-a0 — reserve the a0 register (M68k only)
• -ffixed-a1 — reserve the a1 register (M68k only)
• -ffixed-a2 — reserve the a2 register (M68k only)
• -ffixed-a3 — reserve the a3 register (M68k only)
• -ffixed-a4 — reserve the a4 register (M68k only)
• -ffixed-a5 — reserve the a5 register (M68k only)
• -ffixed-a6 — reserve the a6 register (M68k only)
• -ffixed-d0 — reserve the d0 register (M68k only)
• -ffixed-d1 — reserve the d1 register (M68k only)
• -ffixed-d2 — reserve the d2 register (M68k only)
• -ffixed-d3 — reserve the d3 register (M68k only)
• -ffixed-d4 — reserve the d4 register (M68k only)
• -ffixed-d5 — reserve the d5 register (M68k only)
• -ffixed-d6 — reserve the d6 register (M68k only)
• -ffixed-d7 — reserve the d7 register (M68k only)

okay so this is where it gets VERY "reserve the register" — the compiler is basically moving in and claiming the good seats and you cannot sit there. no cap. moving on to the SPARC benches 💜

• -ffixed-g1 — reserve the G1 register (SPARC only)
• -ffixed-g2 — reserve the G2 register (SPARC only)
• -ffixed-g3 — reserve the G3 register (SPARC only)
• -ffixed-g4 — reserve the G4 register (SPARC only)
• -ffixed-g5 — reserve the G5 register (SPARC only)
• -ffixed-g6 — reserve the G6 register (SPARC only)
• -ffixed-g7 — reserve the G7 register (SPARC only)
• -ffixed-i0 — reserve the I0 register (SPARC only)
• -ffixed-i1 — reserve the I1 register (SPARC only)
• -ffixed-i2 — reserve the I2 register (SPARC only)
• -ffixed-i3 — reserve the I3 register (SPARC only)
• -ffixed-i4 — reserve the I4 register (SPARC only)
• -ffixed-i5 — reserve the I5 register (SPARC only)
• -ffixed-l0 — reserve the L0 register (SPARC only)
• -ffixed-l1 — reserve the L1 register (SPARC only)
• -ffixed-l2 — reserve the L2 register (SPARC only)
• -ffixed-l3 — reserve the L3 register (SPARC only)
• -ffixed-l4 — reserve the L4 register (SPARC only)
• -ffixed-l5 — reserve the L5 register (SPARC only)
• -ffixed-l6 — reserve the L6 register (SPARC only)
• -ffixed-l7 — reserve the L7 register (SPARC only)
• -ffixed-o0 — reserve the O0 register (SPARC only)
• -ffixed-o1 — reserve the O1 register (SPARC only)
• -ffixed-o2 — reserve the O2 register (SPARC only)
• -ffixed-o3 — reserve the O3 register (SPARC only)
• -ffixed-o4 — reserve the O4 register (SPARC only)
• -ffixed-o5 — reserve the O5 register (SPARC only)
• -ffixed-point — enable fixed point types. it's giving "decimals but obsessed with staying put" 🌸
• -ffixed-r19 — reserve register r19 (Hexagon only)
• -ffixed-r9 — reserve the r9 register (ARM only)

and now we get to the AArch64/RISC-V section, which is literally just "reserve the x-something register" for like thirty options. it's iconic actually. the compiler said "everybody gets a boundary" 😌

• -ffixed-x10 — reserve the x10 register (AArch64/RISC-V only)
• -ffixed-x11 — reserve the x11 register (AArch64/RISC-V only)
• -ffixed-x12 — reserve the x12 register (AArch64/RISC-V only)
• -ffixed-x13 — reserve the x13 register (AArch64/RISC-V only)
• -ffixed-x14 — reserve the x14 register (AArch64/RISC-V only)
• -ffixed-x15 — reserve the x15 register (AArch64/RISC-V only)
• -ffixed-x16 — reserve the x16 register (AArch64/RISC-V only)
• -ffixed-x17 — reserve the x17 register (AArch64/RISC-V only)
• -ffixed-x18 — reserve the x18 register (AArch64/RISC-V only)
• -ffixed-x19 — reserve the x19 register (AArch64/RISC-V only)
• -ffixed-x1 — reserve the x1 register (AArch64/RISC-V only)
• -ffixed-x20 — reserve the x20 register (AArch64/RISC-V only)
• -ffixed-x21 — reserve the x21 register (AArch64/RISC-V only)
• -ffixed-x22 — reserve the x22 register (AArch64/RISC-V only)
• -ffixed-x23 — reserve the x23 register (AArch64/RISC-V only)
• -ffixed-x24 — reserve the x24 register (AArch64/RISC-V only)
• -ffixed-x25 — reserve the x25 register (AArch64/RISC-V only)
• -ffixed-x26 — reserve the x26 register (AArch64/RISC-V only)
• -ffixed-x27 — reserve the x27 register (AArch64/RISC-V only)
• -ffixed-x28 — reserve the x28 register (AArch64/RISC-V only)
• -ffixed-x29 — reserve the x29 register (AArch64/RISC-V only)
• -ffixed-x2 — reserve the x2 register (AArch64/RISC-V only)
• -ffixed-x30 — reserve the x30 register (AArch64/RISC-V only)
• -ffixed-x31 — reserve the x31 register (AArch64/RISC-V only)
• -ffixed-x3 — reserve the x3 register (AArch64/RISC-V only)
• -ffixed-x4 — reserve the x4 register (AArch64/RISC-V only)
• -ffixed-x5 — reserve the x5 register (AArch64/RISC-V only)
• -ffixed-x6 — reserve the x6 register (AArch64/RISC-V only)
• -ffixed-x7 — reserve the x7 register (AArch64/RISC-V only)
• -ffixed-x8 — reserve the x8 register (AArch64/RISC-V only)
• -ffixed-x9 — reserve the x9 register (AArch64/RISC-V only)

periodt. register drama over, back to your regularly scheduled compiler flags 🦋

• -fforce-check-cxx20-modules-input-files — checks the input source files from C++20 modules explicitly. no vibes-based skipping allowed 🔍
• -fforce-dwarf-frame — always emit a debug frame section. always always 🌈
• -fforce-emit-vtables — emits more virtual tables to improve devirtualization. more tables, more devirtualizing, we love to see it ✨
• -fforce-enable-int128 — enable support for the int128_t type. big numbers, big energy 👑
• -ffp-accuracy=<value> — specifies the required accuracy for floating-point operations and library calls.
• -ffp-contract=<value> — forms fused FP ops (e.g. FMAs)
• -ffp-eval-method=<value> — specifies the evaluation method to use for floating-point arithmetic.
• -ffp-exception-behavior=<value> — specifies the exception behavior of floating-point operations.
• -ffp-model=<value> — controls the semantics of floating-point calculations.
• -ffreestanding — asserts that the compilation takes place in a freestanding environment. no host, no problem 🧚
• -ffuchsia-api-level=<value> — sets the Fuchsia API level.
• -ffunction-sections — puts each function in its own section. everyone gets their own room, main character energy fr fr 💅
• -fglobal-isel — enables the global instruction selector.
• -fgnu-keywords — allows GNU-extension keywords regardless of the language standard. rules? never heard of her 🙈
• -fgnu-runtime — generates output compatible with the standard GNU Objective-C runtime.
• -fgnu89-inline — uses the gnu89 inline semantics.
• -fgnuc-version=<value> — sets various macros to claim compatibility with the given GCC version; the default is 4.2.1. yes bestie, it just says it's that version. fake it till you make it 💀
• -fgpu-allow-device-init — allow device side init function in HIP (experimental). it's marked experimental so treat it like a situationship, careful 😭
• -fgpu-approx-transcendentals — use approximate transcendental functions.
• -fgpu-default-stream=<value> — specify default stream. the default value is legacy. (CUDA/HIP only)
• -fgpu-defer-diag — defer host/device related diagnostic messages for CUDA/HIP.
• -fgpu-flush-denormals-to-zero — flush denormal floating point values to zero in CUDA/HIP device mode.
• -fgpu-rdc — generate relocatable device code, also known as separate compilation mode.
• -fgpu-sanitize — enable sanitizer for supported offloading devices.
• -fheinous-gnu-extensions — (deprecated) controls whether -Winvalid-gnu-asm-cast defaults to an error or a warning. deprecated bestie, it's giving "we don't do that anymore" 🎀
• -fhip-emit-relocatable — compile HIP source to relocatable.
• -fhip-fp32-correctly-rounded-divide-sqrt — specify that single precision floating-point divide and sqrt used in the program source are correctly rounded (HIP device compilation only).
• -fhip-kernel-arg-name — specify that kernel argument names are preserved (HIP only).
• -fhip-new-launch-api — use new kernel launching API for HIP.
• -fhlsl-strict-availability — enables strict availability diagnostic mode for HLSL built-in functions.
• -fhonor-infinities — specify that floating-point optimizations are not allowed that assume arguments and results are not +-inf. so infinity gets respect 💖
• -fhonor-nans — specify that floating-point optimizations are not allowed that assume arguments and results are not NANs. NaN rights 🫶
• -fignore-exceptions — enable support for ignoring exception handling constructs. we simply do not perceive them ✨
• -fimplicit-module-maps — implicitly search the file system for module map files.
• -fincremental-extensions — enable incremental processing extensions such as processing statements on the global scope.
• -finit-global-zero — zero initialize globals without default initialization (default). it's the default, so like, it's already doing this unless you said otherwise 💅
• -finline-functions — inline suitable functions.
• -finline-hint-functions — inline functions which are (explicitly or implicitly) marked inline.
• -finline-max-stacksize=<value> — suppress inlining of functions whose stack size exceeds the given value. if your stack is too thicc, you're not coming in 📏
• -finput-charset=<value> — specify the default character set for source files.
• -finstrument-function-entry-bare — instrument function entry only, after inlining, without arguments to the instrumentation call.
• -finstrument-functions-after-inlining — like -finstrument-functions, but insert the calls after inlining.
• -finstrument-functions — generate calls to instrument function entry and exit.
• -fintegrated-as — enable the integrated assembler.
• -fintegrated-cc1 — run cc1 in-process.
• -fintegrated-objemitter — use internal machine object code emitter.
• -fjmc — enable just-my-code debugging.
• -fjump-tables — use jump tables for lowering switches.
• -fkeep-persistent-storage-variables — keeps every variable with persistent storage duration alive and well, so globals, statics and thread-local variables all get to stay 🔒 the whole point is guaranteeing you can directly address them, bestie.
• -fkeep-static-consts — keeps those static const variables around even when nobody's using them 🥺 no variable left behind fr fr.
• -fkeep-system-includes — okay so instead of expanding system headers when you're emitting preprocessor output, this one preserves the #include directive ✨ super handy when you're making preprocessed output for test case reduction. But listen: it can produce incorrect output if preprocessor symbols that control the included content (like _XOPEN_SOURCE) are defined in the including source file 😭 and, ngl, the portability of the resulting source to other compilation environments is not guaranteed. Only valid with -E, periodt.
• -flax-vector-conversions=<value> — turns on implicit vector bit-casts 🦋 let them cast, let them slay.
• -flink-huge-device-code — generates and uses a custom linker script for those huge device code sections 💅 big section energy.
• -floop-interchange — enables the loop interchange pass 🔄 iconic compiler optimization behavior.
• -flto-jobs=<value> — controls the backend parallelism of -flto=thin ✨ and the default of 0 means the number of threads gets derived from the number of CPUs detected, so basically it counts your cores and goes off 👑
• -flto-partitions=<value> — how many partitions to use for parallel full LTO codegen. ld.lld only, just so you know 🫶
• -flto=auto — enables LTO in 'full' mode 🔥
• -flto=jobserver — enables LTO in 'full' mode 🔥 (same mode, different flavor of "yes").
• -flto=<value> — sets the LTO mode ⚙️ you pick, it does.
• -flto — enables LTO in 'full' mode 💖
• -fmacro-backtrace-limit=<value> — sets the max number of entries to print in a macro expansion backtrace, and 0 = no limit 🌈 (yes, "no limit" is a real choice and it is chaotic of you).
• -fmacro-prefix-map=<value> — remaps file source paths inside predefined preprocessor macros and __builtin_FILE() 📁 and heads up, it implies -ffile-reproducible.
• -fmath-errno — requires math functions to indicate errors by setting errno 🚨 they gotta tell you when something's wrong, communication is key bestie.
• -fmatrix-memory-layout=<value> — sets the matrix memory layout, either row-major or column-major 🎀 pick your lane.
• -fmax-tokens=<value> — the max total number of preprocessed tokens, used for -Wmax-tokens. 🧮
• -fmax-type-align=<value> — specifies the maximum alignment to enforce on pointers that don't have an explicit alignment 📐.
• -fmemory-profile-use=<pathname> — uses a memory profile for profile-guided memory optimization 🧠✨.
• -fmemory-profile=<directory> — enables heap memory profiling and dumps the results into <directory> 📂.
• -fmemory-profile — enables heap memory profiling, no directory specified, no notes 💜.
• -fmerge-all-constants — allows merging of constants 🫂 let the constants be friends.
• -fmessage-length=<value> — formats message diagnostics so they fit within N columns 📏 tidy little diagnostics, we love to see it.
• -fminimize-whitespace — ignores the whitespace from the input file when emitting preprocessor output 🌸 it'll only contain whitespace when it's necessary, e.g. to keep two minus signs from merging into an increment operator. Super useful with the -P option to normalize whitespace such that two files with only formatting changes come out equal ✨ Important: only valid with -E on C-like inputs, and it's incompatible with -traditional-cpp 😭 pick one, you can't have both.
• -fmodule-file=[<name>=]<file> — specifies the mapping of module name to precompiled module file, or just loads a module file if the name is omitted 💅 flexible.
• -fmodule-header=<kind> — builds a C++20 Header Unit from a header that should be found in the user search path (fmodule-header=user) or the system search path (fmodule-header=system) 🔍.
• -fmodule-header — builds a C++20 Header Unit from a header 🎀 the short version.
• -fmodule-map-file=<file> — loads this module map file 📜.
• -fmodule-name=<name> — specifies the name of the module to build 🏷️ name it, claim it.
• -fmodule-output=<value> — saves intermediate module file results when compiling a standard C++ module unit 💾.
• -fmodule-output — saves intermediate module file results when compiling a standard C++ module unit 💾 (same deal, no argument).
• -fmodulemap-allow-subdirectory-search — allows searching for module maps in subdirectories of search paths 🗂️ dig deeper.
• -fmodules-cache-path=<directory> — specifies the module cache path 🧺 where the modules go to chill.
• -fmodules-decluse — requires declaration of modules used within a module 📝 no sneaky undeclared usage.
• -fmodules-disable-diagnostic-validation — disables validation of the diagnostic options when loading the module 🙈.
• -fmodules-embed-all-files<value> — embeds the contents of all files read by this compilation into the produced module file 📦 everything, in the box.
• -fmodules-force-validate-user-headers — forces validation of user headers when repeatedly loading a module file within a single build session 🔁.
• -fmodules-ignore-macro=<value> — ignores the definition of the given macro when building and loading modules 🙅♀️.
• -fmodules-prune-after=<seconds> — specifies the interval (in seconds) after which a module file will be considered unused ⏳.
• -fmodules-prune-interval=<seconds> — specifies the interval (in seconds) between attempts to prune the module cache 🧹.
• -fmodules-reduced-bmi — generates the reduced BMI ✨.
• -fmodules-search-all — searches even non-imported modules to resolve references 🔎.
• -fmodules-strict-decluse — like -fmodules-decluse but requires all headers to be in modules 😤 stricter, no exceptions.
• -fmodules-user-build-path <directory> — specifies the module user build path 🛠️.
• -fmodules-validate-input-files-content — validates PCM input files based on content if the mtime differs 🕵️ content over timestamps.
• -fmodules-validate-once-per-build-session — doesn't verify input files for the modules if the module has already been successfully validated or loaded during this build session ✅ trust the process.
• -fmodules-validate-system-headers — validates the system headers that a module depends on when loading the module 🩺.
• -fmodules — enables the 'modules' language feature 💫.
• -fms-compatibility-version=<value> — a dot-separated value representing the Microsoft compiler version number to report in _MSC_VER, and 0 = don't define it (that's the default) 🪟.
• -fms-compatibility — enables full Microsoft Visual C++ compatibility 🧩.
• -fms-define-stdc — defines '__STDC__' to '1' in MSVC Compatibility mode 🏷️.
• -fms-extensions — accepts some non-standard constructs supported by the Microsoft compiler 🤝.
• -fms-hotpatch — ensures that all functions can be hotpatched at runtime 🔥🩹.
• -fms-runtime-lib=<value> — selects the Windows run-time library 🪟📚.
• -fms-secure-hotpatch-functions-file=<value> — path to a file that contains a list of mangled names of functions that should be hot-patched for Windows Secure Hot-Patching 📄🔐.
• -fms-secure-hotpatch-functions-list=<value> — a list of mangled symbol names of functions that should be hot-patched for Windows Secure Hot-Patching 📋🔐.
• -fms-volatile — volatile loads and stores have acquire and release semantics ⚡.
• -fmsc-version=<value> — Microsoft compiler version number to report in _MSC_VER, and 0 = don't define it (default) 🪟.
• -fnamed-loops — enables support for named loops 🏷️🔄.
• -fnew-alignment=<align> — specifies the largest alignment guaranteed by '::operator new(size_t)' 📐.
• -fnew-infallible — enables treating throwing global C++ operator new as always returning valid memory 😌 it annotates with __attribute__((returns_nonnull)) and throw(). And yes, this is detectable in source 👀.
• -fno-aapcs-bitfield-width — does not follow the AAPCS standard requirement stating that volatile bit-field width is dictated by the field container type 🚫📏 (ARM only).
• -fno-access-control — disables C++ access control 😈 private? never heard of her.
• -fno-addrsig — doesn't emit an address-significance table 🙅.
• -fno-apinotes-modules — disables module-based external API notes support 📝🚫.
• -fno-apinotes — disables external API notes support 🚫.
• -fno-assume-sane-operator-new — doesn't assume that C++'s global operator new can't alias any pointer 🤨 assume nothing bestie.
• -fno-assume-unique-vtables — disables optimizations based on vtable pointer identity 🧬.
• -fno-assumptions — disables codegen and compile-time checks for C++23's [[assume]] attribute 🚫🤔.
• -fno-atomic-fine-grained-memory — assumes no atomic operations on fine-grained memory 🧵.
• -fno-atomic-ignore-denormal-mode — disallows atomic operations from ignoring denormal mode 🚫🌀.
• -fno-atomic-remote-memory — assumes no atomic operations on remote memory 📡.
• -fno-auto-import — MinGW specific 🐧 disables support for automatic dllimport in code generation and linking.
• -fno-autolink — disables generation of linker directives for automatic library linking 🔗🚫.
• -fno-builtin-<value> — disables implicit builtin knowledge of one specific function 🎯.
• -fno-builtin — disables implicit builtin knowledge of functions, full stop 🛑.
• -fno-bundle-offload-arch — specifies that the offload bundler should not identify a bundle with a specific arch 📦 so like, for example, the bundle for nvptx64-nvidia-cuda-sm_80 uses the bundle tag nvptx64-nvidia-cuda when used. This lets .o files contain .bc bundles that are unspecific to a particular arch version ✨.
• -fno-c++-static-destructors — disables C++ static destructor registration 🚫💀.
• -fno-char8_t — disables the C++ builtin type char8_t 🔡🚫.
• -fno-clangir — uses the AST -> LLVM pipeline to compile 🌳➡️🔧.
• -fno-color-diagnostics — disables colors in diagnostics 🌈🚫 (sad, but sometimes necessary).
• -fno-common — compiles common globals like normal definitions 📦.
• -fno-complete-member-pointers — does not require member pointer base types to be complete if they would be significant under the Microsoft ABI 🪟🚫.
• -fno-constant-cfstrings — disables creation of CodeFoundation-type constant strings 🚫📄.
• -fno-coverage-mapping — disables code coverage analysis 📉🚫.
• -fno-coverage-mcdc — disables MC/DC coverage criteria 🚫🧪.
• -fno-crash-diagnostics — disables auto-generation of preprocessed source files and a script for reproduction when clang crashes 💥🚫 (so when it goes down, it goes down quietly, your call bestie).
• -fno-cuda-prec-sqrt — doesn't specify that sqrt is correctly rounded, for CUDA devices 🎮📐.
• -fno-cx-fortran-rules — range reduction is disabled for complex arithmetic operations 🌀🚫.
• -fno-cx-limited-range — basic algebraic expansions of complex arithmetic operations involving are disabled 🙈 (yes, that's the exact wording, keeping it verbatim for you).
• -fno-cxx-modules — disables modules for C++ 🚫📦.
• -fno-debug-macro — does not emit macro debug information 🐛🚫.
• -fno-declspec — disallows __declspec as a keyword 🚫🔑.
• -fno-define-target-os-macros — disables predefined target OS macros 🖥️🚫.
• -fno-delayed-template-parsing — Disable delayed template parsing. No more waiting around, bestie. ✨
• -fno-delete-null-pointer-checks — Do not treat usage of null pointers as undefined behavior. live your null-pointer truth, lowkey. 🦋
• -fno-diagnostics-fixit-info — Do not include fixit information in diagnostics. no little hints, just vibes. 💅
• -fno-diagnostics-show-line-numbers — Show line numbers in diagnostic code snippets. yes literally "Show" even though it's -fno, the page said it, periodt. 👑
• -fno-digraphs — Disallow alternative token representations '<:', ':>', '<%', '%>', '%:', '%:%:'. no digraphs allowed, sorry not sorry. 🎀
• -fno-direct-access-external-data — Use GOT indirection to reference external data symbols. GOT indirection, iconic. 🌈
• -fno-disable-block-signature-string — Don't disable block signature string) the stray ) is part of the lore, bestie. 💀
• -fno-discard-value-names — Do not discard value names in LLVM IR. keep the names, they're main character energy. 🌸
• -fno-dollars-in-identifiers — Disallow '$' in identifiers. no dollar signs in identifiers, even if capitalism said yes. 💸
• -fno-elide-constructors — Disable C++ copy constructor elision. copy constructors stay visible, no cap. 🦋
• -fno-elide-type — Do not elide types when printing diagnostics. full type names, no editing. ✨
• -fno-eliminate-unused-debug-types — Emit debug info for defined but unused types. even the unused types get their moment. 💖
• -fno-exceptions — Disable support for exception handling. no throw, no catch, just vibes. 💀
• -fno-experimental-late-parse-attributes — Disable experimental late parsing of attributes. late parsing? not today. 🧚
• -fno-experimental-loop-fusion — DisableEnable the loop fusion pass. it really says "DisableEnable", I'm just the messenger 😭 🔥
• -fno-experimental-relative-c++-abi-vtables — Do not use the experimental C++ class ABI for classes with virtual tables. no experimental vtable ABI, bestie. 👑
• -fno-experimental-sanitize-metadata=<value> — Disable emitting metadata for binary analysis sanitizers. metadata says bye. 🌈
• -fno-fat-lto-objects — Disable fat LTO object support. no fat LTO objects. 🎀
• -fno-file-reproducible — Use the host's platform-specific path separator character when expanding the __FILE__ macro. platform-specific path separator, slay. 💅
• -fno-fine-grained-bitfield-accesses — Use large-integer access for consecutive bitfield runs. large-integer access, period. 🦋
• -fno-finite-loops — Do not assume that any loop is finite. infinite loops are valid, bestie. 🌸
• -fno-fixed-point — Disable fixed point types. fixed point? not here. ✨
• -fno-force-enable-int128 — Disable support for int128_t type. no int128_t forcing. 💖
• -fno-global-isel — Disables the global instruction selector. global isel is off. 🧚
• -fno-gnu-inline-asm — Disable GNU style inline asm. no GNU inline asm, lowkey. 💀
• -fno-gpu-allow-device-init — Don't allow device side init function in HIP (experimental). experimental HIP device init, blocked. 🔥
• -fno-gpu-approx-transcendentals — Don't use approximate transcendental functions. no approximate transcendentals, bestie. 🌈
• -fno-gpu-defer-diag — Don't defer host/device related diagnostic messages for CUDA/HIP. diagnostics come through immediately. 👑
• -fno-hip-emit-relocatable — Do not override toolchain to compile HIP source to relocatable. relocatable HIP? not overridden. 💅
• -fno-hip-fp32-correctly-rounded-divide-sqrt — Don't specify that single precision floating-point divide and sqrt used in the program source are correctly rounded (HIP device compilation only). HIP device only, bestie. 🦋
• -fno-hip-kernel-arg-name — Don't specify that kernel argument names are preserved (HIP only). HIP only, no preservation. 🌸
• -fno-hip-new-launch-api — Don't use new kernel launching API for HIP. old API stays, period. ✨
• -fno-init-global-zero — Do not zero initialize globals without default initialization. no free zero init. 💖
• -fno-integrated-as — Disable the integrated assembler. external assembler era. 🧚
• -fno-integrated-cc1 — Spawn a separate process for each cc1. separate cc1 processes, every time. 🔥
• -fno-integrated-objemitter — Use external machine object code emitter. external object emitter, slay. 👑
• -fno-jump-tables — Do not use jump tables for lowering switches. no jump tables for switches. 🌈
• -fno-keep-persistent-storage-variables — Disable keeping all variables that have a persistent storage duration, including global, static and thread-local variables, to guarantee that they can be directly addressed. persistent storage variables, not kept. 💅
• -fno-keep-static-consts — Don't keep static const variables even if unused. unused static consts get yeeted. 🦋
• -fno-knr-functions — Disable support for K&R C function declarations. K&R functions? no. 🌸
• -fno-link-huge-device-code — Do not generate or use a custom linker script for huge device code sections (default). this is the default, bestie. ✨
• -fno-loop-interchange — Disable the loop interchange pass. loop interchange off. 💖
• -fno-lto — Disable LTO mode (default). default behavior, no LTO. 🧚
• -fno-memory-profile — Disable heap memory profiling. no heap memory profiling. 🔥
• -fno-merge-all-constants — Disallow merging of constants. constants stay separate, period. 👑
• -fno-modules-check-relocated<value> — Skip checks for relocated modules when loading PCM files. PCM files, skip checks. 🌈
• -fno-modules-force-validate-user-headers — Do not force validation of user headers when repeatedly loading a module file within single build session. single build session, no force validation. 💅
• -fno-modules-validate-textual-header-includes — Do not enforce -fmodules-decluse and private header restrictions for textual headers. This flag will be removed in a future Clang release. future removal warning, bestie. 🦋
• -fno-ms-tls-guards — Do not emit code to perform on-demand initialization of thread-local variables. no MS TLS guards. 🌸
• -fno-new-infallible — Disable treating throwing global C++ operator new as always returning valid memory (annotates with __attribute__((returns_nonnull)) and throw()). This is detectable in source. detectable in source, no cap. ✨
• -fno-objc-avoid-heapify-local-blocks — Don't try to avoid heapifying local blocks. local blocks get heapified. 💖
• -fno-objc-infer-related-result-type — do not infer Objective-C related result type based on method family. no inference from method family. 🧚
• -fno-offload-fp32-prec-div — fdiv operations in offload device code are not required to return correctly rounded results. offload fdiv, not correctly rounded required. 🔥
• -fno-offload-fp32-prec-sqrt — sqrt operations in offload device code are not required to return correctly rounded results. offload sqrt, same vibe. 👑
• -fno-offload-lto — Disable LTO mode (default) for offload compilation. default offload LTO off. 🌈
• -fno-offload-uniform-block — Don't assume that kernels are launched with uniform block sizes (default true for CUDA/HIP and false otherwise). default true for CUDA/HIP, false otherwise. 💅
• -fno-offload-via-llvm — Don't use LLVM/Offload as portable offloading runtime. no LLVM/Offload runtime. 🦋
• -fno-openmp-extensions — Disable all Clang extensions for OpenMP directives and clauses. no OpenMP extensions. 🌸
• -fno-openmp-simd — Do not emit code for any OpenMP constructs. no OpenMP code at all. ✨
• -fno-operator-names — Do not treat C++ operator name keywords as synonyms for operators. operator names are not synonyms. 💖
• -fno-optimize-sibling-calls — Disable tail call optimization, keeping the call stack accurate. accurate call stack, period. 🧚
• -fno-partition-static-data-sections — Disable partition static data sections using profile information (x86 and aarch64 ELF). x86 and aarch64 ELF only. 🔥
• -fno-pch-codegen — Do not generate code for uses of this PCH that assumes an explicit object file will be built for the PCH. PCH codegen, no. 👑
• -fno-pch-debuginfo — Do not generate debug info for types in an object file built from this PCH and do not generate them elsewhere. no PCH debuginfo. 🌈
• -fno-plt — Use GOT indirection instead of PLT to make external function calls (x86 only). x86 only, bestie. 💅
• -fno-preserve-as-comments — Do not preserve comments in inline assembly. inline asm comments, gone. 🦋
• -fno-profile-generate — Disable generation of profile instrumentation. no profile instrumentation. 🌸
• -fno-profile-instr-generate — Disable generation of profile instrumentation. same as above, iconic. ✨
• -fno-profile-instr-use — Disable using instrumentation data for profile-guided optimization. no PGO instrumentation data. 💖
• -fno-pseudo-probe-for-profiling — Do not emit pseudo probes for sample profiling. no pseudo probes. 🧚
• -fno-raw-string-literals — Disable raw string literals. raw string literals? no. 🔥
• -fno-register-global-dtors-with-atexit — Don't use atexit or __cxa_atexit to register global destructors. global dtors not registered that way. 👑
• -fno-rtlib-add-rpath — Do not add -rpath with architecture-specific resource directory to the linker flags. When --hip-link is specified, do not add -rpath with HIP runtime library directory to the linker flags. no rpath additions, bestie. 🌈
• -fno-rtlib-defaultlib — On Windows, do not emit /defaultlib: directives to link compiler-rt libraries. Windows only. 💅
• -fno-rtti-data — Disable generation of RTTI data. no RTTI data. 🦋
• -fno-rtti — Disable generation of rtti information. no rtti info at all. 🌸
• -fno-sanitize-address-globals-dead-stripping — Disable linker dead stripping of globals in AddressSanitizer. ASan globals not dead-stripped. ✨
• -fno-sanitize-address-outline-instrumentation — Use default code inlining logic for the address sanitizer. default inlining for ASan. 💖
• -fno-sanitize-address-poison-custom-array-cookie — Disable poisoning array cookies when using custom operator new[] in AddressSanitizer. custom operator new[], no poisoning. 🧚
• -fno-sanitize-address-use-after-scope — Disable use-after-scope detection in AddressSanitizer. no use-after-scope detection. 🔥
• -fno-sanitize-address-use-odr-indicator — Disable ODR indicator globals. no ODR indicator globals. 👑
• -fno-sanitize-alloc-token-extended — Disable extended coverage to custom allocation functions. no extended AllocToken coverage. 🌈
• -fno-sanitize-alloc-token-fast-abi — Use the default AllocToken ABI. default ABI, period. 💅
• -fno-sanitize-annotate-debug-info=<value> — Do not allow compiler to annotate sanitizer instrumentation with extra debug info for the specified sanitizers. specified sanitizers only. 🦋
• -fno-sanitize-annotate-debug-info — Do not allow compiler to annotate sanitizer instrumentation with extra debug info for any sanitizers. any sanitizers, no annotations. 🌸
• -fno-sanitize-cfi-canonical-jump-tables — Do not make the jump table addresses canonical in the symbol table. no canonical jump table addresses. ✨
• -fno-sanitize-cfi-cross-dso — Disable control flow integrity (CFI) checks for cross-DSO calls. no cross-DSO CFI checks. 💖
• -fno-sanitize-coverage=<value> — Disable features of coverage instrumentation for Sanitizers. specified coverage features off. 🧚
• -fno-sanitize-debug-trap-reasons — Alias for -fsanitize-debug-trap-reasons=none. alias, bestie. 🔥
• -fno-sanitize-handler-preserve-all-regs — Disable handlers with preserve_all calling convention. no preserve_all handlers. 👑
• -fno-sanitize-hwaddress-experimental-aliasing — Disable aliasing mode in HWAddressSanitizer. no HWASan aliasing mode. 🌈
• -fno-sanitize-ignorelist — Don't use ignorelist file for sanitizers. no ignorelist file. 💅
• -fno-sanitize-memory-param-retval — Disable detection of uninitialized parameters and return values. no param/retval uninit detection. 🦋
• -fno-sanitize-memory-track-origins — Disable origins tracking in MemorySanitizer. no MSan origins tracking. 🌸
• -fno-sanitize-memory-use-after-dtor — Disable use-after-destroy detection in MemorySanitizer. no use-after-dtor detection. ✨
• -fno-sanitize-merge=<value> — Do not allow compiler to merge handlers for specified sanitizers. specified sanitizers, no merge. 💖
• -fno-sanitize-merge — Do not allow compiler to merge handlers for any sanitizers. any sanitizers, no merge. 🧚
• -fno-sanitize-recover=<value> — Disable recovery for specified sanitizers. specified sanitizers, no recovery. 🔥
• -fno-sanitize-stable-abi — Conventional ABI instrumentation for sanitizer runtime. Default: Conventional. default is Conventional, bestie. 👑
• -fno-sanitize-stats — Disable sanitizer statistics gathering. no sanitizer stats. 🌈
• -fno-sanitize-thread-atomics — Disable atomic operations instrumentation in ThreadSanitizer. no TSan atomics instrumentation. 💅
• -fno-sanitize-thread-func-entry-exit — Disable function entry/exit instrumentation in ThreadSanitizer. no TSan func entry/exit. 🦋
• -fno-sanitize-thread-memory-access — Disable memory access instrumentation in ThreadSanitizer. no TSan memory access instrumentation. 🌸
• -fno-sanitize-trap=<value> — Disable trapping for specified sanitizers. specified sanitizers, no trap. ✨
• -fno-sanitize-trap — turns OFF trapping for every single sanitizer 💅 no traps, we vibe differently now.
• -fno-sanitize-type-outline-instrumentation — tells it to use the code inlining logic for the type sanitizer ✨
• -fno-short-wchar — forces wchar_t to be an unsigned int, no cap 🫶
• -fno-show-column — diagnostics will NOT include the column number. bestie loses her coordinates 😭
• -fno-show-source-location — no source location info attached to diagnostics at all. it's giving mystery 🦋
• -fno-signed-char — char is unsigned, periodt 💜
• -fno-signed-zeros — allows optimizations that ignore the sign of floating point zeros 🔥 (yes it's chaotic, yes it's allowed)
• -fno-skip-odr-check-in-gmf — performs ODR checks for decls inside the global module fragment 👑
• -fno-spell-checking — disables spell-checking. typos are my truth now 💀
• -fno-split-machine-functions — disables late function splitting using profile information (x86 and aarch64 ELF) 🌸
• -fno-split-stack — wouldn't use segmented stack. nope, not doing it 🙈
• -fno-stack-clash-protection — disables stack clash protection ⚠️
• -fno-stack-protector — disables the use of stack protectors ⚠️
• -fno-standalone-debug — limits the debug information produced, to reduce the size of the debug binary 🎀
• -fno-strict-aliasing — disables optimizations based on strict aliasing rules ✨
• -fno-strict-float-cast-overflow — relaxes the language rules and tries to match the behavior of the target's native float-to-int conversion instructions 💅
• -fno-strict-return — does NOT treat control flow paths that fall off the end of a non-void function as unreachable 🌈
• -fno-swift-version-independent-apinotes — disables version-independent external API notes support 💜
• -fno-sycl-add-default-spec-consts-image — turns off generation of the device image where all specialization constant usages are replaced with default values 🦋
• -fno-sycl-allow-device-dependencies — deprecated, bestie: please use -fno-sycl-allow-device-image-dependencies instead 🚨
• -fno-sycl-allow-device-image-dependencies — does not allow dependencies between device code images (this is the default) 🫶
• -fno-sycl-cuda-compatibility — disables CUDA compatibility mode 💀
• -fno-sycl-dead-args-optimization — disables elimination of DPC++ dead kernel arguments ✨
• -fno-sycl-decompose-functor — does not decompose the SYCL functor if possible (experimental, CUDA only) 🧚
• -fno-sycl-device-code-split-esimd — does not split ESIMD and SYCL device code into separate device binary images. has effect only for SPIR-based targets. (experimental) 🌸
• -fno-sycl-early-optimizations — disables the standard optimization pipeline for the SYCL device compiler 😭
• -fno-sycl-esimd-force-stateless-mem — does not enforce using stateless memory accesses 💅
• -fno-sycl-explicit-simd — disables the SYCL explicit SIMD extension. (deprecated) ⚠️
• -fno-sycl-force-inline-kernel-lambda — disallows force inline SYCL kernels lambda in the entry point 🔥
• -fno-sycl-id-queries-fit-in-int — does not assume that SYCL ID queries fit within MAX_INT 🙈
• -fno-sycl-instrument-device-code — does not add Instrumentation and Tracing Technology (ITT) instrumentation intrinsics calls (experimental) 🎀
• -fno-sycl-libspirv — disables the check for libspirv ❌
• -fno-sycl-link-spirv — disables adding of the default (spir64) triple when it's discovered in user specified objects and archives 🌈
• -fno-sycl-rdc — generates relocatable device code during SYCL offload target compilation. using -fno-sycl-rdc in combination with -c will produce final device binaries within the generated fat object. when you use this option, each kernel must be self-contained within its translation unit (source file). therefore, the use of SYCL_EXTERNAL is disallowed when this option is enabled 👑
• -fno-sycl-remove-unused-external-funcs — prevents removal of unused SYCL_EXTERNAL functions 💜
• -fno-sycl-unnamed-lambda — disallows unnamed SYCL lambda kernels 🦋
• -fno-sycl-use-bitcode — uses SPIR-V instead of LLVM bitcode in fat objects (deprecated) 🚨
• -fno-sycl-use-footer — disables usage of the integration footer during SYCL enabled compilations ✨
• -fno-sycl — disables SYCL C++ extensions 💀
• -fno-system-debug — does not emit debug information for declarations in system headers 🌸
• -fno-temp-file — directly creates the compilation output files. this may lead to incorrect incremental builds if the compiler crashes ⚠️ (fr fr, be careful)
• -fno-threadsafe-statics — does not emit code to make initialization of local statics thread safe 🙈
• -fno-trigraphs — does not process trigraph sequences 💅
• -fno-unified-lto — uses distinct LTO pipelines 🎀
• -fno-unique-section-names — does not use unique names for text and data sections 🔥
• -fno-unroll-loops — turns off the loop unroller 😭
• -fno-use-cxa-atexit — doesn't use __cxa_atexit for calling destructors 🫶
• -fno-use-init-array — uses .ctors/.dtors instead of .init_array/.fini_array 🌈
• -fno-verify-intermediate-code — disables verification of LLVM IR 😬
• -fno-visibility-inlines-hidden-static-local-var — disables -fvisibility-inlines-hidden-static-local-var (this is the default on non-darwin targets) ✨
• -fno-xray-function-index — omits the function index section, at the expense of single-function patching performance 💀
• -fno-zero-initialized-in-bss — doesn't place zero initialized data in BSS 🦋
• -fno-zos-extensions — does not accept non-standard constructs supported by the z/OS compiler 💜

---

• -fobjc-arc-exceptions — uses EH-safe code when synthesizing retains and releases in -fobjc-arc 🎀
• -fobjc-arc — synthesizes retain and release calls for Objective-C pointers ✨
• -fobjc-avoid-heapify-local-blocks — tries to avoid heapifying local blocks 🌸
• -fobjc-direct-precondition-thunk — moves precondition checks for direct methods into thunks 👑
• -fobjc-disable-direct-methods-for-testing — ignores the attribute objc_direct so that direct methods can be tested 🧪
• -fobjc-encode-cxx-class-template-spec — fully encodes c++ class template specialization 🔥
• -fobjc-exceptions — enables Objective-C exceptions 🫶
• -fobjc-runtime=<value> — specifies the target Objective-C runtime kind and version 💅
• -fobjc-weak — enables ARC-style weak references in Objective-C 🌈

---

• -foffload-fp32-prec-div — fdiv operations in offload device code are required to return correctly rounded results ⭐
• -foffload-fp32-prec-sqrt — sqrt operations in offload device code are required to return correctly rounded results ⭐
• -foffload-implicit-host-device-templates — template functions or specializations without host, device and global attributes have implicit host device attributes (CUDA/HIP only) 🦋
• -foffload-lto=<value> — sets the LTO mode for offload compilation ✨
• -foffload-lto — enables LTO in 'full' mode for offload compilation 🔥
• -foffload-uniform-block — assumes that kernels are launched with uniform block sizes (default true for CUDA/HIP and false otherwise) 💜
• -foffload-via-llvm — uses LLVM/Offload as the portable offloading runtime 🎀

---

• -fomit-frame-pointer — omits the frame pointer from functions that don't need it. some stack unwinding cases, such as profilers and sanitizers, may prefer specifying -fno-omit-frame-pointer. on many targets, -O1 and higher omit the frame pointer by default. -m[no-]omit-leaf-frame-pointer takes precedence for leaf functions 🌸
• -fopenacc — enables OpenACC 🌈
• -fopenmp-extensions — enables all Clang extensions for OpenMP directives and clauses ✨
• -fopenmp-force-usm — forces behavior as if the user specified pragma omp requires unified_shared_memory 👑
• -fopenmp-offload-mandatory — does not create a host fallback if offloading to the device fails 😤
• -fopenmp-simd — emits OpenMP code only for SIMD-based constructs 💜
• -fopenmp-target-debug — enables debugging in the OpenMP offloading device RTL 🐛
• -fopenmp-target-jit — emits code that can be JIT compiled for OpenMP offloading. implies -foffload-lto=full 🔥
• -fopenmp-targets=<value> — specifies a comma-separated list of triples of OpenMP offloading targets to be supported 🎀
• -fopenmp-version=<value> — sets the OpenMP version (e.g. 45 for OpenMP 4.5, 51 for OpenMP 5.1). the default value is 51 for Clang 💅
• -fopenmp — parses OpenMP pragmas and generates parallel code ✨
• -foperator-arrow-depth=<value> — maximum number of 'operator->'s to call for a member access 🦋
• -foptimization-record-file=<file> — specifies the output name of the file containing the optimization remarks. implies -fsave-optimization-record. on Darwin platforms, this cannot be used with multiple -arch <arch> options ⚠️
• -foptimization-record-passes=<regex> — only includes passes which match a specified regular expression in the generated optimization record (by default, include all passes) 🔍
• -fpack-struct=<value> — specifies the default maximum struct packing alignment 📦
• -fpartition-static-data-sections — enables partition static data sections using profile information (x86 and aarch64 ELF) 🌸
• -fpascal-strings — recognizes and constructs Pascal-style string literals 💜
• -fpass-plugin=<dsopath> — loads pass plugin from a dynamic shared object file (only with new pass manager) 🔌
• -fpatchable-function-entry=<N,M,Section> — generates M NOPs before function entry and N-M NOPs after function entry. if section is specified, use it instead of __patchable_function_entries 🎀
• -fpcc-struct-return — overrides the default ABI to return all structs on the stack 📚
• -fpch-codegen — generates code for uses of this PCH that assumes an explicit object file will be built for the PCH ✨
• -fpch-debuginfo — generates debug info for types in an object file built from this PCH, and does not generate them elsewhere 🐛
• -fpch-instantiate-templates — instantiates templates already while building a PCH ⚡
• -fpch-validate-input-files-content — validates PCH input files based on content if mtime differs 🕵️
• -fplugin-arg-<name>-<arg> — passes <arg> to plugin <name> 💅
• -fplugin=<dsopath> — loads the named plugin (dynamic shared object) 🔌
• -fprebuilt-implicit-modules — looks up implicit modules in the prebuilt module path 🔍
• -fprebuilt-module-path=<directory> — specifies the prebuilt module path 📁
• -fpreview-breaking-changes — okay so this is the "we're allowed to break stuff on purpose" flag 💅 It tells the compiler driver and all the compilation phases that backwards compatibility is officially cancelled, no cap. Turn it on and the compiler also defines the macro __INTEL_PREVIEW_BREAKING_CHANGES for you. And bbz, if you pair it with -fsycl, the driver links against a whole alternate form of libsycl called libsycl-preview ✨
• -fproc-stat-report=<value> — saves the subprocess statistics into the file you name 🎀
• -fproc-stat-report<value> — same energy but it just prints the subprocess statistics instead of filing them away 🫶
• -fprofile-arcs — instruments your code so it produces gcov data files (*.gcda) 📊
• -fprofile-continuous — turns on continuous instrumentation profiling mode, lowkey the vibe of "just keep watching me" 👀
• -fprofile-exclude-files=<value> — instruments only functions from files whose names don't match all the regexes you separated with a semi-colon 🙈
• -fprofile-filter-files=<value> — the flip side: instruments only functions from files whose names match any regex separated by a semi-colon 🎯
• -fprofile-function-groups=<N> — splits the functions into N groups and then you use -fprofile-selected-function-group to pick just group i for instrumentation 🧚
• -fprofile-generate-cold-function-coverage=<directory> — generates instrumented code to collect coverage info for the cold functions (the unpopular ones, we love them anyway) into <directory>/default.profraw — though the LLVM_PROFILE_FILE env var gets to override that 💜
• -fprofile-generate-cold-function-coverage — same coverage-info-for-cold-functions deal, but it lands in a default.profraw file instead (and yes, it's overridden by the = form of the option or by LLVM_PROFILE_FILE) ❄️
• -fprofile-generate=<directory> — generates instrumented code that collects execution counts into <directory>/default.profraw, overridable by the LLVM_PROFILE_FILE env var bestie 🍓
• -fprofile-generate — collects those execution counts straight into default.profraw (overridden by LLVM_PROFILE_FILE env var) ✨
• -fprofile-instr-generate=<file> — generates instrumented code that collects execution counts into <file>, and yeah LLVM_PROFILE_FILE can override it 😌
• -fprofile-instr-generate — collects execution counts into the default.profraw file (overridden by the = form of the option or LLVM_PROFILE_FILE env var) 🌸
• -fprofile-instr-use=<value> — uses instrumentation data for profile-guided optimization, iconic behavior 🫶
• -fprofile-list=<value> — a filename that defines the list of functions/files to instrument. The file uses the sanitizer special case list format, iykyk 💅
• -fprofile-remapping-file=<file> — uses the remappings described in <file> to match the profile data against names in the program 🔥
• -fprofile-sample-accurate — says, officially, that the sample profile is accurate. Trust. 💯
• -fprofile-sample-use=<value> — enables sample-based profile guided optimizations, main character energy ⭐
• -fprofile-selected-function-group=<i> — pairs with -fprofile-function-groups to split your functions into N groups and instrument only the ones in group i. Valid range is 0 to N-1 inclusive, don't get it twisted 🎀
• -fprofile-update=<method> — sets the update method of the profile counters 🔧
• -fprofile-use=<pathname> — uses instrumentation data for profile-guided optimization. If <pathname> is a directory it reads from <pathname>/default.profdata; otherwise it reads from the file <pathname> 🗂️
• -fprotect-parens — decides whether the optimizer actually honors your parentheses when it evaluates floating-point expressions. The way that matters 😭
• -fpseudo-probe-for-profiling — emits pseudo probes for sample profiling 🧚
• -fptrauth-auth-traps — enables traps on authentication failures 🪤
• -fptrauth-block-descriptor-pointers — enables signing and authentication of block descriptors 🔐
• -fptrauth-calls — enables signing and authentication of all indirect calls 👑
• -fptrauth-elf-got — enables authentication of pointers from the GOT (ELF only, so don't come at me on other formats) 🐧
• -fptrauth-function-pointer-type-discrimination — enables type discrimination on C function pointers 🎯
• -fptrauth-indirect-gotos — enables signing and authentication of indirect goto targets 🚀
• -fptrauth-init-fini-address-discrimination — enables address discrimination of function pointers in init/fini arrays 📍
• -fptrauth-init-fini — enables signing of function pointers in init/fini arrays ✍️
• -fptrauth-intrinsics — enables pointer authentication intrinsics 🧩
• -fptrauth-objc-class-ro — enables signing and authentication for ObjC class_ro pointers 🍎
• -fptrauth-objc-interface-sel — enables signing and authentication of an Objective-C object's 'SEL' fields 🏷️
• -fptrauth-objc-isa — enables signing and authentication of an Objective-C object's 'isa' field 🪪
• -fptrauth-returns — enables signing and authentication of return addresses ↩️
• -fptrauth-type-info-vtable-pointer-discrimination — enables type and address discrimination of the vtable pointer of std::type_info 🧬
• -fptrauth-vtable-pointer-address-discrimination — enables address discrimination of vtable pointers 📌
• -fptrauth-vtable-pointer-type-discrimination — enables type discrimination of vtable pointers 🔍
• -frandomize-layout-seed-file=<file> — the file holding the seed used by the randomize structure layout feature 🎲
• -frandomize-layout-seed=<seed> — the actual seed used by the randomize structure layout feature 🌱
• -fraw-string-literals — enables raw string literals 🪢
• -freciprocal-math — allows division operations to be reassociated, which is giving "math but make it flexible" 🧮
• -freg-struct-return — overrides the default ABI so small structs get returned in registers 📦
• -fregister-global-dtors-with-atexit — uses atexit or __cxa_atexit to register global destructors 🧹
• -fropi — generates read-only position independent code (ARM only) 🦾
• -frtlib-add-rpath — adds -rpath with the architecture-specific resource directory to the linker flags. And when --hip-link is specified, it also adds -rpath with the HIP runtime library directory to the linker flags 🛤️
• -frtlib-defaultlib — on Windows, emits /defaultlib: directives to link compiler-rt libraries (this is the default, so it's just doing its thing) 🪟
• -frwpi — generates read-write position independent code (ARM only) 🦾
• -fsafe-buffer-usage-suggestions — displays suggestions to update code associated with -Wunsafe-buffer-usage warnings 💡
• -fsample-profile-use-profi — uses profi to infer block and edge counts 📈
• -fsanitize-address-destructor=<value> — sets the kind of module destructors emitted by AddressSanitizer instrumentation. These destructors get emitted to unregister instrumented global variables when code is unloaded (like, for example, via dlclose()) 🧼
• -fsanitize-address-field-padding=<value> — the level of field padding for AddressSanitizer 🛋️
• -fsanitize-address-globals-dead-stripping — enables linker dead stripping of globals in AddressSanitizer 🗑️
• -fsanitize-address-outline-instrumentation — always generates function calls for address sanitizer instrumentation 📞
• -fsanitize-address-poison-custom-array-cookie — enables poisoning array cookies when using custom operator new[] in AddressSanitizer 🍪
• -fsanitize-address-use-after-return=<mode> — selects the mode of detecting stack use-after-return in AddressSanitizer 🕵️
• -fsanitize-address-use-after-scope — enables use-after-scope detection in AddressSanitizer 🔎
• -fsanitize-address-use-odr-indicator — enables ODR indicator globals to avoid false ODR violation reports in partially sanitized programs — at the cost of an increase in binary size, so it's giving tradeoff energy 💀
• -fsanitize-alloc-token-extended — enables extended coverage to custom allocation functions ➕
• -fsanitize-alloc-token-fast-abi — uses the AllocToken fast ABI ⚡
• -fsanitize-annotate-debug-info=<value> — annotates sanitizer instrumentation with extra debug info for the sanitizers you specify, if that's supported 🏷️
• -fsanitize-annotate-debug-info — lets the compiler annotate sanitizer instrumentation with extra debug info for all sanitizers, where supported 🌈
• -fsanitize-cfi-canonical-jump-tables — makes the jump table addresses canonical in the symbol table 📚
• -fsanitize-cfi-cross-dso — enables control flow integrity (CFI) checks for cross-DSO calls 🛂
• -fsanitize-cfi-icall-experimental-normalize-integers — normalizes integers in CFI indirect call type signature checks 🔢
• -fsanitize-cfi-icall-generalize-pointers — generalizes pointers in CFI indirect call type signature checks 🪄
• -fsanitize-coverage-allowlist=<value> — restricts sanitizer coverage instrumentation exclusively to modules and functions that match the provided special case list — except the blocked ones 🙅
• -fsanitize-coverage-ignorelist=<value> — disables sanitizer coverage instrumentation for modules and functions that match the provided special case list — even the allowed ones 🙅
• -fsanitize-coverage-stack-depth-callback-min=<M> — uses a callback for max stack depth tracing with a minimum stack depth of <M> 📉
• -fsanitize-coverage=<value> — specifies the type of coverage instrumentation for Sanitizers 🎛️
• -fsanitize-debug-trap-reasons=<value> — sets how trap reasons get emitted:
  • none — not emitted at all. This gives the smallest debug info 🐜
  • basic — emits a fixed trap message per check type. This increases the debug info size, but not as much as detailed 🐕
  • detailed — emits a more detailed trap message. This increases the debug info size the most 🐘

Default is detailed 🎀

• -fsanitize-debug-trap-reasons — an alias for -fsanitize-debug-trap-reasons=detailed ✨
• -fsanitize-handler-preserve-all-regs — enables handlers with the preserve_all calling convention 💾
• -fsanitize-hwaddress-abi=<value> — selects the HWAddressSanitizer ABI to target (interceptor or platform, default interceptor). Heads up bestie: this option is currently unused 💀
• -fsanitize-hwaddress-experimental-aliasing — enables aliasing mode in HWAddressSanitizer 🧪
• -fsanitize-ignorelist=<value> — the path to the ignorelist file for sanitizers 🚫
• -fsanitize-kcfi-arity — embeds function arity information into the KCFI patchable function prefix 🧷
• -fsanitize-kcfi-hash=<value> — selects the hash algorithm for KCFI type IDs (xxHash64, FNV-1a) #️⃣
• -fsanitize-memory-param-retval — enables detection of uninitialized parameters and return values 🕳️
• -fsanitize-memory-track-origins=<value> — enables origins tracking in MemorySanitizer 🌳
• -fsanitize-memory-track-origins — turns on origins tracking inside MemorySanitizer, so bestie, when it yells at you it can actually tell you where the uninitialized thing came from 🕵️♀️
• -fsanitize-memory-use-after-dtor — enables use-after-destroy detection in MemorySanitizer. yes, using a thing after its destructor ran. we're catching that 💀
• -fsanitize-memtag-mode=<value> — sets the default MTE mode. Valid vibe check: 'sync' (which is the default) or 'async' ✨
• -fsanitize-merge=<value> — lets the compiler merge handlers for the sanitizers you name
• -fsanitize-merge — same energy but for all the sanitizers, no picking and choosing 💅
• -fsanitize-recover=<value> — enables recovery for the specified sanitizers
• -fsanitize-skip-hot-cutoff=<value> — excludes sanitization for the top hottest code responsible for the given fraction of PGO counters. The scale is: 0.0 [default] = skip none; 1.0 = skip all. Argument format is literally:

<sanitizer1>=<value1>,<sanitizer2>=<value2>,...

• -fsanitize-stable-abi — stable ABI instrumentation for the sanitizer runtime. Default: Conventional 🔒
• -fsanitize-stats — enables sanitizer statistics gathering.
• -fsanitize-system-ignorelist=<value> — the path to the system ignorelist file for sanitizers 🙈
• -fsanitize-thread-atomics — enables atomic operations instrumentation in ThreadSanitizer (and that's the default, so it's already on, you're welcome)
• -fsanitize-thread-func-entry-exit — enables function entry/exit instrumentation in ThreadSanitizer (default, bestie)
• -fsanitize-thread-memory-access — enables memory access instrumentation in ThreadSanitizer (default 🫶)
• -fsanitize-trap=<value> — enables trapping for the specified sanitizers
• -fsanitize-trap — enables trapping for every single sanitizer, all of them, periodt
• -fsanitize-type-outline-instrumentation — always generate function calls for type sanitizer instrumentation
• -fsanitize-undefined-ignore-overflow-pattern=<value> — specify the overflow patterns to exclude from arithmetic sanitizer instrumentation
• -fsanitize-undefined-strip-path-components=<number> — strip a given number of path components when emitting check metadata — or, if the number is negative, keep only that many 🎀
• -fsanitize=<check> — turn on runtime checks for various forms of undefined or suspicious behavior. see the user manual for the available checks, iykyk
• -fsave-optimization-record=<format> — generate an optimization record file in a specific format
• -fsave-optimization-record — generate a YAML optimization record file 🌸
• -fseh-exceptions — use SEH style exceptions
• -fseparate-named-sections — use separate unique sections for named sections (ELF only, bestie)
• -fshort-enums — allocate to an enum type only as many bytes as it needs for the declared range of possible values. minimalism ✨
• -fshort-wchar — forces wchar_t to be a short unsigned int
• -fshow-overloads=<value> — which overload candidates to show when overload resolution fails. defaults to 'all'
• -fshow-skipped-includes — show skipped includes in -H output.
• -fsigned-char — char is signed. that's the whole thing. iconic honestly
• -fsized-deallocation — enables C++14 sized global deallocation functions
• -fsjlj-exceptions — use SjLj style exceptions
• -fskip-odr-check-in-gmf — skip ODR checks for decls in the global module fragment.
• -fslp-vectorize — enables the superword-level parallelism vectorization passes ⚡
• -fspell-checking-limit=<value> — set the maximum number of times to perform spell checking on unrecognized identifiers (0 = no limit). your typos are safe, girl
• -fsplit-dwarf-inlining — provide minimal debug info in the object/executable so you can still get online symbolication/stack traces when .dwo/.dwp files aren't around, as long as you're using Split DWARF
• -fsplit-lto-unit — enables splitting of the LTO unit
• -fsplit-machine-functions — enable late function splitting using profile information (x86 and aarch64 ELF)
• -fsplit-stack — use segmented stack
• -fstack-clash-protection — enable stack clash protection 🛡️
• -fstack-protector-all — enable stack protectors for all functions, no exceptions, everyone gets one
• -fstack-protector-strong — enable stack protectors for some functions vulnerable to stack smashing. compared to -fstack-protector, this one uses a stronger heuristic that includes functions containing arrays of any size (and any type), plus any calls to alloca or the taking of an address from a local variable 💪
• -fstack-protector — 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 gets 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. okay that was a lot but like, stack safety is the moment 🎀
• -fstack-size-section — emit a section containing metadata on function stack sizes
• -fstack-usage — emit a .su file containing information on function stack sizes
• -fstandalone-debug — emit full debug info for all types used by the program
• -fstrict-aliasing — enable optimizations based on strict aliasing rules
• -fstrict-enums — enable optimizations based on the strict definition of an enum's value range
• -fstrict-flex-arrays=<n> — enable optimizations based on the strict definition of flexible arrays.
• -fstrict-float-cast-overflow — assume that overflowing float-to-int casts are undefined (that's the default, so like, heads up 🫣)
• -fstrict-vtable-pointers — enable optimizations based on the strict rules for overwriting polymorphic C++ objects
• -fswift-async-fp=<option> — control emission of Swift async extended frame info
• -fswift-version-independent-apinotes — enable version-independent external API notes support
• -fsycl-add-default-spec-consts-image — generates a copy of every device image that uses a specialization constant and replaces all usages of specialization constant with default values specified by specialization_id. if a device image does not use a specialization constant at all then no copy is generated. this option is only useful if used in conjunction with Ahead of Time Compilation (-fsycl-target command line option). got it? good 💅
• -fsycl-allow-device-dependencies — deprecated: please use -fsycl-allow-device-image-dependencies instead. girl, upgrade
• -fsycl-allow-device-image-dependencies — allow dependencies between device code images
• -fsycl-cuda-compatibility — enable CUDA compatibility mode (experimental). enables the use of CUDA device code with SYCL device code. under this mode, a SYCL device function can call a CUDA device function (but not the other way around, so no reverse uno). this implies the definition of CUDA macros and the inclusion of implicit header files.
• -fsycl-dead-args-optimization — enables elimination of DPC++ dead kernel arguments 🗑️
• -fsycl-decompose-functor — do decompose SYCL functor if possible (experimental, CUDA only)
• -fsycl-default-sub-group-size <value> — set the default sub group size for SYCL kernels
• -fsycl-device-code-split-esimd — split ESIMD device code from SYCL into a separate device binary image (that's the default). only has effect for SPIR-based targets. (experimental) 🧪
• -fsycl-device-code-split=<value> — perform SYCL device code split. the options are: per_kernel (device code module is created for each SYCL kernel) | per_source (device code module is created for each source (translation unit)) | off (no device code split) | auto (use heuristic to select the best way of splitting device code). default is 'auto' — use heuristic to distribute device code across modules ✨
• -fsycl-device-code-split — perform SYCL device code split in the 'auto' mode, i.e. use heuristic to distribute device code across modules
• -fsycl-device-obj=<value> — specify format of device code stored in the resulting object. valid values are: spirv, asm, llvmir (default) 🎀
• -fsycl-device-only — compile SYCL kernels for device
• -fsycl-disable-range-rounding — deprecated: please use -fsycl-range-rounding=disable instead.
• -fsycl-dump-device-code=<value> — dump device code into the user provided directory. (deprecated, bestie, it's giving legacy)
• -fsycl-early-optimizations — enable standard optimization pipeline for SYCL device compiler
• -fsycl-embed-ir — embed LLVM IR for runtime kernel fusion 🔥
• -fsycl-esimd-force-stateless-mem — enforce using stateless memory accesses. convert stateful accesses via SYCL accessors to stateless within ESIMD kernels. enabled by default.
• -fsycl-exp-range-rounding — use experimental range rounding.
• -fsycl-explicit-simd — enable SYCL explicit SIMD extension. (deprecated)
• -fsycl-footer-path=<value> — specify the location of the temporary source file with the included integration footer
• -fsycl-force-inline-kernel-lambda — allow force inline SYCL kernels lambda in entry point
• -fsycl-force-target=<value> — force the usage of the given triple when extracting device code from any given objects on the command line
• -fsycl-fp32-prec-sqrt — SYCL only. specify that single precision floating-point sqrt is correctly rounded. (deprecated)
• -fsycl-fp64-conv-emu — enable fp64 partial emulation for kernels with only fp64 conversion operations and no fp64 computation operations (requires Intel GPU backend supporting fp64 partial emulation).
• -fsycl-help=<value> — emit help information from the related offline compilation tool. valid values: all, gen, x86_64.
• -fsycl-help — emit help information from all of the offline compilation tools 🙋♀️
• -fsycl-host-compiler-options=<value> — when performing the host compilation with -fsycl-host-compiler specified, use the given options during that compile. options are expected to be a quoted list of space separated options.
• -fsycl-host-compiler=<value> — specify the C++ compiler binary to perform host compilation with during SYCL offload compiles.
• -fsycl-host-only — compile SYCL code for host only. has no effect on non-SYCL compilations 🌈
• -fsycl-id-queries-fit-in-int — bestie, you're telling it to assume that SYCL ID queries fit within MAX_INT. Just… trust the vibes. ✨
• -fsycl-instrument-device-code — adds Instrumentation and Tracing Technology (ITT) instrumentation intrinsics calls 🫶 (experimental, so like… it's giving beta energy)
• -fsycl-libspirv-path=<value> — the path to the libspirv library, bestie 📁
• -fsycl-link — generate a partially linked device object that's meant to be used with the host link 🔗
• -fsycl-max-parallel-link-jobs=<value> — controls the max parallelism of actions performed on SYCL device code post-link — aka the generation of SPIR-V device images, or the AOT compilation of each device image 🌀 (experimental)
• -fsycl-optimize-non-user-code — this one runs with -O0: it optimizes the SYCL framework utility functions but leaves your kernel code unoptimized, so your stuff stays untouched ❄️ (experimental)
• -fsycl-range-rounding=<value> — your options for range rounding of SYCL range kernels: disable (do not generate range rounded kernels), force (only generate range rounded kernels), on (generate range rounded kernels as well as unrounded kernels). The default is 'on' 💫
• -fsycl-remove-unused-external-funcs — allow removal of unused SYCL_EXTERNAL functions (this is the default, no cap) 🧹
• -fsycl-targets=<value> — specify a comma-separated list of triples of SYCL offloading targets to be supported 🎯
• -fsycl-unnamed-lambda — allow unnamed SYCL lambda kernels, anonymous icon behavior 💅
• -fsycl-use-bitcode — use LLVM bitcode instead of SPIR-V in fat objects. deprecated, so like… it's on its way out 👋
• -fsyclbin=<value> — outputs in the SYCLBIN binary format in the state specified by <arg> (input, object, or executable — the default) 📦
• -fsycl — enable SYCL C++ extensions 🔥
• -fsyntax-only — run the preprocessor, parser and semantic analysis stages. That's it, that's the whole job 🧠
• -fsystem-debug — emit debug information for declarations in system headers 🐛
• -fsystem-module — build this module as a system module. Only used with -emit-module 🧩
• -ftarget-compile-fast — experimental feature: reduce target compilation time, with a potential runtime performance trade-off. Speedy trade-off arc ⚡
• -ftarget-export-symbols — expose exported symbols in a generated target library so they're visible to other modules 👀
• -ftarget-register-alloc-mode=<value> — specify a register allocation mode for specific hardware, for use by supported target backends 🎛️
• -ftemplate-backtrace-limit=<value> — set the maximum number of entries to print in a template instantiation backtrace (0 = no limit, go off I guess) 📜
• -ftemplate-depth=<value> — set the maximum depth of recursive template instantiation 🕳️
• -ftemporal-profile — generate instrumented code to collect temporal information ⏱️
• -ftest-coverage — produce gcov notes files (*.gcno) 📝
• -fthin-link-bitcode=<value> — write minimized bitcode to <file> for the ThinLTO thin link only 🧵
• -fthinlto-distributor=<path> — path to the ThinLTO distributor process. If you specify it, ThinLTO backend compilations get distributed by LLD 📡
• -fthinlto-index=<value> — perform ThinLTO importing using the provided function summary index 📇
• -ftime-report=<value> — (for new pass manager) 'per-pass': one report for each pass; 'per-pass-run': one report for each pass invocation 📊
• -ftime-trace-granularity=<value> — minimum time granularity (in microseconds) traced by the time profiler 🔬
• -ftime-trace-verbose<value> — make time trace capture verbose event details (e.g. source filenames). Heads up: this can increase the size of the output by 2-3 times 😳
• -ftime-trace=<value> — similar to -ftime-trace. Specify the JSON file, or a directory which will contain the JSON file 🗂️
• -ftime-trace — turn on the time profiler. Generates a JSON file based on the output filename 🕰️
• -ftrap-function=<value> — issue a call to the specified function rather than a trap instruction 🪤
• -ftrapv-handler=<function name> — specify the function to be called on overflow 🚨
• -ftrapv — trap on integer overflow, periodt 🛑
• -ftrigraphs — process trigraph sequences 🎀
• -ftrivial-auto-var-init-max-size=<value> — stop initializing trivial automatic stack variables if the var size exceeds the specified number of instances (in bytes) 📏
• -ftrivial-auto-var-init-stop-after=<value> — stop initializing trivial automatic stack variables after the specified number of instances ✋
• -ftrivial-auto-var-init=<value> — initialize trivial automatic stack variables. Defaults to 'uninitialized' 🌱
• -funified-lto — use the unified LTO pipeline 🔄
• -funique-basic-block-section-names — use unique names for basic block sections (ELF only) 🏷️
• -funique-internal-linkage-names — uniqueify internal linkage symbol names by appending the MD5 hash of the module path #️⃣
• -funique-source-file-identifier=<value> — specify the source file identifier for -funique-source-file-names; it uses the source file path if you don't specify one 🔖
• -funique-source-file-names — allow the compiler to assume that each translation unit has a unique source file identifier (see -funique-source-file-identifier) at link time 🧬
• -funroll-loops — turn on the loop unroller 🌀
• -funsafe-math-optimizations — allow unsafe floating-point math optimizations, which may decrease precision. unsafe, babe, it says it right there ⚠️
• -fuse-cuid=<value> — the method used to generate ID's for compilation units for the single source offloading languages CUDA and HIP: 'hash' (ID's generated by hashing the file path and command line options) | 'random' (ID's generated as random numbers) | 'none' (disabled). Default is 'hash'. Heads up: this option will be overridden by the option '-cuid=[ID]' if it's specified 🆔
• -fuse-line-directives — use #line in preprocessed output 📌
• -fvalidate-ast-input-files-content — 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> — use the given vector functions library. Note: -fveclib={ArmPL,SLEEF,libmvec} implies -fno-math-errno. Note: -fveclib=libmvec on AArch64 requires GLIBC 2.40 or newer 🧮
• -fvectorize — enable the loop vectorization passes 🏎️
• -fverbose-asm — generate verbose assembly output 🗣️
• -fverify-intermediate-code — enable verification of LLVM IR ✅
• -fvirtual-function-elimination — enables dead virtual function elimination optimization. Requires -flto=full 💀
• -fvisibility-dllexport=<value> — the visibility for dllexport definitions. If Keep is specified the visibility is not adjusted [-fvisibility-from-dllstorageclass] 👁️
• -fvisibility-externs-dllimport=<value> — the visibility for dllimport external declarations. If Keep is specified the visibility is not adjusted [-fvisibility-from-dllstorageclass] 👁️
• -fvisibility-externs-nodllstorageclass=<value> — the visibility for external declarations without an explicit DLL storage class. If Keep is specified the visibility is not adjusted [-fvisibility-from-dllstorageclass] 👁️
• -fvisibility-from-dllstorageclass — override the visibility of globals based on their final DLL storage class 🔍
• -fvisibility-global-new-delete-hidden — give global C++ operator new and delete declarations hidden visibility 🙈
• -fvisibility-global-new-delete=<value> — the visibility for global C++ operator new and delete declarations. If 'source' is specified the visibility is not adjusted 🎚️
• -fvisibility-inlines-hidden-static-local-var — when -fvisibility-inlines-hidden is enabled, static variables in inline C++ member functions will also be given hidden visibility by default 🫥
• -fvisibility-inlines-hidden — give inline C++ member functions hidden visibility by default 🫥
• -fvisibility-ms-compat — give global types 'default' visibility and global functions and variables 'hidden' visibility by default 🤝
• -fvisibility-nodllstorageclass=<value> — the visibility for definitions without an explicit DLL storage class. If Keep is specified the visibility is not adjusted [-fvisibility-from-dllstorageclass] 👁️
• -fvisibility=<value> — set the default symbol visibility for all global definitions 🌐
• -fwasm-exceptions — use WebAssembly style exceptions 🧱
• -fwhole-program-vtables — enables whole-program vtable optimization. Requires -flto 🔗
• -fwinx64-eh-unwindv2=<value> — generate unwind v2 (epilog) information for x64 Windows 🪟
• -fwrapv-pointer — treat pointer overflow as two's complement 🔁
• -fwrapv — treat signed integer overflow as two's complement 🔁
• -fwritable-strings — store string literals as writable data ✍️
• -fxl-pragma-pack — enable IBM XL #pragma pack handling 📚
• -fxray-always-emit-customevents — always emit __xray_customevent(...) calls, even if the containing function is not always instrumented 📢
• -fxray-always-emit-typedevents — always emit __xray_typedevent(...) calls, even if the containing function is not always instrumented 📢
• -fxray-always-instrument=<value> — DEPRECATED: filename defining the whitelist for imbuing the 'always instrument' XRay attribute 🚫
• -fxray-attr-list=<value> — filename defining the list of functions/types for imbuing XRay attributes 📋
• -fxray-function-groups=<value> — only instrument 1 of N groups 🎲
• -fxray-ignore-loops — don't instrument functions with loops unless they also meet the minimum function size ➰
• -fxray-instruction-threshold=<value> — sets the minimum function size to instrument with XRay 📐
• -fxray-instrumentation-bundle=<value> — select which XRay instrumentation points to emit. Options: all, none, function-entry, function-exit, function, custom. Default is 'all'. Note that 'function' includes both 'function-entry' and 'function-exit' 🎁
• -fxray-instrument — generate XRay instrumentation sleds on function entry and exit 🛷
• -fxray-link-deps — link the XRay runtime library when -fxray-instrument is specified (this is the default) 🧲
• -fxray-modes=<value> — list of modes to link in by default into XRay instrumented binaries 🎛️
• -fxray-never-instrument=<value> — DEPRECATED: filename defining the whitelist for imbuing the 'never instrument' XRay attribute 🚫

---

• -fxray-selected-function-group=<value> — bestie this one only makes sense if you're already using -fxray-function-groups, and it picks which group of functions gets instrumented. Valid range is 0 to fxray-function-groups - 1. that's it, that's the whole thought 💅
• -fxray-shared — turn on shared library instrumentation with XRay ✨
• -fzero-call-used-regs=<value> — clear the call-used registers when a function returns (AArch64/x86 only, so if you're on something else… not for you bb 🫶)
• -fzos-extensions — accept some non-standard constructs that the z/OS compiler happens to support
• -fzvector — enable the System z vector language extension ⭐
• -F <value> — add a directory to the framework include search path 🎀
• -gcall-site-info — enable call site debug info
• --gcc-install-dir=<value> — use the GCC installation sitting in the directory you name. The directory ends with path components like lib{,32,64}/gcc{,-cross}/$triple/$version. > heads up bestie: executables (like ld) that the compiler uses are not overridden by the selected GCC installation. no cap, that's the fine print 💀
• --gcc-toolchain=<value> — point Clang at a directory where it can find include and lib{,32,64}/gcc{,-cross}/$triple/$version. Clang will pick the GCC installation with the largest version 👑
• --gcc-triple=<value> — search for the GCC installation using the triple you specify
• -gcodeview-command-line — emit the compiler path and command line straight into CodeView debug information
• -gcodeview-ghash — emit type record hashes into a .debug$H section
• -gcodeview — generate CodeView debug information
• -gdwarf-2 — generate source-level debug info with DWARF version 2
• -gdwarf-3 — generate source-level debug info with DWARF version 3
• -gdwarf-4 — generate source-level debug info with DWARF version 4
• -gdwarf-5 — generate source-level debug info with DWARF version 5
• -gdwarf-6 — generate source-level debug info with DWARF version 6 🦋
• -gdwarf32 — enables DWARF32 format for ELF binaries, but only if debug information emission is enabled in the first place
• -gdwarf64 — enables DWARF64 format for ELF binaries, again only if debug information emission is enabled
• -gdwarf — generate source-level debug info with the default DWARF version
• -gembed-source — embed the source text inside DWARF debug sections 🌸
• -gen-reproducer=<value> — emit a reproducer, and the options are: off, crash (that's the default bb), error, always
• -gkey-instructions — enable Key Instructions, which makes debug stepping in optimized C/C++ code less jumpy in some debuggers. DWARF only ✨
• -gline-directives-only — emit debug line info directives only
• -gline-tables-only — emit debug line number tables only
• -gmodules — generate debug info with external references to clang modules or precompiled headers
• -gno-call-site-info — disable call site debug info (the anti--gcall-site-info, iconic honestly)
• -gno-codeview-command-line — don't emit the compiler path and command line into CodeView debug information
• -gno-embed-source — restore the default behavior of not embedding source text in DWARF debug sections
• -gno-inline-line-tables — don't emit inline line tables. periodt.
• --gpu-bundle-output — bundle the output files of HIP device compilation 🎀
• --gpu-instrument-lib=<value> — instrument device library for HIP, which is an LLVM bitcode containing __cyg_profile_func_enter and __cyg_profile_func_exit
• --gpu-max-threads-per-block=<value> — the default max threads per block for kernel launch bounds for HIP
• -gpulibc — link the LLVM C Library for GPUs 🌈
• -gsplit-dwarf=<value> — set the DWARF fission mode
• -gstrict-dwarf — restrict DWARF features to only the ones defined in the specified version, so you don't sneak in features from later versions. no gatecrashing 💅
• -gstructor-decl-linkage-names — attach linkage names to C++ constructor/destructor declarations in DWARF
• -gz=<value> — the compression type for DWARF debug sections
• -G <size> — put objects of at most size bytes into the small data section (MIPS / Hexagon)
• -g — generate source-level debug information. the classic. the blueprint. 👑
• --help-hidden — display help for hidden options (yes bestie, the secret menu 🙈)
• -help — display available options
• --hip-device-lib=<value> — HIP device library
• --hip-link — link clang-offload-bundler bundles for HIP 🔥
• --hip-path=<value> — the HIP runtime installation path, used for finding the HIP version and adding the HIP include path
• --hip-version=<value> — HIP version in the format of major.minor.patch
• --hipspv-pass-plugin=<dsopath> — path to a pass plugin for HIP to SPIR-V passes ✨
• --hipstdpar-interpose-alloc — replace all memory allocation / deallocation calls with hipManagedMalloc / hipFree equivalents
• --hipstdpar-path=<value> — HIP Standard Parallel Algorithm Acceleration library path, used for finding and implicitly including the library header
• --hipstdpar-prim-path=<value> — rocPrim path, required by the HIP Standard Parallel Algorithm Acceleration library, used to implicitly include the rocPrim library
• --hipstdpar-thrust-path=<value> — rocThrust path, required by the HIP Standard Parallel Algorithm Acceleration library, used to implicitly include the rocThrust library
• --hipstdpar — enable HIP acceleration for standard parallel algorithms 🚀
• -H — show header includes and nesting depth
• -I- — restrict all prior -I flags to double-quoted inclusion, and remove the current directory from the include path
• -iapinotes-modules <directory> — add a directory to the API notes search path, referenced by module name
• -ibuiltininc — enable builtin #include directories even when -nostdinc is used before or after -ibuiltininc. Using -nobuiltininc after this option disables it 🎀
• -idirafter <value> — add a directory to the AFTER include search path
• -iframeworkwithsysroot <directory> — add a directory to the SYSTEM framework search path; absolute paths are relative to -isysroot
• -iframework <value> — add a directory to the SYSTEM framework search path
• -ignore-pch — disable precompiled headers; this overrides -emit-pch and -include-pch 💀
• -imacros <file> — include macros from file before parsing
• -include-pch <file> — include a precompiled header file
• -include <file> — include file before parsing
• -iprefix <dir> — set the -iwithprefix/-iwithprefixbefore prefix
• -iquote <directory> — add a directory to the QUOTE include search path
• -isysroot <dir> — set the system root directory (usually /) 🌸
• -isystem-after <directory> — add a directory to the end of the SYSTEM include search path
• -isystem <directory> — add a directory to the SYSTEM include search path
• -ivfsoverlay <value> — overlay the virtual filesystem described by file on top of the real file system 🦋
• -iwithprefixbefore <dir> — set a directory to the include search path with prefix
• -iwithprefix <dir> — set a directory to the SYSTEM include search path with prefix
• -iwithsysroot <directory> — add a directory to the SYSTEM include search path; absolute paths are relative to -isysroot
• -I <dir> — add a directory to the end of the list of include search paths
• --libclc-lib=<value> — namespec of the libclc OpenCL bitcode library to link
• --libomptarget-amdgcn-bc-path=<value> — path to the libomptarget-amdgcn bitcode library
• --libomptarget-amdgpu-bc-path=<value> — path to the libomptarget-amdgcn bitcode library (yes bestie, same description as the one above, I'm just telling you what the page says 🙈)
• --libomptarget-nvptx-bc-path=<value> — path to the libomptarget-nvptx bitcode library
• --libomptarget-spirv-bc-path=<value> — path to the libomptarget-spirv bitcode library
• -L <dir> — add a directory to the library search path
• -mabi=quadword-atomics — enable quadword atomics ABI on AIX (AIX PPC64 only). Uses lqarx/stqcx. instructions ⚡
• -mabicalls — enable SVR4-style position-independent code (Mips only)
• -maix-shared-lib-tls-model-opt — for a shared library loaded with the main program, change local-dynamic access(es) to initial-exec access(es) at the function level (AIX 64-bit only)
• -maix-small-local-dynamic-tls — produce a faster access sequence for local-dynamic TLS variables where the offset from the TLS base is encoded as an immediate operand (AIX 64-bit only). > this access sequence is not used for variables larger than 32KB, so don't come crying to me about your giant variable 💀
• -maix-small-local-exec-tls — produce a faster access sequence for local-exec TLS variables where the offset from the TLS base is encoded as an immediate operand (AIX 64-bit only). > same deal: not used for variables larger than 32KB
• -maix-struct-return — return all structs in memory (PPC32 only)
• -malign-branch-boundary=<value> — specify the boundary's size for aligning branches
• -malign-branch=<value> — specify which types of branches to align
• -malign-double — align doubles to two words in structs (x86 only)
• -maltivec — enable AltiVec vector initializer syntax ✨
• -mamdgpu-expand-waitcnt-profiling — expand s_waitcnt instructions to help PC-sampling profilers spot memory stalls. Instead of a single waitcnt(target), it emits waitcnt(N-1), waitcnt(N-2), …, waitcnt(target). (AMDGPU only) 👑
• -mamdgpu-ieee — 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) — that's a big deal, bestie, don't do it casually 😭
• -mamdgpu-precise-memory-op — enable precise memory mode (AMDGPU only)
• -mannotate-tablejump — enable the annotate table jump instruction so it can be correlated with the jump table
• -mapx-features=<value> — enable features of APX
• -mapx-inline-asm-use-gpr32 — enable use of GPR32 in inline assembly for APX
• -march=<value> — for a list of available architectures for the target, use -mcpu=help 🎀
• -marm64x<value> — link as a hybrid ARM64X image
• -mbackchain — link stack frames through backchain on System Z
• -mbranch-protection=<value> — enforce targets of indirect branches and function returns 🌈
• -mbranches-within-32B-boundaries — align selected branches (fused, jcc, jmp) within a 32-byte boundary
• -mcabac — enable CABAC instructions 🍓

---

• -mcf-branch-label-scheme=<value> — pick the label scheme for branch control-flow architecture protection ✨ bestie choose your fighter
• -mcmse — allow use of CMSE (Armv8-M Security Extensions) 💅 secure the bag
• -mcode-object-version=<value> — specify code object ABI version. Defaults to 6. (AMDGPU only) 🎀
• -mconstructor-aliases — enable emitting complete constructors and destructors as aliases when possible 👑
• -mcpu=<value> — for a list of available CPUs for the target use '-mcpu=help' 🦋 literally just ask for help
• -mcrbits — control the CR-bit tracking feature on PowerPC. -mcrbits (the enablement of CR-bit tracking support) is the default for POWER8 and above, as well as for all other CPUs when optimization is applied (-O2 and above). 🔥
• -mcrc — allow use of CRC instructions (ARM/Mips only) 🌸
• -mcumode — specify CU wavefront execution mode (AMDGPU only) 💜
• -mdaz-ftz — globally set the denormals-are-zero (DAZ) and flush-to-zero (FTZ) bits in the floating-point control register on program startup 💖
• -mdefault-visibility-export-mapping=<value> — mapping between default visibility and export ✨
• -mdiv32 — use div.w[u] and mod.w[u] instructions with input not sign-extended. 🧚
• -mdouble=<n — force double to be <n> bits 💀 yes the flag is missing its closing > bestie we don't touch it
• -MD — write a depfile containing user and system headers 🎀
• -meabi <value> — set EABI type. Default depends on triple) 🙈 stray ) is canon
• -membedded-data — place constants in the .rodata section instead of the .sdata section even if they meet the -G <size> threshold (MIPS) 🌈
• -menable-experimental-extensions — enable use of experimental RISC-V extensions. 🦋
• -mexec-model=<value> — execution model (WebAssembly only) ⭐
• -mexecute-only — disallow generation of data access to code sections (AArch64/ARM only) 🔥
• -mextern-sdata — assume that externally defined data is in the small data if it meets the -G <size> threshold (MIPS) 👑
• -mfentry — insert calls to fentry at function entry (x86/SystemZ only) 💅
• -mfix-cmse-cve-2021-35465 — work around VLLDM erratum CVE-2021-35465 (ARM only) 💖
• -mfix-cortex-a53-835769 — work around Cortex-A53 erratum 835769 (AArch64 only) 🎀
• -mfix-cortex-a53-843419 — work around Cortex-A53 erratum 843419 (AArch64 only) 🌸
• -mfix-cortex-a57-aes-1742098 — work around Cortex-A57 Erratum 1742098 (ARM only) 💜
• -mfix-cortex-a72-aes-1655431 — work around Cortex-A72 Erratum 1655431 (ARM only) ✨
• -mfix-gr712rc — enable workarounds for GR712RC errata 🧚
• -mfix-ut700 — enable workarounds for UT700 errata 🦋
• -mfp32 — use 32-bit floating point registers (MIPS only) ⭐
• -mfp64 — use 64-bit floating point registers (MIPS only) 🌈
• -mframe-chain=<value> — select the frame chain model used to emit frame records (Arm only). 👑
• -mfrecipe — enable frecipe.{s/d} and frsqrte.{s/d} 🔥
• -mfunction-return=<value> — replace returns with jumps to __x86_return_thunk (x86 only, error otherwise) 💀
• -MF <file> — write depfile output from -MMD, -MD, -MM, or -M to <file> 🎀
• -mgeneral-regs-only — generate code which only uses the general purpose registers (AArch64/x86 only) 💅
• -mglobal-merge — enable merging of globals 💖
• -mgpopt — use GP relative accesses for symbols known to be in a small data section (MIPS) 🌸
• -mguard=<value> — enable or disable Control Flow Guard checks and guard tables emission ✨
• -MG — add missing headers to depfile 🧚
• -mharden-sls=<value> — select straight-line speculation hardening scope (ARM/AArch64/X86 only). <arg> must be: all, none, retbr(ARM/AArch64), blr(ARM/AArch64), comdat(ARM/AArch64), nocomdat(ARM/AArch64), return(X86), indirect-jmp(X86) 👑
• -mhvx-ieee-fp — enable Hexagon HVX IEEE floating-point 🦋
• -mhvx-length=<value> — set Hexagon Vector Length ⭐
• -mhvx-qfloat — enable Hexagon HVX QFloat instructions 🌈
• -mhvx=<value> — enable Hexagon Vector eXtensions 🔥
• -mhvx — enable Hexagon Vector eXtensions 💜
• -miamcu — use Intel MCU ABI 💅
• -mignore-xcoff-visibility — not emit the visibility attribute for asm in AIX OS or give all symbols 'unspecified' visibility in XCOFF object file 💖
• -mimplicit-float — generate implicit floating point or vector instructions 🎀
• -mincremental-linker-compatible — (integrated-as) emit an object file which can be used with an incremental linker 🌸
• -mindirect-branch-cs-prefix — add cs prefix to call and jmp to indirect thunk ✨
• -mindirect-jump=<value> — change indirect jump instructions to inhibit speculation 🧚
• -mios-version-min=<value> — set iOS deployment target 🦋
• -MJ <value> — write a compilation database entry per input ⭐
• -mlam-bh — enable amswap[_db].{b/h} and amadd[_db].{b/h} 🌈
• -mlamcas — enable amcas[_db].{b/h/w/d} 🔥
• -mlasx — enable Loongson Advanced SIMD Extension (LASX). 👑
• -mld-seq-sa — do not generate same-address load-load barrier instructions (dbar 0x700) 💜
• -mlink-builtin-bitcode-postopt — link builtin bitcodes after the optimization pipeline 💅
• -mllvm=<arg> — alias for -mllvm 💖
• -mllvm <value> — additional arguments to forward to LLVM's option processing 🎀
• -mlocal-sdata — extend the -G behaviour to object local data (MIPS) 🌸
• -mlong-calls — generate branches with extended addressability, usually via indirect jumps. ✨
• -mlong-double-128 — force long double to be 128 bits 🧚
• -mlong-double-64 — force long double to be 64 bits 🦋
• -mlong-double-80 — force long double to be 80 bits, padded to 128 bits for storage ⭐
• -mlr-for-calls-only — do not allocate the LR register for general purpose usage, only for calls. (AArch64 only) 🌈
• -mlsx — enable Loongson SIMD Extension (LSX). 🔥
• -mlvi-cfi — enable only control-flow mitigations for Load Value Injection (LVI) 👑
• -mlvi-hardening — enable all mitigations for Load Value Injection (LVI) 💜
• -mmacos-version-min=<value> — set macOS deployment target 💅
• -mmadd4 — enable the generation of 4-operand madd.s, madd.d and related instructions. 💖
• -mmark-bti-property — add .note.gnu.property with BTI to assembly files (AArch64 only) 🎀
• -MMD — write a depfile containing user headers 🌸
• -mmemops — enable generation of memop instructions ✨
• -mmlir <value> — additional arguments to forward to MLIR's option processing 🧚
• -mms-bitfields — set the default structure layout to be compatible with the Microsoft compiler standard 🦋
• -mmsa — enable MSA ASE (MIPS only) ⭐
• -mmt — enable MT ASE (MIPS only) 🌈
• -MM — like -MMD, but also implies -E and writes to stdout by default 🔥
• -mno-abicalls — disable SVR4-style position-independent code (Mips only) 👑
• -mno-amdgpu-precise-memory-op — disable precise memory mode (AMDGPU only) 💜
• -mno-annotate-tablejump — disable annotate table jump instruction to correlate it with the jump table. 💅
• -mno-apx-features=<value> — disable features of APX 💖
• -mno-bti-at-return-twice — do not add a BTI instruction after a setjmp or other return-twice construct (Arm/AArch64 only) 🎀
• -mno-constructor-aliases — disable emitting complete constructors and destructors as aliases when possible 🌸
• -mno-crc — disallow use of CRC instructions (Mips only) ✨
• -mno-cumode — specify WGP wavefront execution mode (AMDGPU only) 🧚
• -mno-daz-ftz — do not globally set the denormals-are-zero (DAZ) and flush-to-zero (FTZ) bits in the floating-point control register on program startup 🦋
• -mno-div32 — do not use div.w[u] and mod.w[u] instructions with input not sign-extended. ⭐
• -mno-embedded-data — do not place constants in the .rodata section instead of the .sdata if they meet the -G <size> threshold (MIPS) 🌈
• -mno-execute-only — allow generation of data access to code sections (AArch64/ARM only) 🔥
• -mno-extern-sdata — 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 — don't work around VLLDM erratum CVE-2021-35465 (ARM only) 💜
• -mno-fix-cortex-a53-835769 — don't work around Cortex-A53 erratum 835769 (AArch64 only) 💅
• -mno-fix-cortex-a53-843419 — don't work around Cortex-A53 erratum 843419 (AArch64 only) 💖
• -mno-fix-cortex-a57-aes-1742098 — don't work around Cortex-A57 Erratum 1742098 (ARM only) 🎀
• -mno-fix-cortex-a72-aes-1655431 — don't work around Cortex-A72 Erratum 1655431 (ARM only) 🌸
• -mno-fmv — disable function multiversioning ✨
• -mno-frecipe — disable frecipe.{s/d} and frsqrte.{s/d} 🧚
• -mno-gather — disable generation of gather instructions in auto-vectorization(x86 only) 🦋
• -mno-global-merge — disable merging of globals ⭐
• -mno-gpopt — do not use GP relative accesses for symbols known to be in a small data section (MIPS) 🌈
• -mno-hvx-ieee-fp — disable Hexagon HVX IEEE floating-point 🔥
• -mno-hvx-qfloat — disable Hexagon HVX QFloat instructions 👑
• -mno-hvx — disable Hexagon Vector eXtensions 💜
• -mno-implicit-float — don't generate implicit floating point or vector instructions 💅
• -mno-incremental-linker-compatible — (integrated-as) emit an object file which cannot be used with an incremental linker 💖
• -mno-lam-bh — disable amswap[_db].{b/h} and amadd[_db].{b/h} 🎀
• -mno-lamcas — disable amcas[_db].{b/h/w/d} 🌸
• -mno-lasx — disable Loongson Advanced SIMD Extension (LASX). ✨
• -mno-ld-seq-sa — generate same-address load-load barrier instructions (dbar 0x700) 🧚
• -mno-local-sdata — do not extend the -G behaviour to object local data (MIPS) 🦋
• -mno-long-calls — restore the default behaviour of not generating long calls ⭐
• -mno-lsx — disable Loongson SIMD Extension (LSX). 🌈
• -mno-lvi-cfi — disable control-flow mitigations for Load Value Injection (LVI) 🔥
• -mno-lvi-hardening — disable mitigations for Load Value Injection (LVI) 👑
• -mno-madd4 — disable the generation of 4-operand madd.s, madd.d and related instructions. 💜
• -mno-memops — disable generation of memop instructions 💅
• -mno-movt — disallow use of movt/movw pairs (ARM only) 💖
• -mno-ms-bitfields — nope, do not set the default struct layout to be Microsoft-compiler-compatible. Bye to that whole situation 💅
• -mno-msa — kill the MSA ASE (MIPS only)
• -mno-mt — kill the MT ASE (MIPS only)
• -mno-neg-immediates — not allowed: converting instructions that carry negative immediates into their negation or inversion. Sorry bestie 🙅
• -mno-nvj — turn off generation of new-value jumps
• -mno-nvs — turn off generation of new-value stores
• -mno-outline-atomics — don't generate local calls to out-of-line atomic operations
• -mno-outline — disable function outlining (AArch64 only)
• -mno-packets — disable generation of instruction packets
• -mno-pic-data-is-text-relative — don't just assume data segments are relative to the text segment, ok? 🫶
• -mno-regnames — when writing assembly output, use only register numbers
• -mno-relax — disable linker relaxation
• -mno-restrict-it — allow generation of complex IT blocks
• -mno-save-restore — disable using library calls for save and restore
• -mno-scalar-strict-align — allow scalar memory accesses to be unaligned (RISC-V only)
• -mno-scatter — disable generation of scatter instructions in auto-vectorization (x86 only)
• -mno-scq — disable the sc.q instruction
• -mno-seses — disable speculative execution side effect suppression (SESES)
• -mno-stack-arg-probe — disable stack probes, which btw are enabled by default
• -mno-strict-align — allow memory accesses to be unaligned (AArch64/LoongArch/RISC-V only)
• -mno-tgsplit — disable threadgroup split execution mode (AMDGPU only)
• -mno-tls-direct-seg-refs — disable direct TLS access through segment registers
• -mno-tocdata=<value> — specifies a list of variables to be exempt from the TOC data transformation
• -mno-tocdata — this one is the default 💤. TOC data transformation is not applied to any variables. Only variables specified explicitly in -mtocdata= will have the TOC data transformation.
• -mno-unaligned-access — force all memory accesses to be aligned (AArch32/MIPSr6 only)
• -mno-unaligned-symbols — expect external char-aligned symbols to be without ABI alignment (SystemZ only)
• -mno-v8plus — disable V8+ mode
• -mno-vector-strict-align — allow vector memory accesses to be unaligned (RISC-V only)
• -mno-wavefrontsize64 — specify wavefront size 32 mode (AMDGPU only)
• -mnocrc — disallow use of CRC instructions (ARM only)
• -mnop-mcount — generate mcount/__fentry__ calls as nops. To activate they need to be patched in 🔧
• -mnvj — yes actually, enable generation of new-value jumps
• -mnvs — enable generation of new-value stores
• -module-dependency-dir <value> — directory to dump module dependencies to
• -module-file-info — spill the tea on a particular module file ☕
• -momit-leaf-frame-pointer — omit frame pointer setup for leaf functions
• -moutline-atomics — generate local calls to out-of-line atomic operations
• -moutline — enable function outlining (AArch64 only)
• -mpacked-stack — use packed stack layout (SystemZ only)
• -mpackets — enable generation of instruction packets
• -mpad-max-prefix-size=<value> — specify the maximum number of prefixes to use for padding
• -mpic-data-is-text-relative — assume data segments are relative to text segment
• -mprefer-vector-width=<value> — specifies the preferred vector width for auto-vectorization. Defaults to 'none', which lets the target make its own decisions ✨
• -mprintf-kind=<value> — specify the printf lowering scheme (AMDGPU only), and the allowed values are "hostcall" (printing happens during kernel execution — this scheme relies on hostcalls which require the system to support pcie atomics) and "buffered" (printing happens after all kernel threads exit — this uses a printf buffer and does not rely on pcie atomic support)
• -MP — create a phony target for each dependency (other than the main file)
• -mqdsp6-compat — enable hexagon-qdsp6 backward compatibility
• -MQ <value> — specify the name of the main file output to quote in the depfile
• -mrecip=<value> — control use of approximate reciprocal and reciprocal square root instructions followed by <n> iterations of Newton-Raphson refinement. The grammar, fr fr:

<value> = ( ['!'] ['vec-'] ('rcp'|'sqrt') [('h'|'s'|'d')] [':'<n>] ) | 'all' | 'default' | 'none'

• -mrecip — equivalent to -mrecip=all, periodt
• -mrecord-mcount — generate a __mcount_loc section entry for each __fentry__ call
• -mregnames — use full register names when writing assembly output
• -mrelax-all — (integrated-as) relax all machine instructions
• -mrelax — enable linker relaxation
• -mreserve-frame-pointer-reg — reserve the frame pointer register even if the function doesn't have a frame 👑
• -mrestrict-it — disallow generation of complex IT blocks. It is off by default.
• -mrtd — make StdCall calling convention the default
• -mrvv-vector-bits=<value> — specify the size in bits of an RVV vector register
• -msave-reg-params — save arguments passed by registers to ABI-defined stack positions
• -msave-restore — enable using library calls for save and restore
• -mscalar-strict-align — force all scalar memory accesses to be aligned (RISC-V only)
• -mscq — enable the sc.q instruction
• -mseses — enable speculative execution side effect suppression (SESES). Includes LVI control flow integrity mitigations 🛡️
• -msign-return-address=<value> — select return address signing scope
• -msimd=<value> — select the SIMD extension(s) to be enabled in LoongArch, either 'none', 'lsx', or 'lasx'
• -mskip-rax-setup — skip setting up the RAX register when passing variable arguments (x86 only)
• -msmall-data-limit=<value> — put global and static data smaller than the limit into a special section
• -msoft-float — use software floating point
• -msse2avx — specify that the assembler should encode SSE instructions with the VEX prefix
• -mstack-alignment=<value> — set the stack alignment
• -mstack-arg-probe — enable stack probes
• -mstack-probe-size=<value> — set the stack probe size
• -mstack-protector-guard-offset=<value> — use the given offset for addressing the stack-protector guard
• -mstack-protector-guard-reg=<value> — use the given reg for addressing the stack-protector guard
• -mstack-protector-guard-symbol=<value> — use the given symbol for addressing the stack-protector guard
• -mstack-protector-guard=<value> — use the given guard (global, tls) for addressing the stack-protector guard
• -mstackrealign — force realign the stack at entry to every function
• -mstrict-align — force all memory accesses to be aligned (AArch64/LoongArch/RISC-V only)
• -msve-streaming-vector-bits=<value> — specify the size in bits of an SVE vector register in streaming mode. Defaults to the vector length agnostic value of "scalable". (AArch64 only) 🌊
• -msve-vector-bits=<value> — specify the size in bits of an SVE vector register. Defaults to the vector length agnostic value of "scalable". (AArch64 only)
• -msvr4-struct-return — return small structs in registers (PPC32 only)
• -mtargetos=<value> — set the deployment target to be the specified OS and OS version
• -mtgsplit — enable threadgroup split execution mode (AMDGPU only)
• -mthread-model <value> — the thread model to use. Defaults to 'posix'.
• -mtls-dialect=<value> — which thread-local storage dialect to use for dynamic accesses of TLS variables
• -mtls-direct-seg-refs — enable direct TLS access through segment registers (this one's the default 💅)
• -mtls-size=<value> — 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)
• -mtocdata=<value> — specifies a list of variables to which the TOC data transformation will be applied
• -mtocdata — all suitable variables will have the TOC data transformation applied 🎉
• -mtp=<value> — thread pointer access method. For AArch32: 'soft' uses a function call, or 'tpidrurw', 'tpidruro' or 'tpidrprw' use the three CP15 registers. 'cp15' is an alias for 'tpidruro'. For AArch64: 'tpidr_el0', 'tpidr_el1', 'tpidr_el2', 'tpidr_el3' or 'tpidrro_el0' use the five system registers. 'elN' is an alias for 'tpidr_elN'.
• -mtune=<value> — only supported on AArch64, PowerPC, RISC-V, SPARC, SystemZ, and X86
• -MT <value> — specify the name of the main file output in the depfile
• -multi-lib-config=<file> — path to the YAML configuration file to be used for multilib selection
• -munaligned-access — allow memory accesses to be unaligned (AArch32/MIPSr6 only)
• -munaligned-symbols — expect external char-aligned symbols to be without ABI alignment (SystemZ only)
• -mv8plus — enable V8+ mode, allowing use of 64-bit V9 instructions in 32-bit code
• -mvector-strict-align — force all vector memory accesses to be aligned (RISC-V only)
• -mvevpu — emit VPU instructions for VE
• -MV — use NMake/Jom format for the depfile
• -mwavefrontsize64 — specify wavefront size 64 mode (AMDGPU only)
• -mxcoff-build-id=<0xHEXSTRING> — on AIX, request creation of a build-id string, "0xHEXSTRING", in the string table of the loader section inside the linked binary
• -mxcoff-roptr — place constant objects with relocatable address values in the RO data section and add -bforceimprw to the linker flags (AIX only)
• -mzos-hlq-clang=<ClangHLQ> — high level qualifier for z/OS C++RT side deck datasets
• -mzos-hlq-csslib=<CsslibHLQ> — high level qualifier for z/OS CSSLIB dataset
• -mzos-hlq-le=<LeHLQ> — high level qualifier for z/OS Language Environment datasets
• -mzos-sys-include=<SysInclude> — path to system headers on z/OS
• -mzos-target=<value> — set the z/OS release of the runtime environment
• -M — like -MD, but it also implies -E and writes to stdout by default 👀
• --no-cuda-include-ptx=<value> — okay so this is you telling clang "bestie, do not include PTX for this GPU architecture" — you pass a value like sm_35, or literally just 'all' if you're feeling chaotic 💅 May be specified more than once, so stack 'em if you got 'em.
• --no-cuda-version-check — normally if the CUDA install you've got is too low a version for the CUDA gpu architecture you asked for, clang errors out and ruins your day. This flag says "no, don't do that" and skips the error 🙈
• --no-default-config — disables loading the default configuration files. they simply do not load. ✨
• --no-gpu-bundle-output — do not bundle the output files of HIP device compilation.
• -no-hip-rt — do not link against the HIP runtime libraries.
• --no-offload-arch=<value> — removes a CUDA/HIP offloading device architecture (e.g. sm_35, gfx906) from the list of devices to compile for. Pass 'all' and it resets the whole list back to its default value 👑
• --no-offload-inc — no include paths for CUDA/HIP, and no including the default CUDA/HIP wrapper headers either.
• --no-offload-new-driver — don't Use the new driver for offloading compilation.
• --no-offloadlib — do not link the device library for CUDA/HIP/SYCL device compilation.
• --no-system-header-prefix=<prefix> — every #include path that starts with <prefix> gets treated as not including a system header.
• --no-wasm-opt — disables the wasm-opt optimizer. gone. 🚫
• -nobuiltininc — disables the builtin #include directories only.
• -nohipwrapperinc — does not include the default HIP wrapper headers, and not the include paths either.
• -nolibsycl — do not link the SYCL runtime library.
• -nostdinc++ — disables the standard #include directories for the C++ standard library.
• -nostdinc — disables both the standard system #include directories and the builtin #include directories. everything. all at once. 💀
• -nostdlibinc — disables the standard system #include directories only.
• -ObjC++ — treat source input files as Objective-C++ inputs 💖
• -ObjC — treat source input files as Objective-C inputs.
• -object-file-name=<file> — sets the output <file> for debug infos.
• -Ofast<value> — deprecated! the elders say use '-O3 -ffast-math' for the exact same behavior, or just '-O3' if you want only the conforming optimizations. no cap.
• --offload-arch-tool=<value> — the tool used for detecting offloading architectures in the system.
• --offload-arch=<value> — specify an offloading device architecture for CUDA, HIP, or OpenMP (e.g. sm_35). Pass 'native' and the compiler will detect the locally installed architectures for you, so iconic. For HIP offloading, the device architecture can be followed by target ID features delimited by a colon (e.g. gfx908:xnack+:sramecc-). May be specified more than once ✨
• --offload-compress — compress offload device binaries (HIP and SYCL only).
• --offload-device-only — only compile for the offloading device.
• --offload-host-device — compile for both the offloading host and device. this one's the default btw 🫶
• --offload-host-only — only compile for the offloading host.
• --offload-inc — add include paths for CUDA/HIP and include the default CUDA/HIP wrapper headers. also the default 💅
• --offload-jobs=<value> — specify the number of threads to use for device offloading tasks during compilation. can be a positive integer, or the string 'jobserver' to use the make-style jobserver from the environment. multitasking queen.
• --offload-link — use the new offloading linker to perform the link job.
• --offload-new-driver — use the new driver for offloading compilation.
• --offload-targets=<value> — specify a list of target architectures to use for offloading.
• --offload=<value> — specify a comma-separated list of offloading target triples (CUDA and HIP only).
• --offloadlib — link device libraries for GPU device compilation.
• -o <file> — write output to <file>.
• -pedantic — warn on language extensions. no extensions. be normal. 😭
• -pg — enable mcount instrumentation.
• -pipe — use pipes between commands, when possible.
• --precompile — only precompile the input.
• --pretty-sgf — emit pretty printed symbol graphs. pretty!!! 🎀
• -print-diagnostic-options — print all of Clang's warning options. all of them.
• -print-effective-triple — print the effective target triple.
• -print-enabled-extensions — print the extensions enabled by the given target and -march/-mcpu options. (AArch64 and RISC-V only)
• -print-file-name=<file> — print the full library path of <file>.
• -print-ivar-layout — enable Objective-C Ivar layout bitmap print trace.
• -print-libgcc-file-name — print the library path for the compiler runtime library currently in use ("libgcc.a" or "libclang_rt.builtins.*.a").
• -print-library-module-manifest-path — print the path for the C++ Standard library module manifest.
• -print-multi-flags-experimental — print the flags used for selecting multilibs (experimental 👀).
• -print-prog-name=<name> — print the full program path of <name>.
• -print-resource-dir — print the resource directory pathname.
• -print-rocm-search-dirs — print the paths used for finding the ROCm installation.
• -print-runtime-dir — print the directory pathname containing Clang's runtime libraries.
• -print-search-dirs — print the paths used for finding libraries and programs.
• -print-supported-cpus — print supported cpu models for the given target (if the target isn't specified, it will print the supported cpus for the default target).
• -print-supported-extensions — print supported -march extensions (RISC-V, AArch64 and ARM only).
• -print-target-triple — print the normalized target triple.
• -print-targets — print the registered targets.
• -pthread — support POSIX threads in generated code.
• --ptxas-path=<value> — path to ptxas (used for compiling CUDA code).

---

• -P — disable linemarker output in -E mode.
• -p — enable mcount instrumentation with prof.
• -Qn — do not emit metadata containing the compiler name and version.
• -Qunused-arguments — don't emit a warning for unused driver arguments. mind your business, driver.
• -Qy — emit metadata containing the compiler name and version.
• -regcall4 — set __regcall4 as a default calling convention to respect __regcall ABI v.4.
• -relocatable-pch — whether to build a relocatable precompiled header.
• -resource-dir <value> — the directory which holds the compiler resource files.
• -rewrite-legacy-objc — rewrite Legacy Objective-C source to C++.
• -rewrite-objc — rewrite Objective-C source to C++.
• --rocm-device-lib-path=<value> — ROCm device library path. Alternative to rocm-path.
• --rocm-path=<value> — 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> — report missed transformations by optimization passes whose name matches the given POSIX regular expression.
• -Rpass=<value> — report transformations performed by optimization passes whose name matches the given POSIX regular expression.
• -rtlib=<value> — compiler runtime library to use.
• -R<remark> — enable the specified remark.
• -save-offload-code=<value> — save offload code generated during compilation into the user provided directory.
• -save-stats=<value> — save llvm statistics.
• -save-stats — save llvm statistics.
• -save-temps=<value> — save intermediate compilation results. <arg> can be set to 'cwd' for current working directory, or 'obj' which will save temporary files in the same directory as the final output file.
• -save-temps — alias for --save-temps=cwd.
• -serialize-diagnostics <value> — serialize compiler diagnostics to a file.
• -shared-libsan — dynamically link the sanitizer runtime.
• --start-no-unused-arguments — don't emit warnings about unused arguments for the following arguments. (a little "shhh" for everything after it 🫶)
• -static-libclosure — generate code for statically linking libclosure (BlocksRuntime).
• -static-libsan — statically link the sanitizer runtime (Not supported for ASan, TSan or UBSan on darwin).
• -static-openmp — use the static host OpenMP runtime while linking.
• -std=<value> — language standard to compile for.
• -stdlib++-isystem <directory> — use directory as the C++ standard library include path.
• -stdlib=<value> — C++ standard library to use.
• -sycl-std=<value> — SYCL language standard to compile for.
• --symbol-graph-dir=<value> — directory in which to emit symbol graphs.
• --system-header-prefix=<prefix> — treat all #include paths starting with <prefix> as including a system header.
• -S — only run preprocess and compilation steps.
• --target=<value> — generate code for the given target.
• -time — time individual commands. clock it, bestie ⏱️
• -traditional-cpp — enable some traditional CPP emulation.
• -trigraphs — process trigraph sequences.
• -T <script> — specify <script> as linker script.
• -undef — undef all system defines.
• -unwindlib=<value> — unwind library to use.
• -U <macro> — undefine macro <macro>.
• --verify-debug-info — verify the binary representation of debug output.
• -verify-pch — load and verify that a pre-compiled header file is not stale. get that PCH a vibe check 🦋
• --version — print version information.
• -vfsoverlay <value> — overlay the virtual filesystem described by file over the real file system. Additionally, pass this overlay file to the linker if it supports it.
• -v — show commands to run and use verbose output.
• -Wa,<arg> — pass the comma separated arguments in <arg> to the assembler.
• --warning-suppression-mappings=<value> — file containing diagnostic suppression mappings. See user manual for file format.
• --wasm-opt — enable the wasm-opt optimizer (default).
• -Wl,<arg> — pass the comma separated arguments in <arg> to the linker.
• -working-directory <value> — resolve file paths relative to the specified directory.
• -Wp,<arg> — pass the comma separated arguments in <arg> to the preprocessor.
• -W<warning> — enable the specified warning.
• -w — suppress all warnings. shhh. 🤫
• -Xanalyzer <arg> — pass <arg> to the static analyzer.
• -Xarch_device <arg> — pass <arg> to device compilation in the offloading toolchain.
• -Xarch_host <arg> — pass <arg> to host compilation in the offloading toolchain.
• -Xarch_<arch> <arg> — if the target matches <arch>, then boom, <arg> goes straight to the compilation. Conditional bestie behavior ✨
• -Xassembler <arg> — hands <arg> over to the assembler
• -Xclang=<arg> — just an alias for -Xclang. that's it, that's the whole job 💅
• -Xclangas=<arg> — alias for -Xclangas, same vibe
• -Xclangas <arg> — passes <arg> to clang -cc1as
• -Xclang <arg> — passes <arg> to clang -cc1
• -Xcuda-fatbinary <arg> — passes <arg> into the fatbinary invocation
• -Xcuda-ptxas <arg> — passes <arg> to the ptxas assembler
• -Xlinker <arg> — passes <arg> to the linker
• -Xoffload-linker<triple> <arg> — passes <arg> to the offload linkers, or specifically to the ones identified by -<triple>
• -Xopenmp-target=<triple> <arg> — passes <arg> to the target offloading toolchain that <triple> points at.
• -Xopenmp-target <arg> — passes <arg> to the target offloading toolchain. no triple needed, it just goes 🫶
• -Xpreprocessor <arg> — passes <arg> to the preprocessor
• -Xsycl-target-backend=<triple> <arg> — passes <arg> to the SYCL based backend that <triple> identifies.
• -Xsycl-target-backend <arg> — passes <arg> to the SYCL based target backend.
• -Xsycl-target-frontend=<triple> <arg> — passes <arg> to the SYCL based target frontend that <triple> identifies.
• -Xsycl-target-frontend <arg> — passes <arg> to the SYCL based target frontend.
• -Xsycl-target-linker=<triple> <arg> — passes <arg> to the SYCL based target linker that <triple> identifies.
• -Xsycl-target-linker <arg> — passes <arg> to the SYCL based target linker.
• -Xs <arg> — passes <arg> to the offline compiler.
• -Xs<arg> — passes <arg> to the offline compiler, except it also slaps the option specifier - onto the front of <arg> first. sneaky but iconic 🎀
• -Xthinlto-distributor=<arg> — passes <arg> to the ThinLTO distributor process. you can drop this one multiple times, or comma-separate the values, whichever fits your vibe.
• -x <language> — treats every input file after this point as being type <language>
• -z <arg> — passes -z <arg> to the linker

---

🌈 dxc compatibility options 🌈

okay so these next ones are the let's move from DXC to Clang squad, bestie 💜

• --dxv-path=<value> — DXIL validator installation path
• -fdx-rootsignature-define=<value> — overrides the entry function root signature with the root signature sitting at the given macro name.
• -fdx-rootsignature-version=<value> — Root Signature Version
• -fspv-extension=<value> — tells it which SPIR-V extensions are available. if you don't pass this one at all, then all extensions are available (greedy, love that for us). if you pass KHR, then all the KHR extensions are available. and if you pass DXC, then all the extensions implemented by the DirectX Shader compiler become available. this one is literally the move if you're migrating from DXC over to Clang.
• -fspv-target-env=<value> — specifies the target environment
• /hlsl-all-resources-bound — enables agressive flattening
• -hlsl-entry <value> — entry point name for hlsl

---

💖 SEE ALSO 💖

the whole entire full documentation for clang-22 lives as a Texinfo manual. so if the info program and the clang-22 program are both properly installed on your machine, this command

info clang-22

is gonna hand you the complete manual. go get it, it's giving encyclopedia but make it cute 🦋

---

and that's a wrap on the whole page, bestie!! no cap, you read all of it 💅 this beauty comes to you from clang-22 7.0.1-0ubuntu2, dated September 2026, and it answers to the name CLANG-22(1) 👑 mwah, go compile something iconic 🎀✨