Руководство avr gcc

Option Summary

Here is a summary of all the options, grouped by type.
Explanations are in the following sections.

Overall
Options

-c -S -E -o file -dumpbase dumpbase
-dumpbase-ext auxdropsuf -dumpdir dumppfx
-x language -v -###
—help[=class[,…]] —target-help
—version -pass-exit-codes -pipe -specs=file
-wrapper @file
-ffile-prefix-map=old=new
-fcanon-prefix-map -fplugin=file
-fplugin-arg-name=arg
-fdump-ada-spec[-slim] -fada-spec-parent=unit
-fdump-go-spec=file

C Language Options

-ansi -std=standard -aux-info filename
-fno-asm -fno-builtin -fno-builtin-function
-fcond-mismatch -ffreestanding -fgimple -fgnu-tm -fgnu89-inline
-fhosted -flax-vector-conversions -fms-extensions
-foffload=arg -foffload-options=arg
-fopenacc -fopenacc-dim=geom -fopenmp -fopenmp-simd
-fopenmp-target-simd-clone[=device-type]
-fpermitted-flt-eval-methods=standard -fplan9-extensions
-fsigned-bitfields -funsigned-bitfields -fsigned-char
-funsigned-char -fstrict-flex-arrays[=n]
-fsso-struct=endianness

C++ Language
Options

-fabi-version=n -fno-access-control
-faligned-new=n -fargs-in-order=n -fchar8_t
-fcheck-new -fconstexpr-depth=n
-fconstexpr-cache-depth=n
-fconstexpr-loop-limit=n
-fconstexpr-ops-limit=n -fno-elide-constructors
-fno-enforce-eh-specs -fno-gnu-keywords
-fno-implicit-templates -fno-implicit-inline-templates
-fno-implement-inlines -fmodule-header[=kind]
-fmodule-only -fmodules-ts -fmodule-implicit-inline
-fno-module-lazy -fmodule-mapper=specification
-fmodule-version-ignore -fms-extensions
-fnew-inheriting-ctors -fnew-ttp-matching
-fno-nonansi-builtins -fnothrow-opt -fno-operator-names
-fno-optional-diags -fpermissive -fno-pretty-templates
-fno-rtti -fsized-deallocation
-ftemplate-backtrace-limit=n
-ftemplate-depth=n -fno-threadsafe-statics
-fuse-cxa-atexit -fno-weak -nostdinc++
-fvisibility-inlines-hidden -fvisibility-ms-compat
-fext-numeric-literals
-flang-info-include-translate[=header]
-flang-info-include-translate-not
-flang-info-module-cmi[=module]
-stdlib=libstdc++,libc++ -Wabi-tag -Wcatch-value
-Wcatch-value=n -Wno-class-conversion -Wclass-memaccess
-Wcomma-subscript -Wconditionally-supported -Wno-conversion-null
-Wctad-maybe-unsupported -Wctor-dtor-privacy
-Wdangling-reference -Wno-delete-incomplete
-Wdelete-non-virtual-dtor -Wno-deprecated-array-compare
-Wdeprecated-copy -Wdeprecated-copy-dtor
-Wno-deprecated-enum-enum-conversion
-Wno-deprecated-enum-float-conversion -Weffc++ -Wno-exceptions
-Wextra-semi -Wno-inaccessible-base -Wno-inherited-variadic-ctor
-Wno-init-list-lifetime -Winvalid-constexpr
-Winvalid-imported-macros -Wno-invalid-offsetof
-Wno-literal-suffix -Wmismatched-new-delete -Wmismatched-tags
-Wmultiple-inheritance -Wnamespaces -Wnarrowing -Wnoexcept
-Wnoexcept-type -Wnon-virtual-dtor -Wpessimizing-move
-Wno-placement-new -Wplacement-new=n -Wrange-loop-construct
-Wredundant-move -Wredundant-tags -Wreorder -Wregister
-Wstrict-null-sentinel -Wno-subobject-linkage -Wtemplates
-Wno-non-template-friend -Wold-style-cast -Woverloaded-virtual
-Wno-pmf-conversions -Wself-move -Wsign-promo -Wsized-deallocation
-Wsuggest-final-methods -Wsuggest-final-types
-Wsuggest-override -Wno-terminate -Wuseless-cast
-Wno-vexing-parse -Wvirtual-inheritance
-Wno-virtual-move-assign -Wvolatile
-Wzero-as-null-pointer-constant

Objective-C
and Objective-C++ Language Options

-fconstant-string-class=class-name -fgnu-runtime
-fnext-runtime -fno-nil-receivers
-fobjc-abi-version=n -fobjc-call-cxx-cdtors
-fobjc-direct-dispatch -fobjc-exceptions -fobjc-gc
-fobjc-nilcheck -fobjc-std=objc1 -fno-local-ivars
-fivar-visibility=[public|protected|private|package]
-freplace-objc-classes -fzero-link -gen-decls
-Wassign-intercept -Wno-property-assign-default -Wno-protocol
-Wobjc-root-class -Wselector -Wstrict-selector-match
-Wundeclared-selector

Diagnostic
Message Formatting Options

-fmessage-length=n -fdiagnostics-plain-output
-fdiagnostics-show-location=[once|every-line]
-fdiagnostics-color=[auto|never|always]
-fdiagnostics-urls=[auto|never|always]
-fdiagnostics-format=[text|sarif-stderr|sarif-file|json|json-stderr|json-file]
-fno-diagnostics-show-option -fno-diagnostics-show-caret
-fno-diagnostics-show-labels -fno-diagnostics-show-line-numbers
-fno-diagnostics-show-cwe -fno-diagnostics-show-rule
-fdiagnostics-minimum-margin-width=width
-fdiagnostics-parseable-fixits -fdiagnostics-generate-patch
-fdiagnostics-show-template-tree -fno-elide-type
-fdiagnostics-path-format=[none|separate-events|inline-events]
-fdiagnostics-show-path-depths -fno-show-column
-fdiagnostics-column-unit=[display|byte]
-fdiagnostics-column-origin=origin
-fdiagnostics-escape-format=[unicode|bytes]

Warning
Options

-fsyntax-only -fmax-errors=n -Wpedantic
-pedantic-errors -w -Wextra -Wall -Wabi=n
-Waddress -Wno-address-of-packed-member -Waggregate-return
-Walloc-size-larger-than=byte-size -Walloc-zero
-Walloca -Walloca-larger-than=byte-size
-Wno-aggressive-loop-optimizations -Warith-conversion
-Warray-bounds -Warray-bounds=n -Warray-compare
-Wno-attributes -Wattribute-alias=n
-Wno-attribute-alias -Wno-attribute-warning
-Wbidi-chars=[none|unpaired|any|ucn]
-Wbool-compare -Wbool-operation
-Wno-builtin-declaration-mismatch -Wno-builtin-macro-redefined
-Wc90-c99-compat -Wc99-c11-compat -Wc11-c2x-compat
-Wc++-compat -Wc++11-compat -Wc++14-compat -Wc++17-compat
-Wc++20-compat -Wno-c++11-extensions -Wno-c++14-extensions
-Wno-c++17-extensions -Wno-c++20-extensions
-Wno-c++23-extensions -Wcast-align -Wcast-align=strict
-Wcast-function-type -Wcast-qual -Wchar-subscripts
-Wclobbered -Wcomment -Wno-complain-wrong-lang
-Wconversion -Wno-coverage-mismatch -Wno-cpp -Wdangling-else
-Wdangling-pointer -Wdangling-pointer=n -Wdate-time
-Wno-deprecated -Wno-deprecated-declarations -Wno-designated-init
-Wdisabled-optimization -Wno-discarded-array-qualifiers
-Wno-discarded-qualifiers -Wno-div-by-zero -Wdouble-promotion
-Wduplicated-branches -Wduplicated-cond -Wempty-body
-Wno-endif-labels -Wenum-compare -Wenum-conversion
-Wenum-int-mismatch -Werror -Werror=* -Wexpansion-to-defined
-Wfatal-errors -Wfloat-conversion -Wfloat-equal -Wformat
-Wformat=2 -Wno-format-contains-nul -Wno-format-extra-args
-Wformat-nonliteral -Wformat-overflow=n -Wformat-security
-Wformat-signedness -Wformat-truncation=n -Wformat-y2k
-Wframe-address -Wframe-larger-than=byte-size
-Wno-free-nonheap-object -Wno-if-not-aligned
-Wno-ignored-attributes -Wignored-qualifiers
-Wno-incompatible-pointer-types -Wimplicit -Wimplicit-fallthrough
-Wimplicit-fallthrough=n -Wno-implicit-function-declaration
-Wno-implicit-int -Winfinite-recursion -Winit-self -Winline
-Wno-int-conversion -Wint-in-bool-context -Wno-int-to-pointer-cast
-Wno-invalid-memory-model -Winvalid-pch -Winvalid-utf8 -Wno-unicode
-Wjump-misses-init -Wlarger-than=byte-size
-Wlogical-not-parentheses -Wlogical-op -Wlong-long
-Wno-lto-type-mismatch -Wmain -Wmaybe-uninitialized
-Wmemset-elt-size -Wmemset-transposed-args
-Wmisleading-indentation -Wmissing-attributes -Wmissing-braces
-Wmissing-field-initializers -Wmissing-format-attribute
-Wmissing-include-dirs -Wmissing-noreturn -Wno-missing-profile
-Wno-multichar -Wmultistatement-macros -Wnonnull -Wnonnull-compare
-Wnormalized=[none|id|nfc|nfkc]
-Wnull-dereference -Wno-odr -Wopenacc-parallelism
-Wopenmp-simd -Wno-overflow -Woverlength-strings
-Wno-override-init-side-effects -Wpacked
-Wno-packed-bitfield-compat -Wpacked-not-aligned -Wpadded
-Wparentheses -Wno-pedantic-ms-format -Wpointer-arith
-Wno-pointer-compare -Wno-pointer-to-int-cast -Wno-pragmas
-Wno-prio-ctor-dtor -Wredundant-decls -Wrestrict
-Wno-return-local-addr -Wreturn-type -Wno-scalar-storage-order
-Wsequence-point -Wshadow -Wshadow=global -Wshadow=local
-Wshadow=compatible-local -Wno-shadow-ivar
-Wno-shift-count-negative -Wno-shift-count-overflow
-Wshift-negative-value -Wno-shift-overflow
-Wshift-overflow=n -Wsign-compare -Wsign-conversion
-Wno-sizeof-array-argument -Wsizeof-array-div
-Wsizeof-pointer-div -Wsizeof-pointer-memaccess
-Wstack-protector -Wstack-usage=byte-size
-Wstrict-aliasing -Wstrict-aliasing=n -Wstrict-overflow
-Wstrict-overflow=n -Wstring-compare
-Wno-stringop-overflow -Wno-stringop-overread
-Wno-stringop-truncation -Wstrict-flex-arrays
-Wsuggest-attribute=[pure|const|noreturn|format|malloc]
-Wswitch -Wno-switch-bool -Wswitch-default -Wswitch-enum
-Wno-switch-outside-range -Wno-switch-unreachable -Wsync-nand
-Wsystem-headers -Wtautological-compare -Wtrampolines -Wtrigraphs
-Wtrivial-auto-var-init -Wtsan -Wtype-limits -Wundef
-Wuninitialized -Wunknown-pragmas -Wunsuffixed-float-constants
-Wunused -Wunused-but-set-parameter -Wunused-but-set-variable
-Wunused-const-variable -Wunused-const-variable=n
-Wunused-function -Wunused-label -Wunused-local-typedefs
-Wunused-macros -Wunused-parameter -Wno-unused-result
-Wunused-value -Wunused-variable -Wno-varargs
-Wvariadic-macros -Wvector-operation-performance -Wvla
-Wvla-larger-than=byte-size -Wno-vla-larger-than
-Wvolatile-register-var -Wwrite-strings -Wxor-used-as-pow
-Wzero-length-bounds

Static Analyzer
Options

-fanalyzer -fanalyzer-call-summaries
-fanalyzer-checker=name -fno-analyzer-feasibility
-fanalyzer-fine-grained -fno-analyzer-state-merge
-fno-analyzer-state-purge -fno-analyzer-suppress-followups
-fanalyzer-transitivity -fno-analyzer-undo-inlining
-fanalyzer-verbose-edges -fanalyzer-verbose-state-changes
-fanalyzer-verbosity=level -fdump-analyzer
-fdump-analyzer-callgraph -fdump-analyzer-exploded-graph
-fdump-analyzer-exploded-nodes
-fdump-analyzer-exploded-nodes-2
-fdump-analyzer-exploded-nodes-3
-fdump-analyzer-exploded-paths -fdump-analyzer-feasibility
-fdump-analyzer-json -fdump-analyzer-state-purge
-fdump-analyzer-stderr -fdump-analyzer-supergraph
-fdump-analyzer-untracked -Wno-analyzer-double-fclose
-Wno-analyzer-double-free
-Wno-analyzer-exposure-through-output-file
-Wno-analyzer-exposure-through-uninit-copy
-Wno-analyzer-fd-access-mode-mismatch
-Wno-analyzer-fd-double-close -Wno-analyzer-fd-leak
-Wno-analyzer-fd-phase-mismatch
-Wno-analyzer-fd-type-mismatch
-Wno-analyzer-fd-use-after-close
-Wno-analyzer-fd-use-without-check -Wno-analyzer-file-leak
-Wno-analyzer-free-of-non-heap
-Wno-analyzer-imprecise-fp-arithmetic
-Wno-analyzer-infinite-recursion
-Wno-analyzer-jump-through-null -Wno-analyzer-malloc-leak
-Wno-analyzer-mismatching-deallocation
-Wno-analyzer-null-argument -Wno-analyzer-null-dereference
-Wno-analyzer-out-of-bounds
-Wno-analyzer-possible-null-argument
-Wno-analyzer-possible-null-dereference
-Wno-analyzer-putenv-of-auto-var
-Wno-analyzer-shift-count-negative
-Wno-analyzer-shift-count-overflow
-Wno-analyzer-stale-setjmp-buffer
-Wno-analyzer-tainted-allocation-size
-Wno-analyzer-tainted-assertion
-Wno-analyzer-tainted-array-index
-Wno-analyzer-tainted-divisor -Wno-analyzer-tainted-offset
-Wno-analyzer-tainted-size -Wanalyzer-too-complex
-Wno-analyzer-unsafe-call-within-signal-handler
-Wno-analyzer-use-after-free
-Wno-analyzer-use-of-pointer-in-stale-stack-frame
-Wno-analyzer-use-of-uninitialized-value
-Wno-analyzer-va-arg-type-mismatch
-Wno-analyzer-va-list-exhausted -Wno-analyzer-va-list-leak
-Wno-analyzer-va-list-use-after-va-end
-Wno-analyzer-write-to-const
-Wno-analyzer-write-to-string-literal

C and Objective-C-only
Warning Options

-Wbad-function-cast -Wmissing-declarations
-Wmissing-parameter-type -Wmissing-prototypes -Wnested-externs
-Wold-style-declaration -Wold-style-definition
-Wstrict-prototypes -Wtraditional -Wtraditional-conversion
-Wdeclaration-after-statement -Wpointer-sign

Debugging
Options

-g -glevel -gdwarf -gdwarf-version -gbtf
-gctf -gctflevel -ggdb -grecord-gcc-switches
-gno-record-gcc-switches -gstrict-dwarf -gno-strict-dwarf
-gas-loc-support -gno-as-loc-support -gas-locview-support
-gno-as-locview-support -gcolumn-info -gno-column-info -gdwarf32
-gdwarf64 -gstatement-frontiers -gno-statement-frontiers
-gvariable-location-views -gno-variable-location-views
-ginternal-reset-location-views -gno-internal-reset-location-views
-ginline-points -gno-inline-points -gvms
-gz[=type] -gsplit-dwarf -gdescribe-dies
-gno-describe-dies
-fdebug-prefix-map=old=new
-fdebug-types-section -fno-eliminate-unused-debug-types
-femit-struct-debug-baseonly -femit-struct-debug-reduced
-femit-struct-debug-detailed[=spec-list]
-fno-eliminate-unused-debug-symbols -femit-class-debug-always
-fno-merge-debug-strings -fno-dwarf2-cfi-asm -fvar-tracking
-fvar-tracking-assignments

Optimization
Options

-faggressive-loop-optimizations
-falign-functions[=n[:m:[n2[:m2]]]]
-falign-jumps[=n[:m:[n2[:m2]]]]
-falign-labels[=n[:m:[n2[:m2]]]]
-falign-loops[=n[:m:[n2[:m2]]]]
-fno-allocation-dce -fallow-store-data-races -fassociative-math
-fauto-profile -fauto-profile[=path] -fauto-inc-dec
-fbranch-probabilities -fcaller-saves
-fcombine-stack-adjustments -fconserve-stack -fcompare-elim
-fcprop-registers -fcrossjumping -fcse-follow-jumps
-fcse-skip-blocks -fcx-fortran-rules -fcx-limited-range
-fdata-sections -fdce -fdelayed-branch
-fdelete-null-pointer-checks -fdevirtualize
-fdevirtualize-speculatively -fdevirtualize-at-ltrans -fdse
-fearly-inlining -fipa-sra -fexpensive-optimizations
-ffat-lto-objects -ffast-math -ffinite-math-only -ffloat-store
-fexcess-precision=style -ffinite-loops
-fforward-propagate -ffp-contract=style
-ffunction-sections -fgcse -fgcse-after-reload -fgcse-las
-fgcse-lm -fgraphite-identity -fgcse-sm -fhoist-adjacent-loads
-fif-conversion -fif-conversion2 -findirect-inlining
-finline-functions -finline-functions-called-once
-finline-limit=n -finline-small-functions -fipa-modref
-fipa-cp -fipa-cp-clone -fipa-bit-cp -fipa-vrp -fipa-pta
-fipa-profile -fipa-pure-const -fipa-reference
-fipa-reference-addressable -fipa-stack-alignment -fipa-icf
-fira-algorithm=algorithm -flive-patching=level
-fira-region=region -fira-hoist-pressure
-fira-loop-pressure -fno-ira-share-save-slots
-fno-ira-share-spill-slots -fisolate-erroneous-paths-dereference
-fisolate-erroneous-paths-attribute -fivopts
-fkeep-inline-functions -fkeep-static-functions
-fkeep-static-consts -flimit-function-alignment
-flive-range-shrinkage -floop-block -floop-interchange
-floop-strip-mine -floop-unroll-and-jam -floop-nest-optimize
-floop-parallelize-all -flra-remat -flto -flto-compression-level
-flto-partition=alg -fmerge-all-constants
-fmerge-constants -fmodulo-sched -fmodulo-sched-allow-regmoves
-fmove-loop-invariants -fmove-loop-stores -fno-branch-count-reg
-fno-defer-pop -fno-fp-int-builtin-inexact -fno-function-cse
-fno-guess-branch-probability -fno-inline -fno-math-errno
-fno-peephole -fno-peephole2 -fno-printf-return-value
-fno-sched-interblock -fno-sched-spec -fno-signed-zeros
-fno-toplevel-reorder -fno-trapping-math
-fno-zero-initialized-in-bss -fomit-frame-pointer
-foptimize-sibling-calls -fpartial-inlining -fpeel-loops
-fpredictive-commoning -fprefetch-loop-arrays
-fprofile-correction -fprofile-use -fprofile-use=path
-fprofile-partial-training -fprofile-values
-fprofile-reorder-functions -freciprocal-math -free
-frename-registers -freorder-blocks
-freorder-blocks-algorithm=algorithm
-freorder-blocks-and-partition -freorder-functions
-frerun-cse-after-loop -freschedule-modulo-scheduled-loops
-frounding-math -fsave-optimization-record
-fsched2-use-superblocks -fsched-pressure -fsched-spec-load
-fsched-spec-load-dangerous
-fsched-stalled-insns-dep[=n]
-fsched-stalled-insns[=n] -fsched-group-heuristic
-fsched-critical-path-heuristic -fsched-spec-insn-heuristic
-fsched-rank-heuristic -fsched-last-insn-heuristic
-fsched-dep-count-heuristic -fschedule-fusion
-fschedule-insns -fschedule-insns2 -fsection-anchors
-fselective-scheduling -fselective-scheduling2
-fsel-sched-pipelining -fsel-sched-pipelining-outer-loops
-fsemantic-interposition -fshrink-wrap -fshrink-wrap-separate
-fsignaling-nans -fsingle-precision-constant
-fsplit-ivs-in-unroller -fsplit-loops -fsplit-paths
-fsplit-wide-types -fsplit-wide-types-early -fssa-backprop
-fssa-phiopt -fstdarg-opt -fstore-merging -fstrict-aliasing
-fipa-strict-aliasing -fthread-jumps -ftracer -ftree-bit-ccp
-ftree-builtin-call-dce -ftree-ccp -ftree-ch
-ftree-coalesce-vars -ftree-copy-prop -ftree-dce
-ftree-dominator-opts -ftree-dse -ftree-forwprop -ftree-fre
-fcode-hoisting -ftree-loop-if-convert -ftree-loop-im
-ftree-phiprop -ftree-loop-distribution
-ftree-loop-distribute-patterns -ftree-loop-ivcanon
-ftree-loop-linear -ftree-loop-optimize -ftree-loop-vectorize
-ftree-parallelize-loops=n -ftree-pre -ftree-partial-pre
-ftree-pta -ftree-reassoc -ftree-scev-cprop -ftree-sink -ftree-slsr
-ftree-sra -ftree-switch-conversion -ftree-tail-merge
-ftree-ter -ftree-vectorize -ftree-vrp -ftrivial-auto-var-init
-funconstrained-commons -funit-at-a-time -funroll-all-loops
-funroll-loops -funsafe-math-optimizations -funswitch-loops
-fipa-ra -fvariable-expansion-in-unroller -fvect-cost-model -fvpt
-fweb -fwhole-program -fwpa -fuse-linker-plugin
-fzero-call-used-regs —param name=value
-O -O0 -O1 -O2 -O3 -Os -Ofast -Og -Oz

Program
Instrumentation Options

-p -pg -fprofile-arcs —coverage -ftest-coverage
-fprofile-abs-path -fprofile-dir=path
-fprofile-generate -fprofile-generate=path
-fprofile-info-section -fprofile-info-section=name
-fprofile-note=path -fprofile-prefix-path=path
-fprofile-update=method
-fprofile-filter-files=regex
-fprofile-exclude-files=regex
-fprofile-reproducible=[multithreaded|parallel-runs|serial]
-fsanitize=style -fsanitize-recover
-fsanitize-recover=style -fsanitize-trap
-fsanitize-trap=style -fasan-shadow-offset=number
-fsanitize-sections=s1,s2,…
-fsanitize-undefined-trap-on-error -fbounds-check
-fcf-protection=[full|branch|return|none|check]
-fharden-compares -fharden-conditional-branches
-fstack-protector -fstack-protector-all -fstack-protector-strong
-fstack-protector-explicit -fstack-check
-fstack-limit-register=reg
-fstack-limit-symbol=sym -fno-stack-limit
-fsplit-stack
-fvtable-verify=[std|preinit|none]
-fvtv-counts -fvtv-debug -finstrument-functions
-finstrument-functions-once
-finstrument-functions-exclude-function-list=sym,sym,…
-finstrument-functions-exclude-file-list=file,file,…
-fprofile-prefix-map=old=new

Preprocessor
Options

-Aquestion=answer
-A-question[=answer] -C -CC
-Dmacro[=defn] -dD -dI -dM -dN -dU
-fdebug-cpp -fdirectives-only -fdollars-in-identifiers
-fexec-charset=charset -fextended-identifiers
-finput-charset=charset -flarge-source-files
-fmacro-prefix-map=old=new
-fmax-include-depth=depth -fno-canonical-system-headers
-fpch-deps -fpch-preprocess -fpreprocessed
-ftabstop=width -ftrack-macro-expansion
-fwide-exec-charset=charset -fworking-directory -H
-imacros file -include file -M -MD -MF -MG -MM
-MMD -MP -MQ -MT -Mno-modules -no-integrated-cpp -P -pthread
-remap -traditional -traditional-cpp -trigraphs
-Umacro -undef -Wp,option
-Xpreprocessor option

Assembler
Options

-Wa,option -Xassembler option

Linker
Options

object-file-name -fuse-ld=linker
-llibrary -nostartfiles -nodefaultlibs -nolibc -nostdlib
-nostdlib++ -e entry —entry=entry -pie
-pthread -r -rdynamic -s -static -static-pie -static-libgcc
-static-libstdc++ -static-libasan -static-libtsan -static-liblsan
-static-libubsan -shared -shared-libgcc -symbolic -T
script -Wl,option -Xlinker option
-u symbol -z keyword

Directory
Options

-Bprefix -Idir -I- -idirafter
dir -imacros file -imultilib dir
-iplugindir=dir -iprefix file -iquote
dir -isysroot dir -isystem dir
-iwithprefix dir -iwithprefixbefore dir
-Ldir -no-canonical-prefixes —no-sysroot-suffix
-nostdinc -nostdinc++ —sysroot=dir

Code Generation
Options

-fcall-saved-reg -fcall-used-reg
-ffixed-reg -fexceptions -fnon-call-exceptions
-fdelete-dead-exceptions -funwind-tables
-fasynchronous-unwind-tables -fno-gnu-unique
-finhibit-size-directive -fcommon -fno-ident -fpcc-struct-return
-fpic -fPIC -fpie -fPIE -fno-plt -fno-jump-tables
-fno-bit-tests -frecord-gcc-switches -freg-struct-return
-fshort-enums -fshort-wchar -fverbose-asm
-fpack-struct[=n] -fleading-underscore
-ftls-model=model -fstack-reuse=reuse_level
-ftrampolines -ftrapv -fwrapv
-fvisibility=[default|internal|hidden|protected]
-fstrict-volatile-bitfields -fsync-libcalls

Developer
Options

-dletters -dumpspecs -dumpmachine -dumpversion
-dumpfullversion -fcallgraph-info[=su,da] -fchecking
-fchecking=n -fdbg-cnt-list
-fdbg-cnt=counter-value-list
-fdisable-ipa-pass_name
-fdisable-rtl-pass_name
-fdisable-rtl-pass-name=range-list
-fdisable-tree-pass_name
-fdisable-tree-pass-name=range-list
-fdump-debug -fdump-earlydebug -fdump-noaddr -fdump-unnumbered
-fdump-unnumbered-links -fdump-final-insns[=file]
-fdump-ipa-all -fdump-ipa-cgraph -fdump-ipa-inline
-fdump-lang-all -fdump-lang-switch
-fdump-lang-switch—options
-fdump-lang-switch—options=filename
-fdump-passes -fdump-rtl-pass
-fdump-rtl-pass=filename
-fdump-statistics -fdump-tree-all
-fdump-tree-switch
-fdump-tree-switch—options
-fdump-tree-switch—options=filename
-fcompare-debug[=opts] -fcompare-debug-second
-fenable-kind—pass
-fenable-kind—pass=range-list
-fira-verbose=n -flto-report -flto-report-wpa
-fmem-report-wpa -fmem-report -fpre-ipa-mem-report
-fpost-ipa-mem-report -fopt-info
-fopt-info-options[=file] -fmultiflags
-fprofile-report -frandom-seed=string
-fsched-verbose=n -fsel-sched-verbose
-fsel-sched-dump-cfg -fsel-sched-pipelining-verbose -fstats
-fstack-usage -ftime-report -ftime-report-details
-fvar-tracking-assignments-toggle -gtoggle
-print-file-name=library -print-libgcc-file-name
-print-multi-directory -print-multi-lib -print-multi-os-directory
-print-prog-name=program -print-search-dirs -Q
-print-sysroot -print-sysroot-headers-suffix -save-temps
-save-temps=cwd -save-temps=obj -time[=file]

Machine-Dependent
Options

AArch64 Options -mabi=name -mbig-endian
-mlittle-endian -mgeneral-regs-only -mcmodel=tiny
-mcmodel=small -mcmodel=large -mstrict-align -mno-strict-align
-momit-leaf-frame-pointer -mtls-dialect=desc
-mtls-dialect=traditional -mtls-size=size
-mfix-cortex-a53-835769 -mfix-cortex-a53-843419
-mlow-precision-recip-sqrt -mlow-precision-sqrt -mlow-precision-div
-mpc-relative-literal-loads
-msign-return-address=scope
-mbranch-protection=none|standard|pac-ret[+leaf
+b-key]|bti -mharden-sls=opts
-march=name -mcpu=name
-mtune=name -moverride=string
-mverbose-cost-dump -mstack-protector-guard=guard
-mstack-protector-guard-reg=sysreg
-mstack-protector-guard-offset=offset
-mtrack-speculation -moutline-atomics

Adapteva Epiphany Options -mhalf-reg-file
-mprefer-short-insn-regs -mbranch-cost=num -mcmove
-mnops=num -msoft-cmpsf -msplit-lohi -mpost-inc
-mpost-modify -mstack-offset=num -mround-nearest
-mlong-calls -mshort-calls -msmall16 -mfp-mode=mode
-mvect-double -max-vect-align=num -msplit-vecmove-early
-m1reg-reg

AMD GCN Options -march=gpu
-mtune=gpu -mstack-size=bytes

ARC Options -mbarrel-shifter -mjli-always
-mcpu=cpu -mA6 -mARC600 -mA7 -mARC700 -mdpfp
-mdpfp-compact -mdpfp-fast -mno-dpfp-lrsr -mea -mno-mpy
-mmul32x16 -mmul64 -matomic -mnorm -mspfp -mspfp-compact
-mspfp-fast -msimd -msoft-float -mswap -mcrc -mdsp-packa -mdvbf
-mlock -mmac-d16 -mmac-24 -mrtsc -mswape -mtelephony -mxy -misize
-mannotate-align -marclinux -marclinux_prof -mlong-calls
-mmedium-calls -msdata -mirq-ctrl-saved -mrgf-banked-regs
-mlpc-width=width -G num -mvolatile-cache
-mtp-regno=regno -malign-call -mauto-modify-reg
-mbbit-peephole -mno-brcc -mcase-vector-pcrel -mcompact-casesi
-mno-cond-exec -mearly-cbranchsi -mexpand-adddi -mindexed-loads
-mlra -mlra-priority-none -mlra-priority-compact
-mlra-priority-noncompact -mmillicode -mmixed-code -mq-class
-mRcq -mRcw -msize-level=level -mtune=cpu
-mmultcost=num -mcode-density-frame
-munalign-prob-threshold=probability
-mmpy-option=multo -mdiv-rem -mcode-density -mll64
-mfpu=fpu -mrf16 -mbranch-index

ARM Options -mapcs-frame -mno-apcs-frame
-mabi=name -mapcs-stack-check -mno-apcs-stack-check
-mapcs-reentrant -mno-apcs-reentrant -mgeneral-regs-only
-msched-prolog -mno-sched-prolog -mlittle-endian
-mbig-endian -mbe8 -mbe32 -mfloat-abi=name
-mfp16-format=name -mthumb-interwork
-mno-thumb-interwork -mcpu=name
-march=name -mfpu=name
-mtune=name -mprint-tune-info
-mstructure-size-boundary=n -mabort-on-noreturn
-mlong-calls -mno-long-calls -msingle-pic-base
-mno-single-pic-base -mpic-register=reg
-mnop-fun-dllimport -mpoke-function-name -mthumb -marm
-mflip-thumb -mtpcs-frame -mtpcs-leaf-frame
-mcaller-super-interworking -mcallee-super-interworking
-mtp=name -mtls-dialect=dialect
-mword-relocations -mfix-cortex-m3-ldrd
-mfix-cortex-a57-aes-1742098 -mfix-cortex-a72-aes-1655431
-munaligned-access -mneon-for-64bits
-mslow-flash-data -masm-syntax-unified
-mrestrict-it -mverbose-cost-dump -mpure-code
-mcmse -mfix-cmse-cve-2021-35465
-mstack-protector-guard=guard
-mstack-protector-guard-offset=offset -mfdpic
-mbranch-protection=none|standard|pac-ret[+leaf]
[+bti]|bti[+pac-ret[+leaf]]

AVR Options -mmcu=mcu -mabsdata
-maccumulate-args -mbranch-cost=cost
-mcall-prologues -mgas-isr-prologues -mint8
-mdouble=bits -mlong-double=bits
-mn_flash=size -mno-interrupts -mmain-is-OS_task
-mrelax -mrmw -mstrict-X -mtiny-stack
-mfract-convert-truncate -mshort-calls -nodevicelib
-nodevicespecs -Waddr-space-convert -Wmisspelled-isr

Blackfin Options
-mcpu=cpu[—sirevision] -msim
-momit-leaf-frame-pointer -mno-omit-leaf-frame-pointer
-mspecld-anomaly -mno-specld-anomaly -mcsync-anomaly
-mno-csync-anomaly -mlow-64k -mno-low64k -mstack-check-l1
-mid-shared-library -mno-id-shared-library
-mshared-library-id=n -mleaf-id-shared-library
-mno-leaf-id-shared-library -msep-data -mno-sep-data -mlong-calls
-mno-long-calls -mfast-fp -minline-plt -mmulticore -mcorea
-mcoreb -msdram -micplb

C6X Options -mbig-endian -mlittle-endian
-march=cpu -msim -msdata=sdata-type

CRIS Options -mcpu=cpu
-march=cpu -mtune=cpu
-mmax-stack-frame=n -metrax4 -metrax100 -mpdebug
-mcc-init -mno-side-effects -mstack-align -mdata-align
-mconst-align -m32-bit -m16-bit -m8-bit
-mno-prologue-epilogue -melf -maout -sim -sim2
-mmul-bug-workaround -mno-mul-bug-workaround

C-SKY Options -march=arch
-mcpu=cpu -mbig-endian -EB -mlittle-endian -EL
-mhard-float -msoft-float -mfpu=fpu -mdouble-float
-mfdivdu -mfloat-abi=name -melrw -mistack -mmp -mcp
-mcache -msecurity -mtrust -mdsp -medsp -mvdsp -mdiv
-msmart -mhigh-registers -manchor -mpushpop -mmultiple-stld
-mconstpool -mstack-size -mccrt -mbranch-cost=n
-mcse-cc -msched-prolog -msim

Darwin Options -all_load -allowable_client -arch
-arch_errors_fatal -arch_only -bind_at_load -bundle
-bundle_loader -client_name -compatibility_version
-current_version -dead_strip -dependency-file -dylib_file
-dylinker_install_name -dynamic -dynamiclib
-exported_symbols_list -filelist -flat_namespace
-force_cpusubtype_ALL -force_flat_namespace
-headerpad_max_install_names -iframework -image_base -init
-install_name -keep_private_externs -multi_module
-multiply_defined -multiply_defined_unused -noall_load
-no_dead_strip_inits_and_terms -nofixprebinding -nomultidefs
-noprebind -noseglinkedit -pagezero_size -prebind
-prebind_all_twolevel_modules -private_bundle -read_only_relocs
-sectalign -sectobjectsymbols -whyload -seg1addr
-sectcreate -sectobjectsymbols -sectorder -segaddr
-segs_read_only_addr -segs_read_write_addr -seg_addr_table
-seg_addr_table_filename -seglinkedit -segprot
-segs_read_only_addr -segs_read_write_addr -single_module -static
-sub_library -sub_umbrella -twolevel_namespace -umbrella
-undefined -unexported_symbols_list
-weak_reference_mismatches -whatsloaded -F -gused -gfull
-mmacosx-version-min=version -mkernel
-mone-byte-bool

DEC Alpha Options -mno-fp-regs -msoft-float
-mieee -mieee-with-inexact -mieee-conformant
-mfp-trap-mode=mode -mfp-rounding-mode=mode
-mtrap-precision=mode -mbuild-constants
-mcpu=cpu-type -mtune=cpu-type -mbwx
-mmax -mfix -mcix -mfloat-vax -mfloat-ieee
-mexplicit-relocs -msmall-data -mlarge-data -msmall-text
-mlarge-text -mmemory-latency=time

eBPF Options -mbig-endian -mlittle-endian
-mkernel=version -mframe-limit=bytes -mxbpf
-mco-re -mno-co-re -mjmpext -mjmp32 -malu32
-mcpu=version

FR30 Options -msmall-model -mno-lsim

FT32 Options -msim -mlra -mnodiv -mft32b -mcompress
-mnopm

FRV Options -mgpr-32 -mgpr-64 -mfpr-32 -mfpr-64
-mhard-float -msoft-float -malloc-cc -mfixed-cc -mdword
-mno-dword -mdouble -mno-double -mmedia -mno-media
-mmuladd -mno-muladd -mfdpic -minline-plt -mgprel-ro
-multilib-library-pic -mlinked-fp -mlong-calls -malign-labels
-mlibrary-pic -macc-4 -macc-8 -mpack -mno-pack -mno-eflags
-mcond-move -mno-cond-move -moptimize-membar
-mno-optimize-membar -mscc -mno-scc -mcond-exec
-mno-cond-exec -mvliw-branch -mno-vliw-branch
-mmulti-cond-exec -mno-multi-cond-exec -mnested-cond-exec
-mno-nested-cond-exec -mtomcat-stats -mTLS -mtls
-mcpu=cpu

GNU/Linux Options -mglibc -muclibc -mmusl -mbionic
-mandroid -tno-android-cc -tno-android-ld

H8/300 Options -mrelax -mh -ms -mn -mexr -mno-exr
-mint32 -malign-300

HPPA Options -march=architecture-type
-matomic-libcalls -mbig-switch -mcaller-copies
-mdisable-fpregs -mdisable-indexing -mordered
-mfast-indirect-calls -mgas -mgnu-ld -mhp-ld
-mfixed-range=register-range -mcoherent-ldcw
-mjump-in-delay -mlinker-opt -mlong-calls -mlong-load-store
-mno-atomic-libcalls -mno-disable-fpregs -mno-disable-indexing
-mno-fast-indirect-calls -mno-gas -mno-jump-in-delay
-mno-long-load-store -mno-portable-runtime -mno-soft-float
-mno-space-regs -msoft-float -mpa-risc-1-0 -mpa-risc-1-1
-mpa-risc-2-0 -mportable-runtime -mschedule=cpu-type
-mspace-regs -msoft-mult -msio -mwsio
-munix=unix-std -nolibdld -static -threads

IA-64 Options -mbig-endian -mlittle-endian -mgnu-as
-mgnu-ld -mno-pic -mvolatile-asm-stop -mregister-names -msdata
-mno-sdata -mconstant-gp -mauto-pic -mfused-madd
-minline-float-divide-min-latency
-minline-float-divide-max-throughput
-mno-inline-float-divide -minline-int-divide-min-latency
-minline-int-divide-max-throughput -mno-inline-int-divide
-minline-sqrt-min-latency -minline-sqrt-max-throughput
-mno-inline-sqrt -mdwarf2-asm -mearly-stop-bits
-mfixed-range=register-range
-mtls-size=tls-size -mtune=cpu-type
-milp32 -mlp64 -msched-br-data-spec -msched-ar-data-spec
-msched-control-spec -msched-br-in-data-spec
-msched-ar-in-data-spec -msched-in-control-spec -msched-spec-ldc
-msched-spec-control-ldc -msched-prefer-non-data-spec-insns
-msched-prefer-non-control-spec-insns
-msched-stop-bits-after-every-cycle
-msched-count-spec-in-critical-path
-msel-sched-dont-check-control-spec -msched-fp-mem-deps-zero-cost
-msched-max-memory-insns-hard-limit
-msched-max-memory-insns=max-insns

LM32 Options -mbarrel-shift-enabled -mdivide-enabled
-mmultiply-enabled -msign-extend-enabled -muser-enabled

LoongArch Options -march=cpu-type
-mtune=cpu-type -mabi=base-abi-type
-mfpu=fpu-type -msoft-float -msingle-float
-mdouble-float -mbranch-cost=n
-mcheck-zero-division -mno-check-zero-division -mcond-move-int
-mno-cond-move-int -mcond-move-float -mno-cond-move-float
-memcpy -mno-memcpy -mstrict-align -mno-strict-align
-mmax-inline-memcpy-size=n -mexplicit-relocs
-mno-explicit-relocs -mdirect-extern-access
-mno-direct-extern-access -mcmodel=code-model

M32R/D Options -m32r2 -m32rx -m32r
-mdebug -malign-loops -mno-align-loops
-missue-rate=number -mbranch-cost=number
-mmodel=code-size-model-type
-msdata=sdata-type -mno-flush-func
-mflush-func=name -mno-flush-trap
-mflush-trap=number -G num

M32C Options -mcpu=cpu -msim
-memregs=number

M680x0 Options -march=arch
-mcpu=cpu -mtune=tune -m68000 -m68020
-m68020-40 -m68020-60 -m68030 -m68040 -m68060 -mcpu32 -m5200
-m5206e -m528x -m5307 -m5407 -mcfv4e -mbitfield -mno-bitfield
-mc68000 -mc68020 -mnobitfield -mrtd -mno-rtd -mdiv -mno-div
-mshort -mno-short -mhard-float -m68881 -msoft-float -mpcrel
-malign-int -mstrict-align -msep-data -mno-sep-data
-mshared-library-id=n -mid-shared-library -mno-id-shared-library
-mxgot -mno-xgot -mlong-jump-table-offsets

MCore Options -mhardlit -mno-hardlit -mdiv -mno-div
-mrelax-immediates -mno-relax-immediates -mwide-bitfields
-mno-wide-bitfields -m4byte-functions -mno-4byte-functions
-mcallgraph-data -mno-callgraph-data -mslow-bytes -mno-slow-bytes
-mno-lsim -mlittle-endian -mbig-endian -m210 -m340
-mstack-increment

MicroBlaze Options -msoft-float -mhard-float
-msmall-divides -mcpu=cpu -mmemcpy -mxl-soft-mul
-mxl-soft-div -mxl-barrel-shift -mxl-pattern-compare
-mxl-stack-check -mxl-gp-opt -mno-clearbss -mxl-multiply-high
-mxl-float-convert -mxl-float-sqrt -mbig-endian -mlittle-endian
-mxl-reorder -mxl-mode-app-model
-mpic-data-is-text-relative

MIPS Options -EL -EB -march=arch
-mtune=arch -mips1 -mips2 -mips3 -mips4 -mips32
-mips32r2 -mips32r3 -mips32r5 -mips32r6 -mips64 -mips64r2
-mips64r3 -mips64r5 -mips64r6 -mips16 -mno-mips16
-mflip-mips16 -minterlink-compressed
-mno-interlink-compressed -minterlink-mips16
-mno-interlink-mips16 -mabi=abi -mabicalls
-mno-abicalls -mshared -mno-shared -mplt -mno-plt -mxgot
-mno-xgot -mgp32 -mgp64 -mfp32 -mfpxx -mfp64 -mhard-float
-msoft-float -mno-float -msingle-float -mdouble-float
-modd-spreg -mno-odd-spreg -mabs=mode
-mnan=encoding -mdsp -mno-dsp -mdspr2 -mno-dspr2
-mmcu -mmno-mcu -meva -mno-eva -mvirt -mno-virt
-mxpa -mno-xpa -mcrc -mno-crc -mginv -mno-ginv
-mmicromips -mno-micromips -mmsa -mno-msa
-mloongson-mmi -mno-loongson-mmi -mloongson-ext
-mno-loongson-ext -mloongson-ext2 -mno-loongson-ext2
-mfpu=fpu-type -msmartmips -mno-smartmips
-mpaired-single -mno-paired-single -mdmx -mno-mdmx -mips3d
-mno-mips3d -mmt -mno-mt -mllsc -mno-llsc -mlong64 -mlong32
-msym32 -mno-sym32 -Gnum -mlocal-sdata
-mno-local-sdata -mextern-sdata -mno-extern-sdata -mgpopt
-mno-gopt -membedded-data -mno-embedded-data
-muninit-const-in-rodata -mno-uninit-const-in-rodata
-mcode-readable=setting -msplit-addresses
-mno-split-addresses -mexplicit-relocs -mno-explicit-relocs
-mcheck-zero-division -mno-check-zero-division -mdivide-traps
-mdivide-breaks -mload-store-pairs -mno-load-store-pairs
-munaligned-access -mno-unaligned-access -mmemcpy -mno-memcpy
-mlong-calls -mno-long-calls -mmad -mno-mad -mimadd -mno-imadd
-mfused-madd -mno-fused-madd -nocpp -mfix-24k -mno-fix-24k
-mfix-r4000 -mno-fix-r4000 -mfix-r4400 -mno-fix-r4400
-mfix-r5900 -mno-fix-r5900 -mfix-r10000 -mno-fix-r10000
-mfix-rm7000 -mno-fix-rm7000 -mfix-vr4120 -mno-fix-vr4120
-mfix-vr4130 -mno-fix-vr4130 -mfix-sb1 -mno-fix-sb1
-mflush-func=func -mno-flush-func
-mbranch-cost=num -mbranch-likely
-mno-branch-likely -mcompact-branches=policy
-mfp-exceptions -mno-fp-exceptions -mvr4130-align
-mno-vr4130-align -msynci -mno-synci -mlxc1-sxc1 -mno-lxc1-sxc1
-mmadd4 -mno-madd4 -mrelax-pic-calls -mno-relax-pic-calls
-mmcount-ra-address -mframe-header-opt
-mno-frame-header-opt

MMIX Options -mlibfuncs -mno-libfuncs -mepsilon
-mno-epsilon -mabi=gnu -mabi=mmixware -mzero-extend -mknuthdiv
-mtoplevel-symbols -melf -mbranch-predict -mno-branch-predict
-mbase-addresses -mno-base-addresses -msingle-exit
-mno-single-exit

MN10300 Options -mmult-bug -mno-mult-bug
-mno-am33 -mam33 -mam33-2 -mam34 -mtune=cpu-type
-mreturn-pointer-on-d0 -mno-crt0 -mrelax -mliw -msetlb

Moxie Options -meb -mel -mmul.x -mno-crt0

MSP430 Options -msim -masm-hex -mmcu= -mcpu= -mlarge
-msmall -mrelax -mwarn-mcu -mcode-region=
-mdata-region= -msilicon-errata= -msilicon-errata-warn=
-mhwmult= -minrt -mtiny-printf -mmax-inline-shift=

NDS32 Options -mbig-endian -mlittle-endian
-mreduced-regs -mfull-regs -mcmov -mno-cmov -mext-perf
-mno-ext-perf -mext-perf2 -mno-ext-perf2 -mext-string
-mno-ext-string -mv3push -mno-v3push -m16bit
-mno-16bit -misr-vector-size=num
-mcache-block-size=num -march=arch
-mcmodel=code-model -mctor-dtor -mrelax

Nios II Options -G num
-mgpopt=option -mgpopt -mno-gpopt
-mgprel-sec=regexp -mr0rel-sec=regexp
-mel -meb -mno-bypass-cache -mbypass-cache
-mno-cache-volatile -mcache-volatile -mno-fast-sw-div
-mfast-sw-div -mhw-mul -mno-hw-mul -mhw-mulx -mno-hw-mulx
-mno-hw-div -mhw-div -mcustom-insn=N
-mno-custom-insn -mcustom-fpu-cfg=name
-mhal -msmallc -msys-crt0=name
-msys-lib=name -march=arch -mbmx -mno-bmx
-mcdx -mno-cdx

Nvidia PTX Options -m64 -mmainkernel
-moptimize

OpenRISC Options -mboard=name -mnewlib
-mhard-mul -mhard-div -msoft-mul -msoft-div -msoft-float
-mhard-float -mdouble-float -munordered-float -mcmov -mror -mrori
-msext -msfimm -mshftimm -mcmodel=code-model

PDP-11 Options -mfpu -msoft-float -mac0 -mno-ac0
-m40 -m45 -m10 -mint32 -mno-int16 -mint16 -mno-int32
-msplit -munix-asm -mdec-asm -mgnu-asm -mlra

PowerPC Options See RS/6000 and PowerPC Options.

PRU Options -mmcu=mcu -minrt
-mno-relax -mloop -mabi=variant

RISC-V Options
-mbranch-cost=N-instruction -mplt -mno-plt
-mabi=ABI-string -mfdiv -mno-fdiv -mdiv
-mno-div -misa-spec=ISA-spec-string
-march=ISA-string -mtune=processor-string
-mpreferred-stack-boundary=num
-msmall-data-limit=N-bytes -msave-restore
-mno-save-restore -mshorten-memrefs -mno-shorten-memrefs
-mstrict-align -mno-strict-align -mcmodel=medlow
-mcmodel=medany -mexplicit-relocs -mno-explicit-relocs
-mrelax -mno-relax -mriscv-attribute -mno-riscv-attribute
-malign-data=type -mbig-endian -mlittle-endian
-mstack-protector-guard=guard
-mstack-protector-guard-reg=reg
-mstack-protector-guard-offset=offset -mcsr-check
-mno-csr-check -minline-atomics -mno-inline-atomics

RL78 Options -msim -mmul=none -mmul=g13 -mmul=g14
-mallregs -mcpu=g10 -mcpu=g13 -mcpu=g14 -mg10 -mg13 -mg14
-m64bit-doubles -m32bit-doubles -msave-mduc-in-interrupts

RS/6000 and PowerPC Options
-mcpu=cpu-type -mtune=cpu-type
-mcmodel=code-model -mpowerpc64 -maltivec
-mno-altivec -mpowerpc-gpopt -mno-powerpc-gpopt
-mpowerpc-gfxopt -mno-powerpc-gfxopt -mmfcrf -mno-mfcrf
-mpopcntb -mno-popcntb -mpopcntd -mno-popcntd -mfprnd
-mno-fprnd -mcmpb -mno-cmpb -mhard-dfp -mno-hard-dfp
-mfull-toc -mminimal-toc -mno-fp-in-toc -mno-sum-in-toc -m64
-m32 -mxl-compat -mno-xl-compat -mpe -malign-power
-malign-natural -msoft-float -mhard-float -mmultiple
-mno-multiple -mupdate -mno-update
-mavoid-indexed-addresses -mno-avoid-indexed-addresses
-mfused-madd -mno-fused-madd -mbit-align -mno-bit-align
-mstrict-align -mno-strict-align -mrelocatable
-mno-relocatable -mrelocatable-lib -mno-relocatable-lib -mtoc
-mno-toc -mlittle -mlittle-endian -mbig -mbig-endian
-mdynamic-no-pic -mswdiv -msingle-pic-base
-mprioritize-restricted-insns=priority
-msched-costly-dep=dependence_type
-minsert-sched-nops=scheme -mcall-aixdesc -mcall-eabi
-mcall-freebsd -mcall-linux -mcall-netbsd -mcall-openbsd
-mcall-sysv -mcall-sysv-eabi -mcall-sysv-noeabi
-mtraceback=traceback_type -maix-struct-return
-msvr4-struct-return -mabi=abi-type -msecure-plt
-mbss-plt -mlongcall -mno-longcall -mpltseq -mno-pltseq
-mblock-move-inline-limit=num
-mblock-compare-inline-limit=num
-mblock-compare-inline-loop-limit=num
-mno-block-ops-unaligned-vsx
-mstring-compare-inline-limit=num -misel -mno-isel
-mvrsave -mno-vrsave -mmulhw -mno-mulhw -mdlmzb
-mno-dlmzb -mprototype -mno-prototype -msim -mmvme -mads
-myellowknife -memb -msdata -msdata=opt
-mreadonly-in-sdata -mvxworks -G num -mrecip
-mrecip=opt -mno-recip -mrecip-precision
-mno-recip-precision -mveclibabi=type -mfriz
-mno-friz -mpointers-to-nested-functions
-mno-pointers-to-nested-functions -msave-toc-indirect
-mno-save-toc-indirect -mpower8-fusion -mno-mpower8-fusion
-mpower8-vector -mno-power8-vector -mcrypto -mno-crypto -mhtm
-mno-htm -mquad-memory -mno-quad-memory
-mquad-memory-atomic -mno-quad-memory-atomic
-mcompat-align-parm -mno-compat-align-parm -mfloat128
-mno-float128 -mfloat128-hardware -mno-float128-hardware
-mgnu-attribute -mno-gnu-attribute
-mstack-protector-guard=guard
-mstack-protector-guard-reg=reg
-mstack-protector-guard-offset=offset -mprefixed
-mno-prefixed -mpcrel -mno-pcrel -mmma -mno-mmma -mrop-protect
-mno-rop-protect -mprivileged -mno-privileged

RX Options -m64bit-doubles -m32bit-doubles -fpu
-nofpu -mcpu= -mbig-endian-data -mlittle-endian-data
-msmall-data -msim -mno-sim -mas100-syntax
-mno-as100-syntax -mrelax -mmax-constant-size=
-mint-register= -mpid -mallow-string-insns
-mno-allow-string-insns -mjsr
-mno-warn-multiple-fast-interrupts
-msave-acc-in-interrupts

S/390 and zSeries Options -mtune=cpu-type
-march=cpu-type -mhard-float -msoft-float -mhard-dfp
-mno-hard-dfp -mlong-double-64 -mlong-double-128
-mbackchain -mno-backchain -mpacked-stack -mno-packed-stack
-msmall-exec -mno-small-exec -mmvcle -mno-mvcle -m64 -m31
-mdebug -mno-debug -mesa -mzarch -mhtm -mvx -mzvector
-mtpf-trace -mno-tpf-trace -mtpf-trace-skip -mno-tpf-trace-skip
-mfused-madd -mno-fused-madd -mwarn-framesize
-mwarn-dynamicstack -mstack-size -mstack-guard
-mhotpatch=halfwords,halfwords

SH Options -m1 -m2 -m2e -m2a-nofpu
-m2a-single-only -m2a-single -m2a -m3 -m3e -m4-nofpu
-m4-single-only -m4-single -m4 -m4a-nofpu -m4a-single-only
-m4a-single -m4a -m4al -mb -ml -mdalign -mrelax -mbigtable
-mfmovd -mrenesas -mno-renesas -mnomacsave -mieee -mno-ieee
-mbitops -misize -minline-ic_invalidate -mpadstruct -mprefergot
-musermode -multcost=number -mdiv=strategy
-mdivsi3_libfunc=name
-mfixed-range=register-range
-maccumulate-outgoing-args
-matomic-model=atomic-model
-mbranch-cost=num -mzdcbranch -mno-zdcbranch
-mcbranch-force-delay-slot -mfused-madd -mno-fused-madd -mfsca
-mno-fsca -mfsrra -mno-fsrra -mpretend-cmove -mtas

Solaris 2 Options -mclear-hwcap -mno-clear-hwcap
-mimpure-text -mno-impure-text -pthreads

SPARC Options -mcpu=cpu-type
-mtune=cpu-type -mcmodel=code-model
-mmemory-model=mem-model -m32 -m64 -mapp-regs
-mno-app-regs -mfaster-structs -mno-faster-structs -mflat
-mno-flat -mfpu -mno-fpu -mhard-float -msoft-float
-mhard-quad-float -msoft-quad-float -mstack-bias
-mno-stack-bias -mstd-struct-return -mno-std-struct-return
-munaligned-doubles -mno-unaligned-doubles -muser-mode
-mno-user-mode -mv8plus -mno-v8plus -mvis -mno-vis -mvis2
-mno-vis2 -mvis3 -mno-vis3 -mvis4 -mno-vis4 -mvis4b
-mno-vis4b -mcbcond -mno-cbcond -mfmaf -mno-fmaf -mfsmuld
-mno-fsmuld -mpopc -mno-popc -msubxc -mno-subxc
-mfix-at697f -mfix-ut699 -mfix-ut700 -mfix-gr712rc -mlra
-mno-lra

System V Options -Qy -Qn -YP,paths
-Ym,dir

V850 Options -mlong-calls -mno-long-calls -mep
-mno-ep -mprolog-function -mno-prolog-function -mspace
-mtda=n -msda=n -mzda=n
-mapp-regs -mno-app-regs -mdisable-callt
-mno-disable-callt -mv850e2v3 -mv850e2 -mv850e1 -mv850es
-mv850e -mv850 -mv850e3v5 -mloop -mrelax
-mlong-jumps -msoft-float -mhard-float
-mgcc-abi -mrh850-abi -mbig-switch

VAX Options -mg -mgnu -munix -mlra

Visium Options -mdebug -msim -mfpu -mno-fpu
-mhard-float -msoft-float -mcpu=cpu-type
-mtune=cpu-type -msv-mode -muser-mode

VMS Options -mvms-return-codes
-mdebug-main=prefix -mmalloc64
-mpointer-size=size

VxWorks Options -mrtp -non-static -Bstatic
-Bdynamic -Xbind-lazy -Xbind-now

x86 Options -mtune=cpu-type
-march=cpu-type -mtune-ctrl=feature-list
-mdump-tune-features -mno-default -mfpmath=unit
-masm=dialect -mno-fancy-math-387
-mno-fp-ret-in-387 -m80387 -mhard-float -msoft-float
-mno-wide-multiply -mrtd -malign-double
-mpreferred-stack-boundary=num
-mincoming-stack-boundary=num -mcld -mcx16 -msahf
-mmovbe -mcrc32 -mmwait -mrecip -mrecip=opt
-mvzeroupper -mprefer-avx128 -mprefer-vector-width=opt
-mmove-max=bits -mstore-max=bits -mmmx
-msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -msse4 -mavx -mavx2
-mavx512f -mavx512pf -mavx512er -mavx512cd -mavx512vl -mavx512bw
-mavx512dq -mavx512ifma -mavx512vbmi -msha -maes -mpclmul
-mfsgsbase -mrdrnd -mf16c -mfma -mpconfig -mwbnoinvd -mptwrite
-mprefetchwt1 -mclflushopt -mclwb -mxsavec -mxsaves -msse4a
-m3dnow -m3dnowa -mpopcnt -mabm -mbmi -mtbm -mfma4 -mxop -madx
-mlzcnt -mbmi2 -mfxsr -mxsave -mxsaveopt -mrtm -mhle -mlwp
-mmwaitx -mclzero -mpku -mthreads -mgfni -mvaes -mwaitpkg
-mshstk -mmanual-endbr -mcet-switch -mforce-indirect-call
-mavx512vbmi2 -mavx512bf16 -menqcmd -mvpclmulqdq
-mavx512bitalg -mmovdiri -mmovdir64b -mavx512vpopcntdq
-mavx5124fmaps -mavx512vnni -mavx5124vnniw -mprfchw -mrdpid
-mrdseed -msgx -mavx512vp2intersect -mserialize -mtsxldtrk
-mamx-tile -mamx-int8 -mamx-bf16 -muintr -mhreset -mavxvnni
-mavx512fp16 -mavxifma -mavxvnniint8 -mavxneconvert -mcmpccxadd
-mamx-fp16 -mprefetchi -mraoint -mamx-complex -mcldemote
-mms-bitfields -mno-align-stringops -minline-all-stringops
-minline-stringops-dynamically -mstringop-strategy=alg
-mkl -mwidekl -mmemcpy-strategy=strategy
-mmemset-strategy=strategy -mpush-args
-maccumulate-outgoing-args -m128bit-long-double
-m96bit-long-double -mlong-double-64 -mlong-double-80
-mlong-double-128 -mregparm=num -msseregparm
-mveclibabi=type -mvect8-ret-in-mem -mpc32
-mpc64 -mpc80 -mdaz-ftz -mstackrealign -momit-leaf-frame-pointer
-mno-red-zone -mno-tls-direct-seg-refs
-mcmodel=code-model -mabi=name
-maddress-mode=mode -m32 -m64 -mx32 -m16 -miamcu
-mlarge-data-threshold=num -msse2avx -mfentry
-mrecord-mcount -mnop-mcount -m8bit-idiv
-minstrument-return=type -mfentry-name=name
-mfentry-section=name -mavx256-split-unaligned-load
-mavx256-split-unaligned-store -malign-data=type
-mstack-protector-guard=guard
-mstack-protector-guard-reg=reg
-mstack-protector-guard-offset=offset
-mstack-protector-guard-symbol=symbol
-mgeneral-regs-only -mcall-ms2sysv-xlogues -mrelax-cmpxchg-loop
-mindirect-branch=choice
-mfunction-return=choice -mindirect-branch-register
-mharden-sls=choice -mindirect-branch-cs-prefix -mneeded
-mno-direct-extern-access -munroll-only-small-loops
-mlam=choice

x86 Windows Options -mconsole -mcygwin -mno-cygwin
-mdll -mnop-fun-dllimport -mthread -municode -mwin32
-mwindows -fno-set-stack-executable

Xstormy16 Options -msim

Xtensa Options -mconst16 -mno-const16
-mfused-madd -mno-fused-madd -mforce-no-pic
-mserialize-volatile -mno-serialize-volatile
-mtext-section-literals -mno-text-section-literals
-mauto-litpools -mno-auto-litpools -mtarget-align
-mno-target-align -mlongcalls -mno-longcalls
-mabi=abi-type -mextra-l32r-costs=cycles

zSeries Options See S/390 and zSeries Options.

Options Controlling the Kind of Output

Compilation can involve up to four stages: preprocessing,
compilation proper, assembly and linking, always in that order. GCC is
capable of preprocessing and compiling several files either into several
assembler input files, or into one assembler input file; then each assembler
input file produces an object file, and linking combines all the object
files (those newly compiled, and those specified as input) into an
executable file.

For any given input file, the file name suffix determines what
kind of compilation is done:

file.c

C source code that must be preprocessed.

file.i

C source code that should not be preprocessed.

file.ii

C++ source code that should not be preprocessed.

file.m

Objective-C source code. Note that you must link with the libobjc
library to make an Objective-C program work.

file.mi

Objective-C source code that should not be preprocessed.

file.mm

file.M

Objective-C++ source code. Note that you must link with the libobjc
library to make an Objective-C++ program work. Note that .M refers
to a literal capital M.

file.mii

Objective-C++ source code that should not be preprocessed.

file.h

C, C++, Objective-C or Objective-C++ header file to be turned into a
precompiled header (default), or C, C++ header file to be turned into an
Ada spec (via the -fdump-ada-spec switch).

file.cc

file.cp

file.cxx

file.cpp

file.CPP

file.c++

file.C

C++ source code that must be preprocessed. Note that in .cxx, the
last two letters must both be literally x. Likewise, .C
refers to a literal capital C.

file.mm

file.M

Objective-C++ source code that must be preprocessed.

file.mii

Objective-C++ source code that should not be preprocessed.

file.hh

file.H

file.hp

file.hxx

file.hpp

file.HPP

file.h++

file.tcc

C++ header file to be turned into a precompiled header or Ada spec.

file.f

file.for

file.ftn

Fixed form Fortran source code that should not be preprocessed.

file.F

file.FOR

file.fpp

file.FPP

file.FTN

Fixed form Fortran source code that must be preprocessed (with the
traditional preprocessor).

file.f90

file.f95

file.f03

file.f08

Free form Fortran source code that should not be preprocessed.

file.F90

file.F95

file.F03

file.F08

Free form Fortran source code that must be preprocessed (with the
traditional preprocessor).

file.go

Go source code.

file.d

D source code.

file.di

D interface file.

file.dd

D documentation code (Ddoc).

file.ads

Ada source code file that contains a library unit declaration (a
declaration of a package, subprogram, or generic, or a generic
instantiation), or a library unit renaming declaration (a package,
generic, or subprogram renaming declaration). Such files are also called
specs.

file.adb

Ada source code file containing a library unit body (a subprogram or
package body). Such files are also called bodies.

file.s

Assembler code.

file.S

file.sx

Assembler code that must be preprocessed.

other

An object file to be fed straight into linking. Any file name with no
recognized suffix is treated this way.

You can specify the input language explicitly with the -x
option:

-x language

Specify explicitly the language for the following input files
(rather than letting the compiler choose a default based on the file name
suffix). This option applies to all following input files until the next
-x option. Possible values for language are:

c  c-header  cpp-output
c++  c++-header  c++-system-header c++-user-header c++-cpp-output
objective-c  objective-c-header  objective-c-cpp-output
objective-c++ objective-c++-header objective-c++-cpp-output
assembler  assembler-with-cpp
ada
d
f77  f77-cpp-input f95  f95-cpp-input
go

-x none

Turn off any specification of a language, so that subsequent files are
handled according to their file name suffixes (as they are if -x
has not been used at all).

If you only want some of the stages of compilation, you can use
-x (or filename suffixes) to tell gcc where to start, and one
of the options -c, -S, or -E to say where gcc is
to stop. Note that some combinations (for example, -x cpp-output -E)
instruct gcc to do nothing at all.

-c

Compile or assemble the source files, but do not link. The linking stage
simply is not done. The ultimate output is in the form of an object file
for each source file.

By default, the object file name for a source file is made by
replacing the suffix .c, .i, .s, etc., with
.o.

Unrecognized input files, not requiring compilation or
assembly, are ignored.

-S

Stop after the stage of compilation proper; do not assemble. The output is
in the form of an assembler code file for each non-assembler input file
specified.

By default, the assembler file name for a source file is made
by replacing the suffix .c, .i, etc., with .s.

Input files that don’t require compilation are ignored.

-E

Stop after the preprocessing stage; do not run the compiler proper. The
output is in the form of preprocessed source code, which is sent to the
standard output.

Input files that don’t require preprocessing are ignored.

-o file

Place the primary output in file file. This applies to whatever
sort of output is being produced, whether it be an executable file, an
object file, an assembler file or preprocessed C code.

If -o is not specified, the default is to put an
executable file in a.out, the object file for
source.suffix in source.o, its assembler file in
source.s, a precompiled header file in source.suffix.gch,
and all preprocessed C source on standard output.

Though -o names only the primary output, it also
affects the naming of auxiliary and dump outputs. See the examples
below. Unless overridden, both auxiliary outputs and dump outputs are
placed in the same directory as the primary output. In auxiliary
outputs, the suffix of the input file is replaced with that of the
auxiliary output file type; in dump outputs, the suffix of the dump file
is appended to the input file suffix. In compilation commands, the base
name of both auxiliary and dump outputs is that of the primary output;
in compile and link commands, the primary output name, minus the
executable suffix, is combined with the input file name. If both share
the same base name, disregarding the suffix, the result of the
combination is that base name, otherwise, they are concatenated,
separated by a dash.

gcc -c foo.c ...

will use foo.o as the primary output, and place aux
outputs and dumps next to it, e.g., aux file foo.dwo for
-gsplit-dwarf, and dump file foo.c.???r.final for
-fdump-rtl-final.

If a non-linker output file is explicitly specified, aux and
dump files by default take the same base name:

gcc -c foo.c -o dir/foobar.o ...

will name aux outputs dir/foobar.* and dump outputs
dir/foobar.c.*.

A linker output will instead prefix aux and dump outputs:

gcc foo.c bar.c -o dir/foobar ...

will generally name aux outputs dir/foobar-foo.* and
dir/foobar-bar.*, and dump outputs dir/foobar-foo.c.* and
dir/foobar-bar.c.*.

The one exception to the above is when the executable shares
the base name with the single input:

gcc foo.c -o dir/foo ...

in which case aux outputs are named dir/foo.* and dump
outputs named dir/foo.c.*.

The location and the names of auxiliary and dump outputs can
be adjusted by the options -dumpbase, -dumpbase-ext,
-dumpdir, -save-temps=cwd, and -save-temps=obj.

-dumpbase
dumpbase

This option sets the base name for auxiliary and dump output files. It
does not affect the name of the primary output file. Intermediate outputs,
when preserved, are not regarded as primary outputs, but as auxiliary
outputs:

gcc -save-temps -S foo.c

saves the (no longer) temporary preprocessed file in
foo.i, and then compiles to the (implied) output file
foo.s, whereas:

gcc -save-temps -dumpbase save-foo -c foo.c

preprocesses to in save-foo.i, compiles to
save-foo.s (now an intermediate, thus auxiliary output), and then
assembles to the (implied) output file foo.o.

Absent this option, dump and aux files take their names from
the input file, or from the (non-linker) output file, if one is
explicitly specified: dump output files (e.g. those requested by
-fdump-* options) with the input name suffix, and aux output
files (those requested by other non-dump options, e.g.
«-save-temps»,
«-gsplit-dwarf»,
«-fcallgraph-info») without it.

Similar suffix differentiation of dump and aux outputs can be
attained for explicitly-given -dumpbase basename.suf by also
specifying -dumpbase-ext .suf.

If dumpbase is explicitly specified with any directory
component, any dumppfx specification (e.g. -dumpdir or
-save-temps=*) is ignored, and instead of appending to it,
dumpbase fully overrides it:

gcc foo.c -c -o dir/foo.o -dumpbase alt/foo \
  -dumpdir pfx- -save-temps=cwd ...

creates auxiliary and dump outputs named alt/foo.*,
disregarding dir/ in -o, the ./ prefix implied by
-save-temps=cwd, and pfx- in -dumpdir.

When -dumpbase is specified in a command that compiles
multiple inputs, or that compiles and then links, it may be combined
with dumppfx, as specified under -dumpdir. Then, each
input file is compiled using the combined dumppfx, and default
values for dumpbase and auxdropsuf are computed for each
input file:

gcc foo.c bar.c -c -dumpbase main ...

creates foo.o and bar.o as primary outputs, and
avoids overwriting the auxiliary and dump outputs by using the
dumpbase as a prefix, creating auxiliary and dump outputs named
main-foo.* and main-bar.*.

An empty string specified as dumpbase avoids the
influence of the output basename in the naming of auxiliary and dump
outputs during compilation, computing default values :

gcc -c foo.c -o dir/foobar.o -dumpbase " ...

will name aux outputs dir/foo.* and dump outputs
dir/foo.c.*. Note how their basenames are taken from the input
name, but the directory still defaults to that of the output.

The empty-string dumpbase does not prevent the use of the
output basename for outputs during linking:

gcc foo.c bar.c -o dir/foobar -dumpbase " -flto ...

The compilation of the source files will name auxiliary
outputs dir/foo.* and dir/bar.*, and dump outputs
dir/foo.c.* and dir/bar.c.*. LTO recompilation during
linking will use dir/foobar. as the prefix for dumps and
auxiliary files.

-dumpbase-ext
auxdropsuf

When forming the name of an auxiliary (but not a dump) output file, drop
trailing auxdropsuf from dumpbase before appending any
suffixes. If not specified, this option defaults to the suffix of a
default dumpbase, i.e., the suffix of the input file when
-dumpbase is not present in the command line, or dumpbase is
combined with dumppfx.

gcc foo.c -c -o dir/foo.o -dumpbase x-foo.c -dumpbase-ext .c ...

creates dir/foo.o as the main output, and generates
auxiliary outputs in dir/x-foo.*, taking the location of the
primary output, and dropping the .c suffix from the
dumpbase. Dump outputs retain the suffix:
dir/x-foo.c.*.

This option is disregarded if it does not match the suffix of
a specified dumpbase, except as an alternative to the executable
suffix when appending the linker output base name to dumppfx, as
specified below:

gcc foo.c bar.c -o main.out -dumpbase-ext .out ...

creates main.out as the primary output, and avoids
overwriting the auxiliary and dump outputs by using the executable name
minus auxdropsuf as a prefix, creating auxiliary outputs named
main-foo.* and main-bar.* and dump outputs named
main-foo.c.* and main-bar.c.*.

-dumpdir
dumppfx

When forming the name of an auxiliary or dump output file, use
dumppfx as a prefix:

gcc -dumpdir pfx- -c foo.c ...

creates foo.o as the primary output, and auxiliary
outputs named pfx-foo.*, combining the given dumppfx with
the default dumpbase derived from the default primary output,
derived in turn from the input name. Dump outputs also take the input
name suffix: pfx-foo.c.*.

If dumppfx is to be used as a directory name, it must
end with a directory separator:

gcc -dumpdir dir/ -c foo.c -o obj/bar.o ...

creates obj/bar.o as the primary output, and auxiliary
outputs named dir/bar.*, combining the given dumppfx with
the default dumpbase derived from the primary output name. Dump
outputs also take the input name suffix: dir/bar.c.*.

It defaults to the location of the output file, unless the
output file is a special file like
«/dev/null». Options
-save-temps=cwd and -save-temps=obj override this default,
just like an explicit -dumpdir option. In case multiple such
options are given, the last one prevails:

gcc -dumpdir pfx- -c foo.c -save-temps=obj ...

outputs foo.o, with auxiliary outputs named
foo.* because -save-temps=* overrides the dumppfx
given by the earlier -dumpdir option. It does not matter that
=obj is the default for -save-temps, nor that the output
directory is implicitly the current directory. Dump outputs are named
foo.c.*.

When compiling from multiple input files, if -dumpbase
is specified, dumpbase, minus a auxdropsuf suffix, and a
dash are appended to (or override, if containing any directory
components) an explicit or defaulted dumppfx, so that each of the
multiple compilations gets differently-named aux and dump outputs.

gcc foo.c bar.c -c -dumpdir dir/pfx- -dumpbase main ...

outputs auxiliary dumps to dir/pfx-main-foo.* and
dir/pfx-main-bar.*, appending dumpbase— to dumppfx.
Dump outputs retain the input file suffix: dir/pfx-main-foo.c.*
and dir/pfx-main-bar.c.*, respectively. Contrast with the
single-input compilation:

gcc foo.c -c -dumpdir dir/pfx- -dumpbase main ...

that, applying -dumpbase to a single source, does not
compute and append a separate dumpbase per input file. Its
auxiliary and dump outputs go in dir/pfx-main.*.

When compiling and then linking from multiple input files, a
defaulted or explicitly specified dumppfx also undergoes the
dumpbase— transformation above (e.g. the compilation of
foo.c and bar.c above, but without -c). If neither
-dumpdir nor -dumpbase are given, the linker output base
name, minus auxdropsuf, if specified, or the executable suffix
otherwise, plus a dash is appended to the default dumppfx
instead. Note, however, that unlike earlier cases of linking:

gcc foo.c bar.c -dumpdir dir/pfx- -o main ...

does not append the output name main to dumppfx,
because -dumpdir is explicitly specified. The goal is that the
explicitly-specified dumppfx may contain the specified output
name as part of the prefix, if desired; only an explicitly-specified
-dumpbase would be combined with it, in order to avoid simply
discarding a meaningful option.

When compiling and then linking from a single input file, the
linker output base name will only be appended to the default
dumppfx as above if it does not share the base name with the
single input file name. This has been covered in single-input linking
cases above, but not with an explicit -dumpdir that inhibits the
combination, even if overridden by -save-temps=*:

gcc foo.c -dumpdir alt/pfx- -o dir/main.exe -save-temps=cwd ...

Auxiliary outputs are named foo.*, and dump outputs
foo.c.*, in the current working directory as ultimately requested
by -save-temps=cwd.

Summing it all up for an intuitive though slightly imprecise
data flow: the primary output name is broken into a directory part and a
basename part; dumppfx is set to the former, unless overridden by
-dumpdir or -save-temps=*, and dumpbase is set to
the latter, unless overriden by -dumpbase. If there are multiple
inputs or linking, this dumpbase may be combined with
dumppfx and taken from each input file. Auxiliary output names
for each input are formed by combining dumppfx, dumpbase
minus suffix, and the auxiliary output suffix; dump output names are
only different in that the suffix from dumpbase is retained.

When it comes to auxiliary and dump outputs created during LTO
recompilation, a combination of dumppfx and dumpbase, as
given or as derived from the linker output name but not from inputs,
even in cases in which this combination would not otherwise be used as
such, is passed down with a trailing period replacing the compiler-added
dash, if any, as a -dumpdir option to lto-wrapper; being
involved in linking, this program does not normally get any
-dumpbase and -dumpbase-ext, and it ignores them.

When running sub-compilers, lto-wrapper appends LTO
stage names to the received dumppfx, ensures it contains a
directory component so that it overrides any -dumpdir, and passes
that as -dumpbase to sub-compilers.

-v

Print (on standard error output) the commands executed to run the stages
of compilation. Also print the version number of the compiler driver
program and of the preprocessor and the compiler proper.

-###

Like -v except the commands are not executed and arguments are
quoted unless they contain only alphanumeric characters or
«./-_». This is useful for shell scripts
to capture the driver-generated command lines.

—help

Print (on the standard output) a description of the command-line options
understood by gcc. If the -v option is also specified then
—help is also passed on to the various processes invoked by
gcc, so that they can display the command-line options they accept.
If the -Wextra option has also been specified (prior to the
—help option), then command-line options that have no
documentation associated with them are also displayed.

—target-help

Print (on the standard output) a description of target-specific
command-line options for each tool. For some targets extra target-specific
information may also be printed.

—help={class|[^]qualifier}[,…]

Print (on the standard output) a description of the command-line options
understood by the compiler that fit into all specified classes and
qualifiers. These are the supported classes:

--help=target,undocumented

--help=warnings,^joined,^undocumented

--help=target,optimizers

% gcc -Q -mabi=2 --help=target -c
The following options are target specific:
-mabi=                                2
-mabort-on-noreturn                   [disabled]
-mapcs                                [disabled]

-Q -O2 --help=optimizers

gcc -c -Q -O3 --help=optimizers > /tmp/O3-opts
gcc -c -Q -O2 --help=optimizers > /tmp/O2-opts
diff /tmp/O2-opts /tmp/O3-opts | grep enabled

—version

Display the version number and copyrights of the invoked GCC.

-pass-exit-codes

Normally the gcc program exits with the code of 1 if any phase of
the compiler returns a non-success return code. If you specify
-pass-exit-codes, the gcc program instead returns with the
numerically highest error produced by any phase returning an error
indication. The C, C++, and Fortran front ends return 4 if an internal
compiler error is encountered.

-pipe

Use pipes rather than temporary files for communication between the
various stages of compilation. This fails to work on some systems where
the assembler is unable to read from a pipe; but the GNU assembler has no
trouble.

-specs=file

Process file after the compiler reads in the standard specs
file, in order to override the defaults which the gcc driver
program uses when determining what switches to pass to cc1,
cc1plus, as, ld, etc. More than one
-specs=file can be specified on the command line, and they
are processed in order, from left to right.

-wrapper

Invoke all subcommands under a wrapper program. The name of the wrapper
program and its parameters are passed as a comma separated list.

gcc -c t.c -wrapper gdb,--args

This invokes all subprograms of gcc under gdb
—args, thus the invocation of cc1 is gdb —args cc1
….

-ffile-prefix-map=old=new

When compiling files residing in directory old, record any
references to them in the result of the compilation as if the files
resided in directory new instead. Specifying this option is
equivalent to specifying all the individual -f*-prefix-map options.
This can be used to make reproducible builds that are location
independent. Directories referenced by directives are not affected by
these options. See also -fmacro-prefix-map,
-fdebug-prefix-map, -fprofile-prefix-map and
-fcanon-prefix-map.

-fcanon-prefix-map

For the -f*-prefix-map options normally comparison of old
prefix against the filename that would be normally referenced in the
result of the compilation is done using textual comparison of the
prefixes, or ignoring character case for case insensitive filesystems and
considering slashes and backslashes as equal on DOS based filesystems. The
-fcanon-prefix-map causes such comparisons to be done on
canonicalized paths of old and the referenced filename.

-fplugin=name.so

Load the plugin code in file name.so, assumed to be a shared object
to be dlopen’d by the compiler. The base name of the shared object file is
used to identify the plugin for the purposes of argument parsing (See
-fplugin-arg-name—key=value
below). Each plugin should define the callback functions specified in the
Plugins API.

-fplugin-arg-name—key=value

Define an argument called key with a value of value for the
plugin called name.

-fdump-ada-spec[-slim]

For C and C++ source and include files, generate corresponding Ada
specs.

-fada-spec-parent=unit

In conjunction with -fdump-ada-spec[-slim] above, generate
Ada specs as child units of parent unit.

-fdump-go-spec=file

For input files in any language, generate corresponding Go declarations in
file. This generates Go «const»,
«type»,
«var», and
«func» declarations which may be a
useful way to start writing a Go interface to code written in some other
language.

@file

Read command-line options from file. The options read are inserted
in place of the original @file option. If file does not
exist, or cannot be read, then the option will be treated literally, and
not removed.

Options in file are separated by whitespace. A
whitespace character may be included in an option by surrounding the
entire option in either single or double quotes. Any character
(including a backslash) may be included by prefixing the character to be
included with a backslash. The file may itself contain additional
@file options; any such options will be processed
recursively.

Compiling C++ Programs

C++ source files conventionally use one of the suffixes .C,
.cc, .cpp, .CPP, .c++, .cp, or
.cxx; C++ header files often use .hh, .hpp, .H,
or (for shared template code) .tcc; and preprocessed C++ files use
the suffix .ii. GCC recognizes files with these names and compiles
them as C++ programs even if you call the compiler the same way as for
compiling C programs (usually with the name gcc).

However, the use of gcc does not add the C++ library.
g++ is a program that calls GCC and automatically specifies linking
against the C++ library. It treats .c, .h and .i files
as C++ source files instead of C source files unless -x is used. This
program is also useful when precompiling a C header file with a .h
extension for use in C++ compilations. On many systems, g++ is also
installed with the name c++.

When you compile C++ programs, you may specify many of the same
command-line options that you use for compiling programs in any language; or
command-line options meaningful for C and related languages; or options that
are meaningful only for C++ programs.

Options Controlling C Dialect

The following options control the dialect of C (or languages
derived from C, such as C++, Objective-C and Objective-C++) that the
compiler accepts:

-ansi

In C mode, this is equivalent to -std=c90. In C++ mode, it is
equivalent to -std=c++98.

This turns off certain features of GCC that are incompatible
with ISO C90 (when compiling C code), or of standard C++ (when compiling
C++ code), such as the «asm» and
«typeof» keywords, and predefined
macros such as «unix» and
«vax» that identify the type of system
you are using. It also enables the undesirable and rarely used ISO
trigraph feature. For the C compiler, it disables recognition of C++
style // comments as well as the
«inline» keyword.

The alternate keywords
«__asm__»,
«__extension__»,
«__inline__» and
«__typeof__» continue to work despite
-ansi. You would not want to use them in an ISO C program, of
course, but it is useful to put them in header files that might be
included in compilations done with -ansi. Alternate predefined
macros such as «__unix__» and
«__vax__» are also available, with or
without -ansi.

The -ansi option does not cause non-ISO programs to be
rejected gratuitously. For that, -Wpedantic is required in
addition to -ansi.

The macro «__STRICT_ANSI__»
is predefined when the -ansi option is used. Some header files
may notice this macro and refrain from declaring certain functions or
defining certain macros that the ISO standard doesn’t call for; this is
to avoid interfering with any programs that might use these names for
other things.

Functions that are normally built in but do not have semantics
defined by ISO C (such as «alloca» and
«ffs») are not built-in functions when
-ansi is used.

-std=

Determine the language standard. This option is currently only supported
when compiling C or C++.

The compiler can accept several base standards, such as
c90 or c++98, and GNU dialects of those standards, such as
gnu90 or gnu++98. When a base standard is specified, the
compiler accepts all programs following that standard plus those using
GNU extensions that do not contradict it. For example, -std=c90
turns off certain features of GCC that are incompatible with ISO C90,
such as the «asm» and
«typeof» keywords, but not other GNU
extensions that do not have a meaning in ISO C90, such as omitting the
middle term of a «?:» expression. On
the other hand, when a GNU dialect of a standard is specified, all
features supported by the compiler are enabled, even when those features
change the meaning of the base standard. As a result, some
strict-conforming programs may be rejected. The particular standard is
used by -Wpedantic to identify which features are GNU extensions
given that version of the standard. For example -std=gnu90
-Wpedantic warns about C++ style // comments, while
-std=gnu99 -Wpedantic does not.

A value for this option must be provided; possible values
are

-aux-info
filename

Output to the given filename prototyped declarations for all functions
declared and/or defined in a translation unit, including those in header
files. This option is silently ignored in any language other than C.

Besides declarations, the file indicates, in comments, the
origin of each declaration (source file and line), whether the
declaration was implicit, prototyped or unprototyped (I, N
for new or O for old, respectively, in the first character after
the line number and the colon), and whether it came from a declaration
or a definition (C or F, respectively, in the following
character). In the case of function definitions, a K&R-style list of
arguments followed by their declarations is also provided, inside
comments, after the declaration.

-fno-asm

Do not recognize «asm»,
«inline» or
«typeof» as a keyword, so that code can
use these words as identifiers. You can use the keywords
«__asm__»,
«__inline__» and
«__typeof__» instead. In C, -ansi
implies -fno-asm.

In C++, «inline» is a
standard keyword and is not affected by this switch. You may want to use
the -fno-gnu-keywords flag instead, which disables
«typeof» but not
«asm» and
«inline». In C99 mode (-std=c99
or -std=gnu99), this switch only affects the
«asm» and
«typeof» keywords, since
«inline» is a standard keyword in ISO
C99. In C2X mode (-std=c2x or -std=gnu2x), this switch
only affects the «asm» keyword, since
«typeof» is a standard keyword in ISO
C2X.

-fno-builtin

-fno-builtin-function

Don’t recognize built-in functions that do not begin with
__builtin_ as prefix.

GCC normally generates special code to handle certain built-in
functions more efficiently; for instance, calls to
«alloca» may become single
instructions which adjust the stack directly, and calls to
«memcpy» may become inline copy loops.
The resulting code is often both smaller and faster, but since the
function calls no longer appear as such, you cannot set a breakpoint on
those calls, nor can you change the behavior of the functions by linking
with a different library. In addition, when a function is recognized as
a built-in function, GCC may use information about that function to warn
about problems with calls to that function, or to generate more
efficient code, even if the resulting code still contains calls to that
function. For example, warnings are given with -Wformat for bad
calls to «printf» when
«printf» is built in and
«strlen» is known not to modify global
memory.

With the -fno-builtin-function option only the
built-in function function is disabled. function must not
begin with __builtin_. If a function is named that is not
built-in in this version of GCC, this option is ignored. There is no
corresponding -fbuiltin-function option; if you wish to
enable built-in functions selectively when using -fno-builtin or
-ffreestanding, you may define macros such as:

#define abs(n)          __builtin_abs ((n))
#define strcpy(d, s)    __builtin_strcpy ((d), (s))

-fcond-mismatch

Allow conditional expressions with mismatched types in the second and
third arguments. The value of such an expression is void. This option is
not supported for C++.

-ffreestanding

Assert that compilation targets a freestanding environment. This implies
-fno-builtin. A freestanding environment is one in which the
standard library may not exist, and program startup may not necessarily be
at «main». The most obvious example is
an OS kernel. This is equivalent to -fno-hosted.

-fgimple

Enable parsing of function definitions marked with
«__GIMPLE». This is an experimental
feature that allows unit testing of GIMPLE passes.

-fgnu-tm

When the option -fgnu-tm is specified, the compiler generates code
for the Linux variant of Intel’s current Transactional Memory ABI
specification document (Revision 1.1, May 6 2009). This is an experimental
feature whose interface may change in future versions of GCC, as the
official specification changes. Please note that not all architectures are
supported for this feature.

For more information on GCC’s support for transactional
memory,

Note that the transactional memory feature is not supported
with non-call exceptions (-fnon-call-exceptions).

-fgnu89-inline

The option -fgnu89-inline tells GCC to use the traditional GNU
semantics for «inline» functions when in
C99 mode.

Using this option is roughly equivalent to adding the
«gnu_inline» function attribute to all
inline functions.

The option -fno-gnu89-inline explicitly tells GCC to
use the C99 semantics for «inline»
when in C99 or gnu99 mode (i.e., it specifies the default behavior).
This option is not supported in -std=c90 or -std=gnu90
mode.

The preprocessor macros
«__GNUC_GNU_INLINE__» and
«__GNUC_STDC_INLINE__» may be used to
check which semantics are in effect for
«inline» functions.

-fhosted

Assert that compilation targets a hosted environment. This implies
-fbuiltin. A hosted environment is one in which the entire standard
library is available, and in which
«main» has a return type of
«int». Examples are nearly everything
except a kernel. This is equivalent to -fno-freestanding.

-flax-vector-conversions

Allow implicit conversions between vectors with differing numbers of
elements and/or incompatible element types. This option should not be used
for new code.

-fms-extensions

Accept some non-standard constructs used in Microsoft header files.

In C++ code, this allows member names in structures to be
similar to previous types declarations.

typedef int UOW;
struct ABC {
  UOW UOW;
};

Some cases of unnamed fields in structures and unions are only
accepted with this option.

Note that this option is off for all targets except for x86
targets using ms-abi.

-foffload=disable

-foffload=default

-foffload=target-list

Specify for which OpenMP and OpenACC offload targets code should be
generated. The default behavior, equivalent to -foffload=default,
is to generate code for all supported offload targets. The
-foffload=disable form generates code only for the host fallback,
while -foffload=target-list generates code only for the
specified comma-separated list of offload targets.

Offload targets are specified in GCC’s internal target-triplet
format. You can run the compiler with -v to show the list of
configured offload targets under
«OFFLOAD_TARGET_NAMES».

-foffload-options=options

-foffload-options=target-triplet-list=options

With -foffload-options=options, GCC passes the specified
options to the compilers for all enabled offloading targets. You
can specify options that apply only to a specific target or targets by
using the
-foffload-options=target-list=options form.
The target-list is a comma-separated list in the same format as for
the -foffload= option.

Typical command lines are

-foffload-options=-lgfortran -foffload-options=-lm
-foffload-options="-lgfortran -lm" -foffload-options=nvptx-none=-latomic
-foffload-options=amdgcn-amdhsa=-march=gfx906 -foffload-options=-lm

-fopenacc

Enable handling of OpenACC directives «#pragma
acc» in C/C++ and «!$acc» in
Fortran. When -fopenacc is specified, the compiler generates
accelerated code according to the OpenACC Application Programming
Interface v2.6 https://www.openacc.org. This option implies
-pthread, and thus is only supported on targets that have support
for -pthread.

-fopenacc-dim=geom

Specify default compute dimensions for parallel offload regions that do
not explicitly specify. The geom value is a triple of ‘:’-separated
sizes, in order ‘gang’, ‘worker’ and, ‘vector’. A size can be omitted, to
use a target-specific default value.

-fopenmp

Enable handling of OpenMP directives «#pragma
omp» in C/C++,
«[[omp::directive(…)]]» and
«[[omp::sequence(…)]]» in C++ and
«!$omp» in Fortran. When -fopenmp
is specified, the compiler generates parallel code according to the OpenMP
Application Program Interface v4.5 https://www.openmp.org.
This option implies -pthread, and thus is only supported on targets
that have support for -pthread. -fopenmp implies
-fopenmp-simd.

-fopenmp-simd

Enable handling of OpenMP’s «simd»,
«declare simd»,
«declare reduction»,
«assume»,
«ordered»,
«scan»,
«loop» directives and combined or
composite directives with «simd» as
constituent with «#pragma omp» in C/C++,
«[[omp::directive(…)]]» and
«[[omp::sequence(…)]]» in C++ and
«!$omp» in Fortran. Other OpenMP
directives are ignored.

-fopenmp-target-simd-clone

-fopenmp-target-simd-clone=device-type

In addition to generating SIMD clones for functions marked with the
«declare simd» directive, GCC also
generates clones for functions marked with the OpenMP
«declare target» directive that are
suitable for vectorization when this option is in effect. The
device-type may be one of «none»,
«host»,
«nohost», and
«any», which correspond to keywords for
the «device_type» clause of the
«declare target» directive; clones are
generated for the intersection of devices specified.
-fopenmp-target-simd-clone is equivalent to
-fopenmp-target-simd-clone=any and
-fno-openmp-target-simd-clone is equivalent to
-fopenmp-target-simd-clone=none.

At -O2 and higher (but not -Os or -Og)
this optimization defaults to -fopenmp-target-simd-clone=nohost;
otherwise it is disabled by default.

-fpermitted-flt-eval-methods=style

ISO/IEC TS 18661-3 defines new permissible values for
«FLT_EVAL_METHOD» that indicate that
operations and constants with a semantic type that is an interchange or
extended format should be evaluated to the precision and range of that
type. These new values are a superset of those permitted under C99/C11,
which does not specify the meaning of other positive values of
«FLT_EVAL_METHOD». As such, code
conforming to C11 may not have been written expecting the possibility of
the new values.

-fpermitted-flt-eval-methods specifies whether the
compiler should allow only the values of
«FLT_EVAL_METHOD» specified in
C99/C11, or the extended set of values specified in ISO/IEC TS
18661-3.

style is either «c11»
or «ts-18661-3» as appropriate.

The default when in a standards compliant mode
(-std=c11 or similar) is -fpermitted-flt-eval-methods=c11.
The default when in a GNU dialect (-std=gnu11 or similar) is
-fpermitted-flt-eval-methods=ts-18661-3.

-fplan9-extensions

Accept some non-standard constructs used in Plan 9 code.

This enables -fms-extensions, permits passing pointers
to structures with anonymous fields to functions that expect pointers to
elements of the type of the field, and permits referring to anonymous
fields declared using a typedef. This is only supported for C, not
C++.

-fsigned-bitfields

-funsigned-bitfields

-fno-signed-bitfields

-fno-unsigned-bitfields

These options control whether a bit-field is signed or unsigned, when the
declaration does not use either «signed»
or «unsigned». By default, such a
bit-field is signed, because this is consistent: the basic integer types
such as «int» are signed types.

-fsigned-char

Let the type «char» be signed, like
«signed char».

Note that this is equivalent to -fno-unsigned-char,
which is the negative form of -funsigned-char. Likewise, the
option -fno-signed-char is equivalent to
-funsigned-char.

-funsigned-char

Let the type «char» be unsigned, like
«unsigned char».

Each kind of machine has a default for what
«char» should be. It is either like
«unsigned char» by default or like
«signed char» by default.

Ideally, a portable program should always use
«signed char» or
«unsigned char» when it depends on the
signedness of an object. But many programs have been written to use
plain «char» and expect it to be
signed, or expect it to be unsigned, depending on the machines they were
written for. This option, and its inverse, let you make such a program
work with the opposite default.

The type «char» is always a
distinct type from each of «signed
char» or «unsigned char»,
even though its behavior is always just like one of those two.

-fstrict-flex-arrays

Control when to treat the trailing array of a structure as a flexible
array member for the purpose of accessing the elements of such an array.
The positive form is equivalent to -fstrict-flex-arrays=3, which is
the strictest. A trailing array is treated as a flexible array member only
when it is declared as a flexible array member per C99 standard onwards.
The negative form is equivalent to -fstrict-flex-arrays=0, which is
the least strict. All trailing arrays of structures are treated as
flexible array members.

-fstrict-flex-arrays=level

Control when to treat the trailing array of a structure as a flexible
array member for the purpose of accessing the elements of such an array.
The value of level controls the level of strictness.

The possible values of level are the same as for the
«strict_flex_array» attribute.

You can control this behavior for a specific trailing array
field of a structure by using the variable attribute
«strict_flex_array» attribute.

-fsso-struct=endianness

Set the default scalar storage order of structures and unions to the
specified endianness. The accepted values are big-endian,
little-endian and native for the native endianness of the
target (the default). This option is not supported for C++.

Warning: the -fsso-struct switch causes GCC to
generate code that is not binary compatible with code generated without
it if the specified endianness is not the native endianness of the
target.

Options Controlling C++ Dialect

This section describes the command-line options that are only
meaningful for C++ programs. You can also use most of the GNU compiler
options regardless of what language your program is in. For example, you
might compile a file firstClass.C like this:

g++ -g -fstrict-enums -O -c firstClass.C

In this example, only -fstrict-enums is an option meant
only for C++ programs; you can use the other options with any language
supported by GCC.

Some options for compiling C programs, such as -std, are
also relevant for C++ programs.

Here is a list of options that are only for compiling C++
programs:

-fabi-version=n

Use version n of the C++ ABI. The default is version 0.

Version 0 refers to the version conforming most closely to the
C++ ABI specification. Therefore, the ABI obtained using version 0 will
change in different versions of G++ as ABI bugs are fixed.

Version 1 is the version of the C++ ABI that first appeared in
G++ 3.2.

Version 2 is the version of the C++ ABI that first appeared in
G++ 3.4, and was the default through G++ 4.9.

Version 3 corrects an error in mangling a constant address as
a template argument.

Version 4, which first appeared in G++ 4.5, implements a
standard mangling for vector types.

Version 5, which first appeared in G++ 4.6, corrects the
mangling of attribute const/volatile on function pointer types, decltype
of a plain decl, and use of a function parameter in the declaration of
another parameter.

Version 6, which first appeared in G++ 4.7, corrects the
promotion behavior of C++11 scoped enums and the mangling of template
argument packs, const/static_cast, prefix ++ and —, and a class scope
function used as a template argument.

Version 7, which first appeared in G++ 4.8, that treats
nullptr_t as a builtin type and corrects the mangling of lambdas in
default argument scope.

Version 8, which first appeared in G++ 4.9, corrects the
substitution behavior of function types with function-cv-qualifiers.

Version 9, which first appeared in G++ 5.2, corrects the
alignment of «nullptr_t».

Version 10, which first appeared in G++ 6.1, adds mangling of
attributes that affect type identity, such as ia32 calling convention
attributes (e.g. stdcall).

Version 11, which first appeared in G++ 7, corrects the
mangling of sizeof… expressions and operator names. For multiple
entities with the same name within a function, that are declared in
different scopes, the mangling now changes starting with the twelfth
occurrence. It also implies -fnew-inheriting-ctors.

Version 12, which first appeared in G++ 8, corrects the
calling conventions for empty classes on the x86_64 target and for
classes with only deleted copy/move constructors. It accidentally
changes the calling convention for classes with a deleted copy
constructor and a trivial move constructor.

Version 13, which first appeared in G++ 8.2, fixes the
accidental change in version 12.

Version 14, which first appeared in G++ 10, corrects the
mangling of the nullptr expression.

Version 15, which first appeared in G++ 10.3, corrects G++ 10
ABI tag regression.

Version 16, which first appeared in G++ 11, changes the
mangling of «__alignof__» to be
distinct from that of «alignof», and
dependent operator names.

Version 17, which first appeared in G++ 12, fixes layout of
classes that inherit from aggregate classes with default member
initializers in C++14 and up.

Version 18, which first appeard in G++ 13, fixes manglings of
lambdas that have additional context.

See also -Wabi.

-fabi-compat-version=n

On targets that support strong aliases, G++ works around mangling changes
by creating an alias with the correct mangled name when defining a symbol
with an incorrect mangled name. This switch specifies which ABI version to
use for the alias.

With -fabi-version=0 (the default), this defaults to 13
(GCC 8.2 compatibility). If another ABI version is explicitly selected,
this defaults to 0. For compatibility with GCC versions 3.2 through 4.9,
use -fabi-compat-version=2.

If this option is not provided but -Wabi=n is,
that version is used for compatibility aliases. If this option is
provided along with -Wabi (without the version), the version from
this option is used for the warning.

-fno-access-control

Turn off all access checking. This switch is mainly useful for working
around bugs in the access control code.

-faligned-new

Enable support for C++17 «new» of types
that require more alignment than «void* ::operator
new(std::size_t)» provides. A numeric argument such as
«-faligned-new=32» can be used to
specify how much alignment (in bytes) is provided by that function, but
few users will need to override the default of
alignof(std::max_align_t).

This flag is enabled by default for -std=c++17.

-fchar8_t

-fno-char8_t

Enable support for «char8_t» as adopted
for C++20. This includes the addition of a new
«char8_t» fundamental type, changes to
the types of UTF-8 string and character literals, new signatures for
user-defined literals, associated standard library updates, and new
«__cpp_char8_t» and
«__cpp_lib_char8_t» feature test macros.

This option enables functions to be overloaded for ordinary
and UTF-8 strings:

int f(const char *);    // #1
int f(const char8_t *); // #2
int v1 = f("text");     // Calls #1
int v2 = f(u8"text");   // Calls #2

and introduces new signatures for user-defined literals:

int operator""_udl1(char8_t);
int v3 = u8'x'_udl1;
int operator""_udl2(const char8_t*, std::size_t);
int v4 = u8"text"_udl2;
template<typename T, T...> int operator""_udl3();
int v5 = u8"text"_udl3;

The change to the types of UTF-8 string and character literals
introduces incompatibilities with ISO C++11 and later standards. For
example, the following code is well-formed under ISO C++11, but is
ill-formed when -fchar8_t is specified.

const char *cp = u8"xx";// error: invalid conversion from
                        //        `const char8_t*' to `const char*'
int f(const char*);
auto v = f(u8"xx");     // error: invalid conversion from
                        //        `const char8_t*' to `const char*'
std::string s{u8"xx"};  // error: no matching function for call to
                        //        `std::basic_string<char>::basic_string()'
using namespace std::literals;
s = u8"xx"s;            // error: conversion from
                        //        `basic_string<char8_t>' to non-scalar
                        //        type `basic_string<char>' requested

-fcheck-new

Check that the pointer returned by «operator
new» is non-null before attempting to modify the storage
allocated. This check is normally unnecessary because the C++ standard
specifies that «operator new» only
returns 0 if it is declared
throw(), in which case the compiler always checks
the return value even without this option. In all other cases, when
«operator new» has a non-empty exception
specification, memory exhaustion is signalled by throwing
«std::bad_alloc». See also new
(nothrow).

-fconcepts

-fconcepts-ts

Enable support for the C++ Concepts feature for constraining template
arguments. With -std=c++20 and above, Concepts are part of the
language standard, so -fconcepts defaults to on.

Some constructs that were allowed by the earlier C++
Extensions for Concepts Technical Specification, ISO 19217 (2015), but
didn’t make it into the standard, can additionally be enabled by
-fconcepts-ts.

-fconstexpr-depth=n

Set the maximum nested evaluation depth for C++11 constexpr functions to
n. A limit is needed to detect endless recursion during constant
expression evaluation. The minimum specified by the standard is 512.

-fconstexpr-cache-depth=n

Set the maximum level of nested evaluation depth for C++11 constexpr
functions that will be cached to n. This is a heuristic that trades
off compilation speed (when the cache avoids repeated calculations)
against memory consumption (when the cache grows very large from highly
recursive evaluations). The default is 8. Very few users are likely to
want to adjust it, but if your code does heavy constexpr calculations you
might want to experiment to find which value works best for you.

-fconstexpr-fp-except

Annex F of the C standard specifies that IEC559 floating point exceptions
encountered at compile time should not stop compilation. C++ compilers
have historically not followed this guidance, instead treating floating
point division by zero as non-constant even though it has a well defined
value. This flag tells the compiler to give Annex F priority over other
rules saying that a particular operation is undefined.

constexpr float inf = 1./0.; // OK with -fconstexpr-fp-except

-fconstexpr-loop-limit=n

Set the maximum number of iterations for a loop in C++14 constexpr
functions to n. A limit is needed to detect infinite loops during
constant expression evaluation. The default is 262144 (1<<18).

-fconstexpr-ops-limit=n

Set the maximum number of operations during a single constexpr evaluation.
Even when number of iterations of a single loop is limited with the above
limit, if there are several nested loops and each of them has many
iterations but still smaller than the above limit, or if in a body of some
loop or even outside of a loop too many expressions need to be evaluated,
the resulting constexpr evaluation might take too long. The default is
33554432 (1<<25).

-fcontracts

Enable experimental support for the C++ Contracts feature, as briefly
added to and then removed from the C++20 working paper (N4820). The
implementation also includes proposed enhancements from papers P1290,
P1332, and P1429. This functionality is intended mostly for those
interested in experimentation towards refining the feature to get it into
shape for a future C++ standard.

On violation of a checked contract, the violation handler is
called. Users can replace the violation handler by defining

void
handle_contract_violation (const std::experimental::contract_violation&);

There are different sets of additional flags that can be used
together to specify which contracts will be checked and how, for N4820
contracts, P1332 contracts, or P1429 contracts; these sets cannot be
used together.

-fcoroutines

Enable support for the C++ coroutines extension (experimental).

-fno-elide-constructors

The C++ standard allows an implementation to omit creating a temporary
that is only used to initialize another object of the same type.
Specifying this option disables that optimization, and forces G++ to call
the copy constructor in all cases. This option also causes G++ to call
trivial member functions which otherwise would be expanded inline.

In C++17, the compiler is required to omit these temporaries,
but this option still affects trivial member functions.

-fno-enforce-eh-specs

Don’t generate code to check for violation of exception specifications at
run time. This option violates the C++ standard, but may be useful for
reducing code size in production builds, much like defining
«NDEBUG». This does not give user code
permission to throw exceptions in violation of the exception
specifications; the compiler still optimizes based on the specifications,
so throwing an unexpected exception results in undefined behavior at run
time.

-fextern-tls-init

-fno-extern-tls-init

The C++11 and OpenMP standards allow
«thread_local» and
«threadprivate» variables to have
dynamic (runtime) initialization. To support this, any use of such a
variable goes through a wrapper function that performs any necessary
initialization. When the use and definition of the variable are in the
same translation unit, this overhead can be optimized away, but when the
use is in a different translation unit there is significant overhead even
if the variable doesn’t actually need dynamic initialization. If the
programmer can be sure that no use of the variable in a non-defining TU
needs to trigger dynamic initialization (either because the variable is
statically initialized, or a use of the variable in the defining TU will
be executed before any uses in another TU), they can avoid this overhead
with the -fno-extern-tls-init option.

On targets that support symbol aliases, the default is
-fextern-tls-init. On targets that do not support symbol aliases,
the default is -fno-extern-tls-init.

-ffold-simple-inlines

-fno-fold-simple-inlines

Permit the C++ frontend to fold calls to
«std::move»,
«std::forward»,
«std::addressof» and
«std::as_const». In contrast to
inlining, this means no debug information will be generated for such
calls. Since these functions are rarely interesting to debug, this flag is
enabled by default unless -fno-inline is active.

-fno-gnu-keywords

Do not recognize «typeof» as a keyword,
so that code can use this word as an identifier. You can use the keyword
«__typeof__» instead. This option is
implied by the strict ISO C++ dialects: -ansi, -std=c++98,
-std=c++11, etc.

-fimplicit-constexpr

Make inline functions implicitly constexpr, if they satisfy the
requirements for a constexpr function. This option can be used in C++14
mode or later. This can result in initialization changing from dynamic to
static and other optimizations.

-fno-implicit-templates

Never emit code for non-inline templates that are instantiated implicitly
(i.e. by use); only emit code for explicit instantiations. If you use this
option, you must take care to structure your code to include all the
necessary explicit instantiations to avoid getting undefined symbols at
link time.

-fno-implicit-inline-templates

Don’t emit code for implicit instantiations of inline templates, either.
The default is to handle inlines differently so that compiles with and
without optimization need the same set of explicit instantiations.

-fno-implement-inlines

To save space, do not emit out-of-line copies of inline functions
controlled by «#pragma implementation».
This causes linker errors if these functions are not inlined everywhere
they are called.

-fmodules-ts

-fno-modules-ts

Enable support for C++20 modules. The -fno-modules-ts is usually
not needed, as that is the default. Even though this is a C++20 feature,
it is not currently implicitly enabled by selecting that standard
version.

-fmodule-header

-fmodule-header=user

-fmodule-header=system

Compile a header file to create an importable header unit.

-fmodule-implicit-inline

Member functions defined in their class definitions are not implicitly
inline for modular code. This is different to traditional C++ behavior,
for good reasons. However, it may result in a difficulty during code
porting. This option makes such function definitions implicitly inline. It
does however generate an ABI incompatibility, so you must use it
everywhere or nowhere. (Such definitions outside of a named module remain
implicitly inline, regardless.)

-fno-module-lazy

Disable lazy module importing and module mapper creation.

-fmodule-mapper=[hostname]:port[?ident]

-fmodule-mapper=|program[?ident]args…

-fmodule-mapper==socket[?ident]

-fmodule-mapper=<>[inout][?ident]

-fmodule-mapper=<in>out[?ident]

-fmodule-mapper=file[?ident]

An oracle to query for module name to filename mappings. If unspecified
the CXX_MODULE_MAPPER environment variable is used, and if that is
unset, an in-process default is provided.

-fmodule-only

Only emit the Compiled Module Interface, inhibiting any object file.

-fms-extensions

Disable Wpedantic warnings about constructs used in MFC, such as implicit
int and getting a pointer to member function via non-standard syntax.

-fnew-inheriting-ctors

Enable the P0136 adjustment to the semantics of C++11 constructor
inheritance. This is part of C++17 but also considered to be a Defect
Report against C++11 and C++14. This flag is enabled by default unless
-fabi-version=10 or lower is specified.

-fnew-ttp-matching

Enable the P0522 resolution to Core issue 150, template template
parameters and default arguments: this allows a template with default
template arguments as an argument for a template template parameter with
fewer template parameters. This flag is enabled by default for
-std=c++17.

-fno-nonansi-builtins

Disable built-in declarations of functions that are not mandated by
ANSI/ISO C. These include «ffs»,
«alloca»,
«_exit»,
«index»,
«bzero»,
«conjf», and other related
functions.

-fnothrow-opt

Treat a throw() exception specification as if it
were a «noexcept» specification to
reduce or eliminate the text size overhead relative to a function with no
exception specification. If the function has local variables of types with
non-trivial destructors, the exception specification actually makes the
function smaller because the EH cleanups for those variables can be
optimized away. The semantic effect is that an exception thrown out of a
function with such an exception specification results in a call to
«terminate» rather than
«unexpected».

-fno-operator-names

Do not treat the operator name keywords
«and»,
«bitand»,
«bitor»,
«compl»,
«not»,
«or» and
«xor» as synonyms as keywords.

-fno-optional-diags

Disable diagnostics that the standard says a compiler does not need to
issue. Currently, the only such diagnostic issued by G++ is the one for a
name having multiple meanings within a class.

-fpermissive

Downgrade some diagnostics about nonconformant code from errors to
warnings. Thus, using -fpermissive allows some nonconforming code
to compile.

-fno-pretty-templates

When an error message refers to a specialization of a function template,
the compiler normally prints the signature of the template followed by the
template arguments and any typedefs or typenames in the signature (e.g.
«void f(T) [with T = int]» rather than
«void f(int)») so that it’s clear which
template is involved. When an error message refers to a specialization of
a class template, the compiler omits any template arguments that match the
default template arguments for that template. If either of these behaviors
make it harder to understand the error message rather than easier, you can
use -fno-pretty-templates to disable them.

-fno-rtti

Disable generation of information about every class with virtual functions
for use by the C++ run-time type identification features
(«dynamic_cast» and
«typeid»). If you don’t use those parts
of the language, you can save some space by using this flag. Note that
exception handling uses the same information, but G++ generates it as
needed. The «dynamic_cast» operator can
still be used for casts that do not require run-time type information,
i.e. casts to «void *» or to unambiguous
base classes.

Mixing code compiled with -frtti with that compiled
with -fno-rtti may not work. For example, programs may fail to
link if a class compiled with -fno-rtti is used as a base for a
class compiled with -frtti.

-fsized-deallocation

Enable the built-in global declarations

void operator delete (void *, std::size_t) noexcept;
void operator delete[] (void *, std::size_t) noexcept;

as introduced in C++14. This is useful for user-defined
replacement deallocation functions that, for example, use the size of
the object to make deallocation faster. Enabled by default under
-std=c++14 and above. The flag -Wsized-deallocation warns
about places that might want to add a definition.

-fstrict-enums

Allow the compiler to optimize using the assumption that a value of
enumerated type can only be one of the values of the enumeration (as
defined in the C++ standard; basically, a value that can be represented in
the minimum number of bits needed to represent all the enumerators). This
assumption may not be valid if the program uses a cast to convert an
arbitrary integer value to the enumerated type.

-fstrong-eval-order

Evaluate member access, array subscripting, and shift expressions in
left-to-right order, and evaluate assignment in right-to-left order, as
adopted for C++17. Enabled by default with -std=c++17.
-fstrong-eval-order=some enables just the ordering of member access
and shift expressions, and is the default without -std=c++17.

-ftemplate-backtrace-limit=n

Set the maximum number of template instantiation notes for a single
warning or error to n. The default value is 10.

-ftemplate-depth=n

Set the maximum instantiation depth for template classes to n. A
limit on the template instantiation depth is needed to detect endless
recursions during template class instantiation. ANSI/ISO C++ conforming
programs must not rely on a maximum depth greater than 17 (changed to 1024
in C++11). The default value is 900, as the compiler can run out of stack
space before hitting 1024 in some situations.

-fno-threadsafe-statics

Do not emit the extra code to use the routines specified in the C++ ABI
for thread-safe initialization of local statics. You can use this option
to reduce code size slightly in code that doesn’t need to be
thread-safe.

-fuse-cxa-atexit

Register destructors for objects with static storage duration with the
«__cxa_atexit» function rather than the
«atexit» function. This option is
required for fully standards-compliant handling of static destructors, but
only works if your C library supports
«__cxa_atexit».

-fno-use-cxa-get-exception-ptr

Don’t use the «__cxa_get_exception_ptr»
runtime routine. This causes
«std::uncaught_exception» to be
incorrect, but is necessary if the runtime routine is not available.

-fvisibility-inlines-hidden

This switch declares that the user does not attempt to compare pointers to
inline functions or methods where the addresses of the two functions are
taken in different shared objects.

The effect of this is that GCC may, effectively, mark inline
methods with «__attribute__ ((visibility
(«hidden»)))» so that they do not appear in the
export table of a DSO and do not require a PLT indirection when used
within the DSO. Enabling this option can have a dramatic effect on load
and link times of a DSO as it massively reduces the size of the dynamic
export table when the library makes heavy use of templates.

The behavior of this switch is not quite the same as marking
the methods as hidden directly, because it does not affect static
variables local to the function or cause the compiler to deduce that the
function is defined in only one shared object.

You may mark a method as having a visibility explicitly to
negate the effect of the switch for that method. For example, if you do
want to compare pointers to a particular inline method, you might mark
it as having default visibility. Marking the enclosing class with
explicit visibility has no effect.

Explicitly instantiated inline methods are unaffected by this
option as their linkage might otherwise cross a shared library
boundary.

-fvisibility-ms-compat

This flag attempts to use visibility settings to make GCC’s C++ linkage
model compatible with that of Microsoft Visual Studio.

The flag makes these changes to GCC’s linkage model:

-fno-weak

Do not use weak symbol support, even if it is provided by the linker. By
default, G++ uses weak symbols if they are available. This option exists
only for testing, and should not be used by end-users; it results in
inferior code and has no benefits. This option may be removed in a future
release of G++.

-fext-numeric-literals
(C++ and Objective-C++ only)

Accept imaginary, fixed-point, or machine-defined literal number suffixes
as GNU extensions. When this option is turned off these suffixes are
treated as C++11 user-defined literal numeric suffixes. This is on by
default for all pre-C++11 dialects and all GNU dialects:
-std=c++98, -std=gnu++98, -std=gnu++11,
-std=gnu++14. This option is off by default for ISO C++11 onwards
(-std=c++11, …).

-nostdinc++

Do not search for header files in the standard directories specific to
C++, but do still search the other standard directories. (This option is
used when building the C++ library.)

-flang-info-include-translate

-flang-info-include-translate-not

-flang-info-include-translate=header

Inform of include translation events. The first will note accepted include
translations, the second will note declined include translations. The
header form will inform of include translations relating to that
specific header. If header is of the form
«user» or
«<system>» it will be resolved to
a specific user or system header using the include path.

-flang-info-module-cmi

-flang-info-module-cmi=module

Inform of Compiled Module Interface pathnames. The first will note all
read CMI pathnames. The module form will not reading a specific
module’s CMI. module may be a named module or a header-unit (the
latter indicated by either being a pathname containing directory
separators or enclosed in «<>» or
«»).

-stdlib=libstdc++,libc++

When G++ is configured to support this option, it allows specification of
alternate C++ runtime libraries. Two options are available:
libstdc++ (the default, native C++ runtime for G++) and
libc++ which is the C++ runtime installed on some operating systems
(e.g. Darwin versions from Darwin11 onwards). The option switches G++ to
use the headers from the specified library and to emit
«-lstdc++» or
«-lc++» respectively, when a C++ runtime
is required for linking.

In addition, these warning options have meanings only for C++
programs:

-Wabi-tag (C++ and
Objective-C++ only)

Warn when a type with an ABI tag is used in a context that does not have
that ABI tag. See C++ Attributes for more information about ABI
tags.

-Wcomma-subscript
(C++ and Objective-C++ only)

Warn about uses of a comma expression within a subscripting expression.
This usage was deprecated in C++20 and is going to be removed in C++23.
However, a comma expression wrapped in «(
)» is not deprecated. Example:

void f(int *a, int b, int c) {
    a[b,c];     // deprecated in C++20, invalid in C++23
    a[(b,c)];   // OK
}

In C++23 it is valid to have comma separated expressions in a
subscript when an overloaded subscript operator is found and supports
the right number and types of arguments. G++ will accept the formerly
valid syntax for code that is not valid in C++23 but used to be valid
but deprecated in C++20 with a pedantic warning that can be disabled
with -Wno-comma-subscript.

Enabled by default with -std=c++20 unless
-Wno-deprecated, and with -std=c++23 regardless of
-Wno-deprecated.

-Wctad-maybe-unsupported
(C++ and Objective-C++ only)

Warn when performing class template argument deduction (CTAD) on a type
with no explicitly written deduction guides. This warning will point out
cases where CTAD succeeded only because the compiler synthesized the
implicit deduction guides, which might not be what the programmer
intended. Certain style guides allow CTAD only on types that specifically
«opt-in»; i.e., on types that are designed to support CTAD. This
warning can be suppressed with the following pattern:

struct allow_ctad_t; // any name works
template <typename T> struct S {
  S(T) { }
};
// Guide with incomplete parameter type will never be considered.
S(allow_ctad_t) -> S<void>;

-Wctor-dtor-privacy
(C++ and Objective-C++ only)

Warn when a class seems unusable because all the constructors or
destructors in that class are private, and it has neither friends nor
public static member functions. Also warn if there are no non-private
methods, and there’s at least one private member function that isn’t a
constructor or destructor.

-Wdangling-reference
(C++ and Objective-C++ only)

Warn when a reference is bound to a temporary whose lifetime has ended.
For example:

int n = 1;
const int& r = std::max(n - 1, n + 1); // r is dangling

In the example above, two temporaries are created, one for
each argument, and a reference to one of the temporaries is returned.
However, both temporaries are destroyed at the end of the full
expression, so the reference «r» is
dangling. This warning also detects dangling references in member
initializer lists:

const int& f(const int& i) { return i; }
struct S {
  const int &r; // r is dangling
  S() : r(f(10)) { }
};

Member functions are checked as well, but only their object
argument:

struct S {
   const S& self () { return *this; }
};
const S& s = S().self(); // s is dangling

Certain functions are safe in this respect, for example
«std::use_facet»: they take and return
a reference, but they don’t return one of its arguments, which can fool
the warning. Such functions can be excluded from the warning by wrapping
them in a «#pragma»:

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdangling-reference"
const T& foo (const T&) { ... }
#pragma GCC diagnostic pop

-Wdangling-reference also warns about code like

auto p = std::minmax(1, 2);

where «std::minmax» returns
«std::pair<const int&, const
int&>», and both references dangle after the end of
the full expression that contains the call to
«std::minmax».

This warning is enabled by -Wextra.

-Wdelete-non-virtual-dtor
(C++ and Objective-C++ only)

Warn when «delete» is used to destroy an
instance of a class that has virtual functions and non-virtual destructor.
It is unsafe to delete an instance of a derived class through a pointer to
a base class if the base class does not have a virtual destructor. This
warning is enabled by -Wall.

-Wdeprecated-copy
(C++ and Objective-C++ only)

Warn that the implicit declaration of a copy constructor or copy
assignment operator is deprecated if the class has a user-provided copy
constructor or copy assignment operator, in C++11 and up. This warning is
enabled by -Wextra. With -Wdeprecated-copy-dtor, also
deprecate if the class has a user-provided destructor.

-Wno-deprecated-enum-enum-conversion
(C++ and Objective-C++ only)

Disable the warning about the case when the usual arithmetic conversions
are applied on operands where one is of enumeration type and the other is
of a different enumeration type. This conversion was deprecated in C++20.
For example:

enum E1 { e };
enum E2 { f };
int k = f - e;

-Wdeprecated-enum-enum-conversion is enabled by default
with -std=c++20. In pre-C++20 dialects, this warning can be
enabled by -Wenum-conversion.

-Wno-deprecated-enum-float-conversion
(C++ and Objective-C++ only)

Disable the warning about the case when the usual arithmetic conversions
are applied on operands where one is of enumeration type and the other is
of a floating-point type. This conversion was deprecated in C++20. For
example:

enum E1 { e };
enum E2 { f };
bool b = e <= 3.7;

-Wdeprecated-enum-float-conversion is enabled by
default with -std=c++20. In pre-C++20 dialects, this warning can
be enabled by -Wenum-conversion.

-Wno-init-list-lifetime
(C++ and Objective-C++ only)

Do not warn about uses of
«std::initializer_list» that are likely
to result in dangling pointers. Since the underlying array for an
«initializer_list» is handled like a
normal C++ temporary object, it is easy to inadvertently keep a pointer to
the array past the end of the array’s lifetime. For example:

-Winvalid-constexpr

Warn when a function never produces a constant expression. In C++20 and
earlier, for every «constexpr» function
and function template, there must be at least one set of function
arguments in at least one instantiation such that an invocation of the
function or constructor could be an evaluated subexpression of a core
constant expression. C++23 removed this restriction, so it’s possible to
have a function or a function template marked
«constexpr» for which no invocation
satisfies the requirements of a core constant expression.

This warning is enabled as a pedantic warning by default in
C++20 and earlier. In C++23, -Winvalid-constexpr can be turned
on, in which case it will be an ordinary warning. For example:

void f (int& i);
constexpr void
g (int& i)
{
  // Warns by default in C++20, in C++23 only with -Winvalid-constexpr.
  f(i);
}

-Winvalid-imported-macros

Verify all imported macro definitions are valid at the end of compilation.
This is not enabled by default, as it requires additional processing to
determine. It may be useful when preparing sets of header-units to ensure
consistent macros.

-Wno-literal-suffix
(C++ and Objective-C++ only)

Do not warn when a string or character literal is followed by a ud-suffix
which does not begin with an underscore. As a conforming extension, GCC
treats such suffixes as separate preprocessing tokens in order to maintain
backwards compatibility with code that uses formatting macros from
«<inttypes.h>». For example:

#define __STDC_FORMAT_MACROS
#include <inttypes.h>
#include <stdio.h>

int main() {
  int64_t i64 = 123;
  printf("My int64: %" PRId64"\n", i64);
}

In this case, «PRId64» is
treated as a separate preprocessing token.

This option also controls warnings when a user-defined literal
operator is declared with a literal suffix identifier that doesn’t begin
with an underscore. Literal suffix identifiers that don’t begin with an
underscore are reserved for future standardization.

These warnings are enabled by default.

-Wno-narrowing (C++
and Objective-C++ only)

For C++11 and later standards, narrowing conversions are diagnosed by
default, as required by the standard. A narrowing conversion from a
constant produces an error, and a narrowing conversion from a non-constant
produces a warning, but -Wno-narrowing suppresses the diagnostic.
Note that this does not affect the meaning of well-formed code; narrowing
conversions are still considered ill-formed in SFINAE contexts.

With -Wnarrowing in C++98, warn when a narrowing
conversion prohibited by C++11 occurs within { }, e.g.

int i = { 2.2 }; // error: narrowing from double to int

This flag is included in -Wall and
-Wc++11-compat.

-Wnoexcept
(C++ and Objective-C++ only)

Warn when a noexcept-expression evaluates to false because of a call to a
function that does not have a non-throwing exception specification (i.e.
throw() or
«noexcept») but is known by the compiler
to never throw an exception.

-Wnoexcept-type
(C++ and Objective-C++ only)

Warn if the C++17 feature making
«noexcept» part of a function type
changes the mangled name of a symbol relative to C++14. Enabled by
-Wabi and -Wc++17-compat.

As an example:

template <class T> void f(T t) { t(); };
void g() noexcept;
void h() { f(g); }

In C++14, «f» calls
«f<void(*)()>», but in C++17 it
calls
«f<void(*)()noexcept>».

-Wclass-memaccess
(C++ and Objective-C++ only)

Warn when the destination of a call to a raw memory function such as
«memset» or
«memcpy» is an object of class type, and
when writing into such an object might bypass the class non-trivial or
deleted constructor or copy assignment, violate const-correctness or
encapsulation, or corrupt virtual table pointers. Modifying the
representation of such objects may violate invariants maintained by member
functions of the class. For example, the call to
«memset» below is undefined because it
modifies a non-trivial class object and is, therefore, diagnosed. The safe
way to either initialize or clear the storage of objects of such types is
by using the appropriate constructor or assignment operator, if one is
available.

std::string str = "abc";
memset (&str, 0, sizeof str);

The -Wclass-memaccess option is enabled by
-Wall. Explicitly casting the pointer to the class object to
«void *» or to a type that can be
safely accessed by the raw memory function suppresses the warning.

-Wnon-virtual-dtor (C++
and Objective-C++ only)

Warn when a class has virtual functions and an accessible non-virtual
destructor itself or in an accessible polymorphic base class, in which
case it is possible but unsafe to delete an instance of a derived class
through a pointer to the class itself or base class. This warning is
automatically enabled if -Weffc++ is specified. The
-Wdelete-non-virtual-dtor option (enabled by -Wall) should
be preferred because it warns about the unsafe cases without false
positives.

-Wregister
(C++ and Objective-C++ only)

Warn on uses of the «register» storage
class specifier, except when it is part of the GNU Explicit Register
Variables extension. The use of the
«register» keyword as storage class
specifier has been deprecated in C++11 and removed in C++17. Enabled by
default with -std=c++17.

-Wreorder (C++
and Objective-C++ only)

Warn when the order of member initializers given in the code does not
match the order in which they must be executed. For instance:

struct A {
  int i;
  int j;
  A(): j (0), i (1) { }
};

The compiler rearranges the member initializers for
«i» and
«j» to match the declaration order of
the members, emitting a warning to that effect. This warning is enabled
by -Wall.

-Wno-pessimizing-move
(C++ and Objective-C++ only)

This warning warns when a call to
«std::move» prevents copy elision. A
typical scenario when copy elision can occur is when returning in a
function with a class return type, when the expression being returned is
the name of a non-volatile automatic object, and is not a function
parameter, and has the same type as the function return type.

struct T {
...
};
T fn()
{
  T t;
  ...
  return std::move (t);
}

But in this example, the
«std::move» call prevents copy
elision.

This warning is enabled by -Wall.

-Wno-redundant-move
(C++ and Objective-C++ only)

This warning warns about redundant calls to
«std::move»; that is, when a move
operation would have been performed even without the
«std::move» call. This happens because
the compiler is forced to treat the object as if it were an rvalue in
certain situations such as returning a local variable, where copy elision
isn’t applicable. Consider:

struct T {
...
};
T fn(T t)
{
  ...
  return std::move (t);
}

Here, the «std::move» call
is redundant. Because G++ implements Core Issue 1579, another example
is:

struct T { // convertible to U
...
};
struct U {
...
};
U fn()
{
  T t;
  ...
  return std::move (t);
}

In this example, copy elision isn’t applicable because the
type of the expression being returned and the function return type
differ, yet G++ treats the return value as if it were designated by an
rvalue.

This warning is enabled by -Wextra.

-Wrange-loop-construct
(C++ and Objective-C++ only)

This warning warns when a C++ range-based for-loop is creating an
unnecessary copy. This can happen when the range declaration is not a
reference, but probably should be. For example:

struct S { char arr[128]; };
void fn () {
  S arr[5];
  for (const auto x : arr) { ... }
}

It does not warn when the type being copied is a
trivially-copyable type whose size is less than 64 bytes.

This warning also warns when a loop variable in a range-based
for-loop is initialized with a value of a different type resulting in a
copy. For example:

void fn() {
  int arr[10];
  for (const double &x : arr) { ... }
}

In the example above, in every iteration of the loop a
temporary value of type «double» is
created and destroyed, to which the reference
«const double &» is bound.

This warning is enabled by -Wall.

-Wredundant-tags
(C++ and Objective-C++ only)

Warn about redundant class-key and enum-key in references to class types
and enumerated types in contexts where the key can be eliminated without
causing an ambiguity. For example:

struct foo;
struct foo *p;   // warn that keyword struct can be eliminated

On the other hand, in this example there is no warning:

struct foo;
void foo ();   // "hides" struct foo
void bar (struct foo&);  // no warning, keyword struct is necessary

-Wno-subobject-linkage
(C++ and Objective-C++ only)

Do not warn if a class type has a base or a field whose type uses the
anonymous namespace or depends on a type with no linkage. If a type A
depends on a type B with no or internal linkage, defining it in multiple
translation units would be an ODR violation because the meaning of B is
different in each translation unit. If A only appears in a single
translation unit, the best way to silence the warning is to give it
internal linkage by putting it in an anonymous namespace as well. The
compiler doesn’t give this warning for types defined in the main .C file,
as those are unlikely to have multiple definitions.
-Wsubobject-linkage is enabled by default.

-Weffc++ (C++ and
Objective-C++ only)

Warn about violations of the following style guidelines from Scott Meyers’
Effective C++ series of books:

-Wno-exceptions (C++
and Objective-C++ only)

Disable the warning about the case when an exception handler is shadowed
by another handler, which can point out a wrong ordering of exception
handlers.

-Wstrict-null-sentinel
(C++ and Objective-C++ only)

Warn about the use of an uncasted «NULL»
as sentinel. When compiling only with GCC this is a valid sentinel, as
«NULL» is defined to
«__null». Although it is a null pointer
constant rather than a null pointer, it is guaranteed to be of the same
size as a pointer. But this use is not portable across different
compilers.

-Wno-non-template-friend
(C++ and Objective-C++ only)

Disable warnings when non-template friend functions are declared within a
template. In very old versions of GCC that predate implementation of the
ISO standard, declarations such as friend int foo(int), where the
name of the friend is an unqualified-id, could be interpreted as a
particular specialization of a template function; the warning exists to
diagnose compatibility problems, and is enabled by default.

-Wold-style-cast (C++
and Objective-C++ only)

Warn if an old-style (C-style) cast to a non-void type is used within a
C++ program. The new-style casts
(«dynamic_cast»,
«static_cast»,
«reinterpret_cast», and
«const_cast») are less vulnerable to
unintended effects and much easier to search for.

-Woverloaded-virtual
(C++ and Objective-C++ only)

-Woverloaded-virtual=n

Warn when a function declaration hides virtual functions from a base
class. For example, in:

struct A {
  virtual void f();
};

struct B: public A {
  void f(int); // does not override
};

the «A» class version of
«f» is hidden in
«B», and code like:

B* b;
b->f();

fails to compile.

In cases where the different signatures are not an accident,
the simplest solution is to add a using-declaration to the derived class
to un-hide the base function, e.g. add «using
A::f;» to «B».

The optional level suffix controls the behavior when all the
declarations in the derived class override virtual functions in the base
class, even if not all of the base functions are overridden:

struct C {
  virtual void f();
  virtual void f(int);
};

struct D: public C {
  void f(int); // does override
}

This pattern is less likely to be a mistake; if D is only used
virtually, the user might have decided that the base class semantics for
some of the overloads are fine.

At level 1, this case does not warn; at level 2, it does.
-Woverloaded-virtual by itself selects level 2. Level 1 is
included in -Wall.

-Wno-pmf-conversions
(C++ and Objective-C++ only)

Disable the diagnostic for converting a bound pointer to member function
to a plain pointer.

-Wsign-promo (C++ and
Objective-C++ only)

Warn when overload resolution chooses a promotion from unsigned or
enumerated type to a signed type, over a conversion to an unsigned type of
the same size. Previous versions of G++ tried to preserve unsignedness,
but the standard mandates the current behavior.

-Wtemplates
(C++ and Objective-C++ only)

Warn when a primary template declaration is encountered. Some coding rules
disallow templates, and this may be used to enforce that rule. The warning
is inactive inside a system header file, such as the STL, so one can still
use the STL. One may also instantiate or specialize templates.

-Wmismatched-new-delete
(C++ and Objective-C++ only)

Warn for mismatches between calls to «operator
new» or «operator
delete» and the corresponding call to the
allocation or deallocation function. This includes invocations of C++
«operator delete» with pointers returned
from either mismatched forms of «operator
new», or from other functions that allocate objects for which
the «operator delete» isn’t a suitable
deallocator, as well as calls to other deallocation functions with
pointers returned from «operator new»
for which the deallocation function isn’t suitable.

For example, the «delete»
expression in the function below is diagnosed because it doesn’t match
the array form of the «new» expression
the pointer argument was returned from. Similarly, the call to
«free» is also diagnosed.

void f ()
{
  int *a = new int[n];
  delete a;   // warning: mismatch in array forms of expressions

  char *p = new char[n];
  free (p);   // warning: mismatch between new and free
}

The related option -Wmismatched-dealloc diagnoses
mismatches involving allocation and deallocation functions other than
«operator new»
and «operator delete».

-Wmismatched-new-delete is included in
-Wall.

-Wmismatched-tags
(C++ and Objective-C++ only)

Warn for declarations of structs, classes, and class templates and their
specializations with a class-key that does not match either the definition
or the first declaration if no definition is provided.

For example, the declaration of «struct
Object» in the argument list of
«draw» triggers the warning. To avoid
it, either remove the redundant class-key
«struct» or replace it with
«class» to match its definition.

class Object {
public:
  virtual ~Object () = 0;
};
void draw (struct Object*);

It is not wrong to declare a class with the class-key
«struct» as the example above shows.
The -Wmismatched-tags option is intended to help achieve a
consistent style of class declarations. In code that is intended to be
portable to Windows-based compilers the warning helps prevent unresolved
references due to the difference in the mangling of symbols declared
with different class-keys. The option can be used either on its own or
in conjunction with -Wredundant-tags.

-Wmultiple-inheritance
(C++ and Objective-C++ only)

Warn when a class is defined with multiple direct base classes. Some
coding rules disallow multiple inheritance, and this may be used to
enforce that rule. The warning is inactive inside a system header file,
such as the STL, so one can still use the STL. One may also define classes
that indirectly use multiple inheritance.

-Wvirtual-inheritance

Warn when a class is defined with a virtual direct base class. Some coding
rules disallow multiple inheritance, and this may be used to enforce that
rule. The warning is inactive inside a system header file, such as the
STL, so one can still use the STL. One may also define classes that
indirectly use virtual inheritance.

-Wno-virtual-move-assign

Suppress warnings about inheriting from a virtual base with a non-trivial
C++11 move assignment operator. This is dangerous because if the virtual
base is reachable along more than one path, it is moved multiple times,
which can mean both objects end up in the moved-from state. If the move
assignment operator is written to avoid moving from a moved-from object,
this warning can be disabled.

-Wnamespaces

Warn when a namespace definition is opened. Some coding rules disallow
namespaces, and this may be used to enforce that rule. The warning is
inactive inside a system header file, such as the STL, so one can still
use the STL. One may also use using directives and qualified names.

-Wno-terminate (C++
and Objective-C++ only)

Disable the warning about a throw-expression that will immediately result
in a call to «terminate».

-Wno-vexing-parse
(C++ and Objective-C++ only)

Warn about the most vexing parse syntactic ambiguity. This warns about the
cases when a declaration looks like a variable definition, but the C++
language requires it to be interpreted as a function declaration. For
instance:

void f(double a) {
  int i();        // extern int i (void);
  int n(int(a));  // extern int n (int);
}

Another example:

struct S { S(int); };
void f(double a) {
  S x(int(a));   // extern struct S x (int);
  S y(int());    // extern struct S y (int (*) (void));
  S z();         // extern struct S z (void);
}

The warning will suggest options how to deal with such an
ambiguity; e.g., it can suggest removing the parentheses or using braces
instead.

This warning is enabled by default.

-Wno-class-conversion
(C++ and Objective-C++ only)

Do not warn when a conversion function converts an object to the same
type, to a base class of that type, or to void; such a conversion function
will never be called.

-Wvolatile
(C++ and Objective-C++ only)

Warn about deprecated uses of the
«volatile» qualifier. This includes
postfix and prefix «++» and
«—« expressions of
«volatile»-qualified types, using simple
assignments where the left operand is a
«volatile»-qualified non-class type for
their value, compound assignments where the left operand is a
«volatile»-qualified non-class type,
«volatile»-qualified function return
type, «volatile»-qualified parameter
type, and structured bindings of a
«volatile»-qualified type. This usage
was deprecated in C++20.

Enabled by default with -std=c++20.

-Wzero-as-null-pointer-constant
(C++ and Objective-C++ only)

Warn when a literal 0 is used as null pointer constant. This can be
useful to facilitate the conversion to
«nullptr» in C++11.

-Waligned-new

Warn about a new-expression of a type that requires greater alignment than
the alignof(std::max_align_t) but uses an
allocation function without an explicit alignment parameter. This option
is enabled by -Wall.

Normally this only warns about global allocation functions,
but -Waligned-new=all also warns about class member allocation
functions.

-Wno-placement-new

-Wplacement-new=n

Warn about placement new expressions with undefined behavior, such as
constructing an object in a buffer that is smaller than the type of the
object. For example, the placement new expression below is diagnosed
because it attempts to construct an array of 64 integers in a buffer only
64 bytes large.

char buf [64];
new (buf) int[64];

This warning is enabled by default.

-Wcatch-value

-Wcatch-value=n(C++ and Objective-C++ only)

Warn about catch handlers that do not catch via reference. With
-Wcatch-value=1 (or -Wcatch-value for short) warn about
polymorphic class types that are caught by value. With
-Wcatch-value=2 warn about all class types that are caught by
value. With -Wcatch-value=3 warn about all types that are not
caught by reference. -Wcatch-value is enabled by -Wall.

-Wconditionally-supported
(C++ and Objective-C++ only)

Warn for conditionally-supported (C++11 [intro.defs]) constructs.

-Wno-delete-incomplete
(C++ and Objective-C++ only)

Do not warn when deleting a pointer to incomplete type, which may cause
undefined behavior at runtime. This warning is enabled by default.

Warn about redundant semicolons after in-class function definitions.

-Wno-inaccessible-base
(C++, Objective-C++ only)

This option controls warnings when a base class is inaccessible in a class
derived from it due to ambiguity. The warning is enabled by default. Note
that the warning for ambiguous virtual bases is enabled by the
-Wextra option.

struct A { int a; };

struct B : A { };

struct C : B, A { };

-Wno-inherited-variadic-ctor

Suppress warnings about use of C++11 inheriting constructors when the base
class inherited from has a C variadic constructor; the warning is on by
default because the ellipsis is not inherited.

-Wno-invalid-offsetof
(C++ and Objective-C++ only)

Suppress warnings from applying the
«offsetof» macro to a non-POD type.
According to the 2014 ISO C++ standard, applying
«offsetof» to a non-standard-layout type
is undefined. In existing C++ implementations, however,
«offsetof» typically gives meaningful
results. This flag is for users who are aware that they are writing
nonportable code and who have deliberately chosen to ignore the warning
about it.

The restrictions on
«offsetof» may be relaxed in a future
version of the C++ standard.

-Wsized-deallocation
(C++ and Objective-C++ only)

Warn about a definition of an unsized deallocation function

void operator delete (void *) noexcept;
void operator delete[] (void *) noexcept;

without a definition of the corresponding sized deallocation
function

void operator delete (void *, std::size_t) noexcept;
void operator delete[] (void *, std::size_t) noexcept;

or vice versa. Enabled by -Wextra along with
-fsized-deallocation.

-Wsuggest-final-types

Warn about types with virtual methods where code quality would be improved
if the type were declared with the C++11
«final» specifier, or, if possible,
declared in an anonymous namespace. This allows GCC to more aggressively
devirtualize the polymorphic calls. This warning is more effective with
link-time optimization, where the information about the class hierarchy
graph is more complete.

-Wsuggest-final-methods

Warn about virtual methods where code quality would be improved if the
method were declared with the C++11
«final» specifier, or, if possible, its
type were declared in an anonymous namespace or with the
«final» specifier. This warning is more
effective with link-time optimization, where the information about the
class hierarchy graph is more complete. It is recommended to first
consider suggestions of -Wsuggest-final-types and then rebuild with
new annotations.

-Wsuggest-override

Warn about overriding virtual functions that are not marked with the
«override» keyword.

-Wuse-after-free

-Wuse-after-free=n

Warn about uses of pointers to dynamically allocated objects that have
been rendered indeterminate by a call to a deallocation function. The
warning is enabled at all optimization levels but may yield different
results with optimization than without.

-Wuse-after-free=2 is included in -Wall.

-Wuseless-cast
(C++ and Objective-C++ only)

Warn when an expression is cast to its own type. This warning does not
occur when a class object is converted to a non-reference type as that is
a way to create a temporary:

struct S { };
void g (S&&);
void f (S&& arg)
{
  g (S(arg)); // make arg prvalue so that it can bind to S&&
}

-Wno-conversion-null
(C++ and Objective-C++ only)

Do not warn for conversions between
«NULL» and non-pointer types.
-Wconversion-null is enabled by default.

Options Controlling Objective-C and Objective-C++ Dialects

(NOTE: This manual does not describe the Objective-C and
Objective-C++ languages themselves.

This section describes the command-line options that are only
meaningful for Objective-C and Objective-C++ programs. You can also use most
of the language-independent GNU compiler options. For example, you might
compile a file some_class.m like this:

gcc -g -fgnu-runtime -O -c some_class.m

In this example, -fgnu-runtime is an option meant only for
Objective-C and Objective-C++ programs; you can use the other options with
any language supported by GCC.

Note that since Objective-C is an extension of the C language,
Objective-C compilations may also use options specific to the C front-end
(e.g., -Wtraditional). Similarly, Objective-C++ compilations may use
C++-specific options (e.g., -Wabi).

Here is a list of options that are only for compiling
Objective-C and Objective-C++ programs:

-fconstant-string-class=class-name

Use class-name as the name of the class to instantiate for each
literal string specified with the syntax
«@»…»». The default class
name is «NXConstantString» if the GNU
runtime is being used, and
«NSConstantString» if the NeXT runtime
is being used (see below). On Darwin (macOS, MacOS X) platforms, the
-fconstant-cfstrings option, if also present, overrides the
-fconstant-string-class setting and cause
«@»…»» literals to be laid
out as constant CoreFoundation strings. Note that
-fconstant-cfstrings is an alias for the target-specific
-mconstant-cfstrings equivalent.

-fgnu-runtime

Generate object code compatible with the standard GNU Objective-C runtime.
This is the default for most types of systems.

-fnext-runtime

Generate output compatible with the NeXT runtime. This is the default for
NeXT-based systems, including Darwin and Mac OS X. The macro
«__NEXT_RUNTIME__» is predefined if (and
only if) this option is used.

-fno-nil-receivers

Assume that all Objective-C message dispatches
(«[receiver
message:arg]») in this translation unit
ensure that the receiver is not «nil».
This allows for more efficient entry points in the runtime to be used.
This option is only available in conjunction with the NeXT runtime and ABI
version 0 or 1.

-fobjc-abi-version=n

Use version n of the Objective-C ABI for the selected runtime. This
option is currently supported only for the NeXT runtime. In that case,
Version 0 is the traditional (32-bit) ABI without support for properties
and other Objective-C 2.0 additions. Version 1 is the traditional (32-bit)
ABI with support for properties and other Objective-C 2.0 additions.
Version 2 is the modern (64-bit) ABI. If nothing is specified, the default
is Version 0 on 32-bit target machines, and Version 2 on 64-bit target
machines.

-fobjc-call-cxx-cdtors

For each Objective-C class, check if any of its instance variables is a
C++ object with a non-trivial default constructor. If so, synthesize a
special «- (id) .cxx_construct» instance
method which runs non-trivial default constructors on any such instance
variables, in order, and then return
«self». Similarly, check if any instance
variable is a C++ object with a non-trivial destructor, and if so,
synthesize a special «- (void)
.cxx_destruct» method which runs all such default destructors,
in reverse order.

The «- (id) .cxx_construct»
and «- (void) .cxx_destruct» methods
thusly generated only operate on instance variables declared in the
current Objective-C class, and not those inherited from superclasses. It
is the responsibility of the Objective-C runtime to invoke all such
methods in an object’s inheritance hierarchy. The
«- (id) .cxx_construct» methods are
invoked by the runtime immediately after a new object instance is
allocated; the «- (void)
.cxx_destruct» methods are invoked immediately before the
runtime deallocates an object instance.

As of this writing, only the NeXT runtime on Mac OS X 10.4 and
later has support for invoking the «- (id)
.cxx_construct» and «- (void)
.cxx_destruct» methods.

-fobjc-direct-dispatch

Allow fast jumps to the message dispatcher. On Darwin this is accomplished
via the comm page.

-fobjc-exceptions

Enable syntactic support for structured exception handling in Objective-C,
similar to what is offered by C++. This option is required to use the
Objective-C keywords @try,
@throw, @catch,
@finally and
@synchronized. This option is available with both
the GNU runtime and the NeXT runtime (but not available in conjunction
with the NeXT runtime on Mac OS X 10.2 and earlier).

-fobjc-gc

Enable garbage collection (GC) in Objective-C and Objective-C++ programs.
This option is only available with the NeXT runtime; the GNU runtime has a
different garbage collection implementation that does not require special
compiler flags.

-fobjc-nilcheck

For the NeXT runtime with version 2 of the ABI, check for a nil receiver
in method invocations before doing the actual method call. This is the
default and can be disabled using -fno-objc-nilcheck. Class methods
and super calls are never checked for nil in this way no matter what this
flag is set to. Currently this flag does nothing when the GNU runtime, or
an older version of the NeXT runtime ABI, is used.

-fobjc-std=objc1

Conform to the language syntax of Objective-C 1.0, the language recognized
by GCC 4.0. This only affects the Objective-C additions to the C/C++
language; it does not affect conformance to C/C++ standards, which is
controlled by the separate C/C++ dialect option flags. When this option is
used with the Objective-C or Objective-C++ compiler, any Objective-C
syntax that is not recognized by GCC 4.0 is rejected. This is useful if
you need to make sure that your Objective-C code can be compiled with
older versions of GCC.

-freplace-objc-classes

Emit a special marker instructing ld(1) not to statically link in
the resulting object file, and allow dyld(1) to load it in at run
time instead. This is used in conjunction with the Fix-and-Continue
debugging mode, where the object file in question may be recompiled and
dynamically reloaded in the course of program execution, without the need
to restart the program itself. Currently, Fix-and-Continue functionality
is only available in conjunction with the NeXT runtime on Mac OS X 10.3
and later.

-fzero-link

When compiling for the NeXT runtime, the compiler ordinarily replaces
calls to objc_getClass(«…») (when the
name of the class is known at compile time) with static class references
that get initialized at load time, which improves run-time performance.
Specifying the -fzero-link flag suppresses this behavior and causes
calls to objc_getClass(«…») to be
retained. This is useful in Zero-Link debugging mode, since it allows for
individual class implementations to be modified during program execution.
The GNU runtime currently always retains calls to
objc_get_class(«…») regardless of
command-line options.

-fno-local-ivars

By default instance variables in Objective-C can be accessed as if they
were local variables from within the methods of the class they’re declared
in. This can lead to shadowing between instance variables and other
variables declared either locally inside a class method or globally with
the same name. Specifying the -fno-local-ivars flag disables this
behavior thus avoiding variable shadowing issues.

-fivar-visibility=[public|protected|private|package]

Set the default instance variable visibility to the specified option so
that instance variables declared outside the scope of any access modifier
directives default to the specified visibility.

-gen-decls

Dump interface declarations for all classes seen in the source file to a
file named sourcename.decl.

-Wassign-intercept
(Objective-C and Objective-C++ only)

Warn whenever an Objective-C assignment is being intercepted by the
garbage collector.

-Wno-property-assign-default
(Objective-C and Objective-C++ only)

Do not warn if a property for an Objective-C object has no assign
semantics specified.

-Wno-protocol
(Objective-C and Objective-C++ only)

If a class is declared to implement a protocol, a warning is issued for
every method in the protocol that is not implemented by the class. The
default behavior is to issue a warning for every method not explicitly
implemented in the class, even if a method implementation is inherited
from the superclass. If you use the -Wno-protocol option, then
methods inherited from the superclass are considered to be implemented,
and no warning is issued for them.

-Wobjc-root-class
(Objective-C and Objective-C++ only)

Warn if a class interface lacks a superclass. Most classes will inherit
from «NSObject» (or
«Object») for example. When declaring
classes intended to be root classes, the warning can be suppressed by
marking their interfaces with
«__attribute__((objc_root_class))».

-Wselector
(Objective-C and Objective-C++ only)

Warn if multiple methods of different types for the same selector are
found during compilation. The check is performed on the list of methods in
the final stage of compilation. Additionally, a check is performed for
each selector appearing in a @selector(…)
expression, and a corresponding method for that selector has been found
during compilation. Because these checks scan the method table only at the
end of compilation, these warnings are not produced if the final stage of
compilation is not reached, for example because an error is found during
compilation, or because the -fsyntax-only option is being
used.

-Wstrict-selector-match
(Objective-C and Objective-C++ only)

Warn if multiple methods with differing argument and/or return types are
found for a given selector when attempting to send a message using this
selector to a receiver of type «id» or
«Class». When this flag is off (which is
the default behavior), the compiler omits such warnings if any differences
found are confined to types that share the same size and alignment.

-Wundeclared-selector
(Objective-C and Objective-C++ only)

Warn if a @selector(…) expression referring to
an undeclared selector is found. A selector is considered undeclared if no
method with that name has been declared before the
@selector(…) expression, either explicitly in an
@interface or @protocol
declaration, or implicitly in an @implementation
section. This option always performs its checks as soon as a
@selector(…) expression is found, while
-Wselector only performs its checks in the final stage of
compilation. This also enforces the coding style convention that methods
and selectors must be declared before being used.

-print-objc-runtime-info

Generate C header describing the largest structure that is passed by
value, if any.

Options to Control Diagnostic Messages Formatting

Traditionally, diagnostic messages have been formatted
irrespective of the output device’s aspect (e.g. its width, …). You can
use the options described below to control the formatting algorithm for
diagnostic messages, e.g. how many characters per line, how often source
location information should be reported. Note that some language front ends
may not honor these options.

-fmessage-length=n

Try to format error messages so that they fit on lines of about n
characters. If n is zero, then no line-wrapping is done; each error
message appears on a single line. This is the default for all front ends.

Note — this option also affects the display of the
#error and #warning pre-processor directives, and the
deprecated function/type/variable attribute. It does not however
affect the pragma GCC warning and pragma GCC error
pragmas.

-fdiagnostics-plain-output

This option requests that diagnostic output look as plain as possible,
which may be useful when running dejagnu or other utilities that
need to parse diagnostics output and prefer that it remain more stable
over time. -fdiagnostics-plain-output is currently equivalent to
the following options: -fno-diagnostics-show-caret
-fno-diagnostics-show-line-numbers -fdiagnostics-color=never
-fdiagnostics-urls=never
-fdiagnostics-path-format=separate-events In the future, if GCC
changes the default appearance of its diagnostics, the corresponding
option to disable the new behavior will be added to this list.

-fdiagnostics-show-location=once

Only meaningful in line-wrapping mode. Instructs the diagnostic messages
reporter to emit source location information once; that is, in case
the message is too long to fit on a single physical line and has to be
wrapped, the source location won’t be emitted (as prefix) again, over and
over, in subsequent continuation lines. This is the default behavior.

-fdiagnostics-show-location=every-line

Only meaningful in line-wrapping mode. Instructs the diagnostic messages
reporter to emit the same source location information (as prefix) for
physical lines that result from the process of breaking a message which is
too long to fit on a single line.

-fdiagnostics-color[=WHEN]

-fno-diagnostics-color

Use color in diagnostics. WHEN is never, always, or
auto. The default depends on how the compiler has been configured,
it can be any of the above WHEN options or also never if
GCC_COLORS environment variable isn’t present in the environment,
and auto otherwise. auto makes GCC use color only when the
standard error is a terminal, and when not executing in an emacs shell.
The forms -fdiagnostics-color and -fno-diagnostics-color are
aliases for -fdiagnostics-color=always and
-fdiagnostics-color=never, respectively.

The colors are defined by the environment variable
GCC_COLORS. Its value is a colon-separated list of capabilities
and Select Graphic Rendition (SGR) substrings. SGR commands are
interpreted by the terminal or terminal emulator. (See the section in
the documentation of your text terminal for permitted values and their
meanings as character attributes.) These substring values are integers
in decimal representation and can be concatenated with semicolons.
Common values to concatenate include 1 for bold, 4 for
underline, 5 for blink, 7 for inverse, 39 for
default foreground color, 30 to 37 for foreground colors,
90 to 97 for 16-color mode foreground colors,
38;5;0 to 38;5;255 for 88-color and 256-color modes
foreground colors, 49 for default background color, 40 to
47 for background colors, 100 to 107 for 16-color
mode background colors, and 48;5;0 to 48;5;255 for
88-color and 256-color modes background colors.

The default GCC_COLORS is

error=01;31:warning=01;35:note=01;36:range1=32:range2=34:locus=01:\
quote=01:path=01;36:fixit-insert=32:fixit-delete=31:\
diff-filename=01:diff-hunk=32:diff-delete=31:diff-insert=32:\
type-diff=01;32:fnname=01;32:targs=35

where 01;31 is bold red, 01;35 is bold magenta,
01;36 is bold cyan, 32 is green, 34 is blue,
01 is bold, and 31 is red. Setting GCC_COLORS to
the empty string disables colors. Supported capabilities are as
follows.

-fdiagnostics-urls[=WHEN]

Use escape sequences to embed URLs in diagnostics. For example, when
-fdiagnostics-show-option emits text showing the command-line
option controlling a diagnostic, embed a URL for documentation of that
option.

WHEN is never, always, or auto.
auto makes GCC use URL escape sequences only when the standard
error is a terminal, and when not executing in an emacs shell or any
graphical terminal which is known to be incompatible with this feature,
see below.

The default depends on how the compiler has been configured.
It can be any of the above WHEN options.

GCC can also be configured (via the
—with-diagnostics-urls=auto-if-env configure-time option) so
that the default is affected by environment variables. Under such a
configuration, GCC defaults to using auto if either
GCC_URLS or TERM_URLS environment variables are present
and non-empty in the environment of the compiler, or never if
neither are.

However, even with -fdiagnostics-urls=always the
behavior is dependent on those environment variables: If GCC_URLS
is set to empty or no, do not embed URLs in diagnostics. If set
to st, URLs use ST escape sequences. If set to bel, the
default, URLs use BEL escape sequences. Any other non-empty value
enables the feature. If GCC_URLS is not set, use TERM_URLS
as a fallback. Note: ST is an ANSI escape sequence, string terminator
ESC \, BEL is an ASCII character, CTRL-G that usually sounds like
a beep.

At this time GCC tries to detect also a few terminals that are
known to not implement the URL feature, and have bugs or at least had
bugs in some versions that are still in use, where the URL escapes are
likely to misbehave, i.e. print garbage on the screen. That list is
currently xfce4-terminal, certain known to be buggy gnome-terminal
versions, the linux console, and mingw. This check can be skipped with
the -fdiagnostics-urls=always.

-fno-diagnostics-show-option

By default, each diagnostic emitted includes text indicating the
command-line option that directly controls the diagnostic (if such an
option is known to the diagnostic machinery). Specifying the
-fno-diagnostics-show-option flag suppresses that behavior.

-fno-diagnostics-show-caret

By default, each diagnostic emitted includes the original source line and
a caret ^ indicating the column. This option suppresses this
information. The source line is truncated to n characters, if the
-fmessage-length=n option is given. When the output is done to the
terminal, the width is limited to the width given by the COLUMNS
environment variable or, if not set, to the terminal width.

-fno-diagnostics-show-labels

By default, when printing source code (via
-fdiagnostics-show-caret), diagnostics can label ranges of source
code with pertinent information, such as the types of expressions:

printf ("foo %s bar", long_i + long_j);
             ~^       ~~~~~~~~~~~~~~~
              |              |
              char *         long int

This option suppresses the printing of these labels (in the
example above, the vertical bars and the «char *» and
«long int» text).

-fno-diagnostics-show-cwe

Diagnostic messages can optionally have an associated

CWE («https://cwe.mitre.org/index.html»)
identifier. GCC itself only provides such metadata for some of the
-fanalyzer diagnostics. GCC plugins may also provide diagnostics
with such metadata. By default, if this information is present, it will be
printed with the diagnostic. This option suppresses the printing of this
metadata.

-fno-diagnostics-show-rules

Diagnostic messages can optionally have rules associated with them, such
as from a coding standard, or a specification. GCC itself does not do this
for any of its diagnostics, but plugins may do so. By default, if this
information is present, it will be printed with the diagnostic. This
option suppresses the printing of this metadata.

-fno-diagnostics-show-line-numbers

By default, when printing source code (via
-fdiagnostics-show-caret), a left margin is printed, showing line
numbers. This option suppresses this left margin.

-fdiagnostics-minimum-margin-width=width

This option controls the minimum width of the left margin printed by
-fdiagnostics-show-line-numbers. It defaults to 6.

-fdiagnostics-parseable-fixits

Emit fix-it hints in a machine-parseable format, suitable for consumption
by IDEs. For each fix-it, a line will be printed after the relevant
diagnostic, starting with the string «fix-it:». For example:

fix-it:"test.c":{45:3-45:21}:"gtk_widget_show_all"

The location is expressed as a half-open range, expressed as a
count of bytes, starting at byte 1 for the initial column. In the above
example, bytes 3 through 20 of line 45 of «test.c» are to be
replaced with the given string:

00000000011111111112222222222
12345678901234567890123456789
  gtk_widget_showall (dlg);
  ^^^^^^^^^^^^^^^^^^
  gtk_widget_show_all

The filename and replacement string escape backslash as
«\\», tab as «\t», newline as «\n», double
quotes as «\»», non-printable characters as octal (e.g.
vertical tab as «\013»).

An empty replacement string indicates that the given range is
to be removed. An empty range (e.g. «45:3-45:3») indicates
that the string is to be inserted at the given position.

-fdiagnostics-generate-patch

Print fix-it hints to stderr in unified diff format, after any diagnostics
are printed. For example:

--- test.c
+++ test.c
@ -42,5 +42,5 @

 void show_cb(GtkDialog *dlg)
 {
-  gtk_widget_showall(dlg);
+  gtk_widget_show_all(dlg);
 }

The diff may or may not be colorized, following the same rules
as for diagnostics (see -fdiagnostics-color).

-fdiagnostics-show-template-tree

In the C++ frontend, when printing diagnostics showing mismatching
template types, such as:

could not convert 'std::map<int, std::vector<double> >()'
  from 'map<[...],vector<double>>' to 'map<[...],vector<float>>

the -fdiagnostics-show-template-tree flag enables
printing a tree-like structure showing the common and differing parts of
the types, such as:

map<
  [...],
  vector<
    [double != float]>>

The parts that differ are highlighted with color
(«double» and «float» in this case).

-fno-elide-type

By default when the C++ frontend prints diagnostics showing mismatching
template types, common parts of the types are printed as «[…]»
to simplify the error message. For example:

could not convert 'std::map<int, std::vector<double> >()'
  from 'map<[...],vector<double>>' to 'map<[...],vector<float>>

Specifying the -fno-elide-type flag suppresses that
behavior. This flag also affects the output of the
-fdiagnostics-show-template-tree flag.

-fdiagnostics-path-format=KIND

Specify how to print paths of control-flow events for diagnostics that
have such a path associated with them.

KIND is none, separate-events, or
inline-events, the default.

none means to not print diagnostic paths.

separate-events means to print a separate
«note» diagnostic for each event within the diagnostic. For
example:

test.c:29:5: error: passing NULL as argument 1 to 'PyList_Append' which requires a non-NULL parameter
test.c:25:10: note: (1) when 'PyList_New' fails, returning NULL
test.c:27:3: note: (2) when 'i < count'
test.c:29:5: note: (3) when calling 'PyList_Append', passing NULL from (1) as argument 1

inline-events means to print the events
«inline» within the source code. This view attempts to
consolidate the events into runs of sufficiently-close events, printing
them as labelled ranges within the source.

For example, the same events as above might be printed as:

'test': events 1-3
  |
  |   25 |   list = PyList_New(0);
  |      |          ^~~~~~~~~~~~~
  |      |          |
  |      |          (1) when 'PyList_New' fails, returning NULL
  |   26 |
  |   27 |   for (i = 0; i < count; i++) {
  |      |   ~~~
  |      |   |
  |      |   (2) when 'i < count'
  |   28 |     item = PyLong_FromLong(random());
  |   29 |     PyList_Append(list, item);
  |      |     ~~~~~~~~~~~~~~~~~~~~~~~~~
  |      |     |
  |      |     (3) when calling 'PyList_Append', passing NULL from (1) as argument 1
  |

Interprocedural control flow is shown by grouping the events
by stack frame, and using indentation to show how stack frames are
nested, pushed, and popped.

For example:

  'test': events 1-2
    |
    |  133 | {
    |      | ^
    |      | |
    |      | (1) entering 'test'
    |  134 |   boxed_int *obj = make_boxed_int (i);
    |      |                    ~~~~~~~~~~~~~~~~~~
    |      |                    |
    |      |                    (2) calling 'make_boxed_int'
    |
    +--> 'make_boxed_int': events 3-4
           |
           |  120 | {
           |      | ^
           |      | |
           |      | (3) entering 'make_boxed_int'
           |  121 |   boxed_int *result = (boxed_int *)wrapped_malloc (sizeof (boxed_int));
           |      |                                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
           |      |                                    |
           |      |                                    (4) calling 'wrapped_malloc'
           |
           +--> 'wrapped_malloc': events 5-6
                  |
                  |    7 | {
                  |      | ^
                  |      | |
                  |      | (5) entering 'wrapped_malloc'
                  |    8 |   return malloc (size);
                  |      |          ~~~~~~~~~~~~~
                  |      |          |
                  |      |          (6) calling 'malloc'
                  |
    <-------------+
    |
 'test': event 7
    |
    |  138 |   free_boxed_int (obj);
    |      |   ^~~~~~~~~~~~~~~~~~~~
    |      |   |
    |      |   (7) calling 'free_boxed_int'
    |
(etc)

-fdiagnostics-show-path-depths

This option provides additional information when printing control-flow
paths associated with a diagnostic.

If this is option is provided then the stack depth will be
printed for each run of events within
-fdiagnostics-path-format=inline-events. If provided with
-fdiagnostics-path-format=separate-events, then the stack depth
and function declaration will be appended when printing each event.

This is intended for use by GCC developers and plugin
developers when debugging diagnostics that report interprocedural
control flow.

-fno-show-column

Do not print column numbers in diagnostics. This may be necessary if
diagnostics are being scanned by a program that does not understand the
column numbers, such as dejagnu.

-fdiagnostics-column-unit=UNIT

Select the units for the column number. This affects traditional
diagnostics (in the absence of -fno-show-column), as well as JSON
format diagnostics if requested.

The default UNIT, display, considers the number
of display columns occupied by each character. This may be larger than
the number of bytes required to encode the character, in the case of tab
characters, or it may be smaller, in the case of multibyte characters.
For example, the character «GREEK SMALL LETTER PI (U+03C0)»
occupies one display column, and its UTF-8 encoding requires two bytes;
the character «SLIGHTLY SMILING FACE (U+1F642)» occupies two
display columns, and its UTF-8 encoding requires four bytes.

Setting UNIT to byte changes the column number
to the raw byte count in all cases, as was traditionally output by GCC
prior to version 11.1.0.

-fdiagnostics-column-origin=ORIGIN

Select the origin for column numbers, i.e. the column number assigned to
the first column. The default value of 1 corresponds to traditional GCC
behavior and to the GNU style guide. Some utilities may perform better
with an origin of 0; any non-negative value may be specified.

-fdiagnostics-escape-format=FORMAT

When GCC prints pertinent source lines for a diagnostic it normally
attempts to print the source bytes directly. However, some diagnostics
relate to encoding issues in the source file, such as malformed UTF-8, or
issues with Unicode normalization. These diagnostics are flagged so that
GCC will escape bytes that are not printable ASCII when printing their
pertinent source lines.

This option controls how such bytes should be escaped.

The default FORMAT, unicode displays Unicode
characters that are not printable ASCII in the form
<U+XXXX>, and bytes that do not correspond to a Unicode
character validly-encoded in UTF-8-encoded will be displayed as
hexadecimal in the form <XX>.

For example, a source line containing the string before
followed by the Unicode character U+03C0 («GREEK SMALL LETTER
PI», with UTF-8 encoding 0xCF 0x80) followed by the byte 0xBF (a
stray UTF-8 trailing byte), followed by the string after will be
printed for such a diagnostic as:

before<U+03C0><BF>after

Setting FORMAT to bytes will display all
non-printable-ASCII bytes in the form <XX>, thus showing
the underlying encoding of non-ASCII Unicode characters. For the example
above, the following will be printed:

before<CF><80><BF>after

-fdiagnostics-format=FORMAT

Select a different format for printing diagnostics. FORMAT is
text, sarif-stderr, sarif-file, json,
json-stderr, or json-file.

The default is text.

The sarif-stderr and sarif-file formats both
emit diagnostics in SARIF Version 2.1.0 format, either to stderr, or to
a file named source.sarif, respectively.

The json format is a synonym for json-stderr.
The json-stderr and json-file formats are identical, apart
from where the JSON is emitted to — with the former, the JSON is emitted
to stderr, whereas with json-file it is written to
source.gcc.json.

The emitted JSON consists of a top-level JSON array containing
JSON objects representing the diagnostics. The JSON is emitted as one
line, without formatting; the examples below have been formatted for
clarity.

Diagnostics can have child diagnostics. For example, this
error and note:

misleading-indentation.c:15:3: warning: this 'if' clause does not
  guard... [-Wmisleading-indentation]
   15 |   if (flag)
      |   ^~
misleading-indentation.c:17:5: note: ...this statement, but the latter
  is misleadingly indented as if it were guarded by the 'if'
   17 |     y = 2;
      |     ^

might be printed in JSON form (after formatting) like
this:

[
    {
        "kind": "warning",
        "locations": [
            {
                "caret": {
                    "display-column": 3,
                    "byte-column": 3,
                    "column": 3,
                    "file": "misleading-indentation.c",
                    "line": 15
                },
                "finish": {
                    "display-column": 4,
                    "byte-column": 4,
                    "column": 4,
                    "file": "misleading-indentation.c",
                    "line": 15
                }
            }
        ],
        "message": "this \u2018if\u2019 clause does not guard...",
        "option": "-Wmisleading-indentation",
        "option_url": "https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html#index-Wmisleading-indentation",
        "children": [
            {
                "kind": "note",
                "locations": [
                    {
                        "caret": {
                            "display-column": 5,
                            "byte-column": 5,
                            "column": 5,
                            "file": "misleading-indentation.c",
                            "line": 17
                        }
                    }
                ],
                "escape-source": false,
                "message": "...this statement, but the latter is ..."
            }
        ]
        "escape-source": false,
        "column-origin": 1,
    }
]

where the «note» is a child
of the «warning».

A diagnostic has a «kind».
If this is «warning», then there is an
«option» key describing the
command-line option controlling the warning.

A diagnostic can contain zero or more locations. Each location
has an optional «label» string and up
to three positions within it: a
«caret» position and optional
«start» and
«finish» positions. A position is
described by a «file» name, a
«line» number, and three numbers
indicating a column position:

bad-binary-ops.c:64:23: error: invalid operands to binary + (have 'S' {aka
   'struct s'} and 'T' {aka 'struct t'})
   64 |   return callee_4a () + callee_4b ();
      |          ~~~~~~~~~~~~ ^ ~~~~~~~~~~~~
      |          |              |
      |          |              T {aka struct t}
      |          S {aka struct s}

{
    "children": [],
    "kind": "error",
    "locations": [
        {
            "caret": {
                "column": 23, "file": "bad-binary-ops.c", "line": 64
            }
        },
        {
            "caret": {
                "column": 10, "file": "bad-binary-ops.c", "line": 64
            },
            "finish": {
                "column": 21, "file": "bad-binary-ops.c", "line": 64
            },
            "label": "S {aka struct s}"
        },
        {
            "caret": {
                "column": 25, "file": "bad-binary-ops.c", "line": 64
            },
            "finish": {
                "column": 36, "file": "bad-binary-ops.c", "line": 64
            },
            "label": "T {aka struct t}"
        }
    ],
    "escape-source": false,
    "message": "invalid operands to binary + ..."
}

demo.c:8:15: error: 'struct s' has no member named 'colour'; did you
  mean 'color'?
    8 |   return ptr->colour;
      |               ^~~~~~
      |               color

{
    "children": [],
    "fixits": [
        {
            "next": {
                "column": 21,
                "file": "demo.c",
                "line": 8
            },
            "start": {
                "column": 15,
                "file": "demo.c",
                "line": 8
            },
            "string": "color"
        }
    ],
    "kind": "error",
    "locations": [
        {
            "caret": {
                "column": 15,
                "file": "demo.c",
                "line": 8
            },
            "finish": {
                "column": 20,
                "file": "demo.c",
                "line": 8
            }
        }
    ],
    "escape-source": false,
    "message": "\u2018struct s\u2019 has no member named ..."
}

"path": [
    {
        "depth": 0,
        "description": "when 'PyList_New' fails, returning NULL",
        "function": "test",
        "location": {
            "column": 10,
            "file": "test.c",
            "line": 25
        }
    },
    {
        "depth": 0,
        "description": "when 'i < count'",
        "function": "test",
        "location": {
            "column": 3,
            "file": "test.c",
            "line": 27
        }
    },
    {
        "depth": 0,
        "description": "when calling 'PyList_Append', passing NULL from (1) as argument 1",
        "function": "test",
        "location": {
            "column": 5,
            "file": "test.c",
            "line": 29
        }
    }
]

Options to Request or Suppress Warnings

Warnings are diagnostic messages that report constructions that
are not inherently erroneous but that are risky or suggest there may have
been an error.

The following language-independent options do not enable specific
warnings but control the kinds of diagnostics produced by GCC.

-fsyntax-only

Check the code for syntax errors, but don’t do anything beyond that.

-fmax-errors=n

Limits the maximum number of error messages to n, at which point
GCC bails out rather than attempting to continue processing the source
code. If n is 0 (the default), there is no limit on the number of
error messages produced. If -Wfatal-errors is also specified, then
-Wfatal-errors takes precedence over this option.

-w

Inhibit all warning messages.

-Werror

Make all warnings into errors.

-Werror=

Make the specified warning into an error. The specifier for a warning is
appended; for example -Werror=switch turns the warnings controlled
by -Wswitch into errors. This switch takes a negative form, to be
used to negate -Werror for specific warnings; for example
-Wno-error=switch makes -Wswitch warnings not be errors,
even when -Werror is in effect.

The warning message for each controllable warning includes the
option that controls the warning. That option can then be used with
-Werror= and -Wno-error= as described above. (Printing of
the option in the warning message can be disabled using the
-fno-diagnostics-show-option flag.)

Note that specifying -Werror=foo automatically
implies -Wfoo. However, -Wno-error=foo does
not imply anything.

-Wfatal-errors

This option causes the compiler to abort compilation on the first error
occurred rather than trying to keep going and printing further error
messages.

You can request many specific warnings with options beginning with
-W, for example -Wimplicit to request warnings on implicit
declarations. Each of these specific warning options also has a negative
form beginning -Wno- to turn off warnings; for example,
-Wno-implicit. This manual lists only one of the two forms, whichever
is not the default. For further language-specific options also refer to
C++ Dialect Options and Objective-C and Objective-C++ Dialect
Options. Additional warnings can be produced by enabling the static
analyzer;

Some options, such as -Wall and -Wextra, turn on
other options, such as -Wunused, which may turn on further options,
such as -Wunused-value. The combined effect of positive and negative
forms is that more specific options have priority over less specific ones,
independently of their position in the command-line. For options of the same
specificity, the last one takes effect. Options enabled or disabled via
pragmas take effect as if they appeared at the end of the command-line.

When an unrecognized warning option is requested (e.g.,
-Wunknown-warning), GCC emits a diagnostic stating that the option is
not recognized. However, if the -Wno- form is used, the behavior is
slightly different: no diagnostic is produced for
-Wno-unknown-warning unless other diagnostics are being produced.
This allows the use of new -Wno- options with old compilers, but if
something goes wrong, the compiler warns that an unrecognized option is
present.

The effectiveness of some warnings depends on optimizations also
being enabled. For example -Wsuggest-final-types is more effective
with link-time optimization and some instances of other warnings may not be
issued at all unless optimization is enabled. While optimization in general
improves the efficacy of control and data flow sensitive warnings, in some
cases it may also cause false positives.

-Wpedantic

-pedantic

Issue all the warnings demanded by strict ISO C and ISO C++; reject all
programs that use forbidden extensions, and some other programs that do
not follow ISO C and ISO C++. For ISO C, follows the version of the ISO C
standard specified by any -std option used.

Valid ISO C and ISO C++ programs should compile properly with
or without this option (though a rare few require -ansi or a
-std option specifying the required version of ISO C). However,
without this option, certain GNU extensions and traditional C and C++
features are supported as well. With this option, they are rejected.

-Wpedantic does not cause warning messages for use of
the alternate keywords whose names begin and end with __. This
alternate format can also be used to disable warnings for non-ISO
__intN types, i.e. __intN__. Pedantic warnings are also
disabled in the expression that follows
«__extension__». However, only system
header files should use these escape routes; application programs should
avoid them.

Some users try to use -Wpedantic to check programs for
strict ISO C conformance. They soon find that it does not do quite what
they want: it finds some non-ISO practices, but not all—only those for
which ISO C requires a diagnostic, and some others for which
diagnostics have been added.

A feature to report any failure to conform to ISO C might be
useful in some instances, but would require considerable additional work
and would be quite different from -Wpedantic. We don’t have plans
to support such a feature in the near future.

Where the standard specified with -std represents a GNU
extended dialect of C, such as gnu90 or gnu99, there is a
corresponding base standard, the version of ISO C on which the
GNU extended dialect is based. Warnings from -Wpedantic are given
where they are required by the base standard. (It does not make sense
for such warnings to be given only for features not in the specified GNU
C dialect, since by definition the GNU dialects of C include all
features the compiler supports with the given option, and there would be
nothing to warn about.)

-pedantic-errors

Give an error whenever the base standard (see -Wpedantic)
requires a diagnostic, in some cases where there is undefined behavior at
compile-time and in some other cases that do not prevent compilation of
programs that are valid according to the standard. This is not equivalent
to -Werror=pedantic, since there are errors enabled by this option
and not enabled by the latter and vice versa.

-Wall

This enables all the warnings about constructions that some users consider
questionable, and that are easy to avoid (or modify to prevent the
warning), even in conjunction with macros. This also enables some
language-specific warnings described in C++ Dialect Options
and Objective-C and Objective-C++ Dialect Options.

-Wall turns on the following warning flags:

-Waddress -Warray-bounds=1 (only with-O2) -Warray-compare -Warray-parameter=2 (C and
Objective-C only) -Wbool-compare -Wbool-operation
-Wc++11-compat -Wc++14-compat -Wcatch-value (C++ and
Objective-C++ only) -Wchar-subscripts -Wcomment
-Wdangling-pointer=2 -Wduplicate-decl-specifier (C and
Objective-C only) -Wenum-compare (in C/ObjC; this is on by
default in C++) -Wenum-int-mismatch (C and Objective-C only)
-Wformat -Wformat-overflow -Wformat-truncation
-Wint-in-bool-context -Wimplicit (C and Objective-C only)
-Wimplicit-int (C and Objective-C only)
-Wimplicit-function-declaration (C and Objective-C only)
-Winit-self (only for C++) -Wlogical-not-parentheses
-Wmain (only for C/ObjC and unless-ffreestanding)
-Wmaybe-uninitialized -Wmemset-elt-size
-Wmemset-transposed-args -Wmisleading-indentation (only
for C/C++) -Wmismatched-dealloc -Wmismatched-new-delete
(only for C/C++) -Wmissing-attributes -Wmissing-braces
(only for C/ObjC) -Wmultistatement-macros -Wnarrowing
(only for C++) -Wnonnull -Wnonnull-compare
-Wopenmp-simd -Wparentheses -Wpessimizing-move
(only for C++) -Wpointer-sign -Wrange-loop-construct (only
for C++) -Wreorder -Wrestrict -Wreturn-type
-Wself-move (only for C++) -Wsequence-point
-Wsign-compare (only in C++) -Wsizeof-array-div
-Wsizeof-pointer-div -Wsizeof-pointer-memaccess
-Wstrict-aliasing -Wstrict-overflow=1 -Wswitch
-Wtautological-compare -Wtrigraphs -Wuninitialized
-Wunknown-pragmas -Wunused-function -Wunused-label
-Wunused-value -Wunused-variable -Wuse-after-free=2
-Wvla-parameter (C and Objective-C only)
-Wvolatile-register-var -Wzero-length-bounds

Note that some warning flags are not implied by -Wall.
Some of them warn about constructions that users generally do not
consider questionable, but which occasionally you might wish to check
for; others warn about constructions that are necessary or hard to avoid
in some cases, and there is no simple way to modify the code to suppress
the warning. Some of them are enabled by -Wextra but many of them
must be enabled individually.

This enables some extra warning flags that are not enabled by
-Wall. (This option used to be called -W. The older name is
still supported, but the newer name is more descriptive.)

-Wclobbered -Wcast-function-type
-Wdangling-reference (C++ only) -Wdeprecated-copy (C++
only) -Wempty-body -Wenum-conversion (C only)
-Wignored-qualifiers -Wimplicit-fallthrough=3
-Wmissing-field-initializers -Wmissing-parameter-type (C
only) -Wold-style-declaration (C only) -Woverride-init
-Wsign-compare (C only) -Wstring-compare
-Wredundant-move (only for C++) -Wtype-limits
-Wuninitialized -Wshift-negative-value (in C++11 to C++17
and in C99 and newer) -Wunused-parameter (only with-Wunusedor-Wall)
-Wunused-but-set-parameter (only with-Wunusedor-Wall)

The option -Wextra also prints warning messages for the
following cases: