SYNOPSIS

DESCRIPTION

Options interpreted by castxml are listed below. Remaining options are given to the internal Clang compiler.

OPTIONS

--castxml-cc-<id> <cc>

--castxml-cc-<id> "(" <cc> <cc-opt>... ")"

Configure the internal Clang preprocessor and target platform to match that of the given compiler command. The <id> must be "gnu", "msvc", "gnu-c", or "msvc-c". <cc> names a compiler (e.g. "gcc") and <cc-opt>... specifies options that may affect its target (e.g. "-m32").

--castxml-gccxml

Write gccxml-format output to <src>.xml or file named by '-o'

--castxml-start <name>[,<name>]...

Start AST traversal at declaration(s) with the given (qualified) name(s). Multiple names may be specified as a comma-separated list or by repeating the option.

-help, --help

Print castxml and internal Clang compiler usage information

-o <file>

Write output to <file>

--version

Print castxml and internal Clang compiler version information

Help for the internal Clang compiler appears below.

---------------------------------------------------------------

OVERVIEW: clang LLVM compiler

USAGE: clang [options] <inputs>

OPTIONS:

-###

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

--analyze

Run the static analyzer

-arcmt-migrate-emit-errors

Emit ARC errors even if the migrator can fix them

-arcmt-migrate-report-output <value>

Output path for the plist report

--cuda-device-only

Do device-side CUDA compilation only

--cuda-host-only

Do host-side CUDA compilation only

--cuda-path=<value>

CUDA installation path

-cxx-isystem <directory>

Add directory to the C++ SYSTEM include search path

-c

Only run preprocess, compile, and assemble steps

-dD

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

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

-dependency-file <value>

Filename (or -) to write dependency output to

-dM

Print macro definitions in -E mode instead of normal output

-emit-ast

Emit Clang AST files for source inputs

-emit-llvm

Use the LLVM representation for assembler and object files

-E

Only run the preprocessor

-faltivec

Enable AltiVec vector initializer syntax

-fansi-escape-codes

Use ANSI escape codes for diagnostics

-fapple-kext

Use Apple's kernel extensions ABI

-fapple-pragma-pack

Enable Apple gcc-compatible #pragma pack handling

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

-fblocks

Enable the 'blocks' language feature

-fborland-extensions

Accept non-standard constructs supported by the Borland compiler

-fbuild-session-file=<file>

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

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

Time when the current build session started

-fcolor-diagnostics

Use colors in diagnostics

-fcomment-block-commands=<arg>

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

-fcoverage-mapping

Generate coverage mapping to enable code coverage analysis

-fcxx-exceptions

Enable C++ exceptions

-fdata-sections

Place each data in its own section (ELF Only)

-fdebug-prefix-map=<value>

remap file source paths in debug info

-fdebug-types-section

Place debug types in their own section (ELF Only)

-fdeclspec

Allow __declspec as a keyword

-fdelayed-template-parsing

Parse templated function definitions at the end of the translation unit

-fdiagnostics-parseable-fixits

Print fix-its in machine parseable form

-fdiagnostics-print-source-range-info

Print source range spans in numeric form

-fdiagnostics-show-note-include-stack

Display include stacks for diagnostic notes

-fdiagnostics-show-option

Print option name with mappable diagnostics

-fdiagnostics-show-template-tree

Print a template comparison tree for differing templates

-fdollars-in-identifiers

Allow '$' in identifiers

-femit-all-decls

Emit all declarations, even if unused

-femulated-tls

Use emutls functions to access thread_local variables

-fexceptions

Enable support for exception handling

-ffast-math

Enable the *frontend*'s 'fast-math' mode. This has no effect on optimizations, but provides a preprocessor macro __FAST_MATH__ the same as GCC's -ffast-math flag

-ffixed-r9

Reserve the r9 register (ARM only)

-ffixed-x18

Reserve the x18 register (AArch64 only)

-ffp-contract=<value>

Form fused FP ops (e.g. FMAs): fast (everywhere) | on (according to FP_CONTRACT pragma, default) | off (never fuse)

-ffreestanding

Assert that the compilation takes place in a freestanding environment

-ffunction-sections

Place each function in its own section (ELF Only)

-fgnu-keywords

Allow GNU-extension keywords regardless of language standard

-fgnu-runtime

Generate output compatible with the standard GNU Objective-C runtime

-fgnu89-inline

Use the gnu89 inline semantics

-fimplicit-module-maps

Implicitly search the file system for module map files.

-finstrument-functions

Generate calls to instrument function entry and exit

-fintegrated-as

Enable the integrated assembler

-flto=<value>

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

-flto

Enable LTO in 'full' mode

-fmath-errno

Require math functions to indicate errors by setting errno

-fmax-type-align=<value>

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

-fmodule-file=<file>

Load this precompiled module file

-fmodule-map-file=<file>

Load this module map file

-fmodule-name= <name>

Specify the name of the module to build

-fmodules-cache-path=<directory>

Specify the module cache path

-fmodules-decluse

Require declaration of modules used within a module

-fmodules-ignore-macro=<value>

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

-fmodules-prune-after=<seconds>

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

-fmodules-prune-interval=<seconds>

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

-fmodules-search-all

Search even non-imported modules to resolve references

-fmodules-strict-decluse

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

-fmodules-user-build-path <directory>

Specify the module user build path

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

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

-fmodules-validate-system-headers

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

-fmodules

Enable the 'modules' language feature

-fms-compatibility-version=<value>

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

-fms-compatibility

Enable full Microsoft Visual C++ compatibility

-fms-extensions

Accept some non-standard constructs supported by the Microsoft compiler

-fmsc-version=<value>

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

-fno-access-control

Disable C++ access control

-fno-assume-sane-operator-new

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

-fno-autolink

Disable generation of linker directives for automatic library linking

-fno-builtin-<value>

Disable implicit builtin knowledge of a specific function

-fno-builtin

Disable implicit builtin knowledge of functions

-fno-common

Compile common globals like normal definitions

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

-fno-coverage-mapping

Disable code coverage analysis

-fno-declspec

Disallow __declspec as a keyword

-fno-diagnostics-fixit-info

Do not include fixit information in diagnostics

-fno-dollars-in-identifiers

Disallow '$' in identifiers

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

-fno-elide-type

Do not elide types when printing diagnostics

-fno-gnu-inline-asm

Disable GNU style inline asm

-fno-integrated-as

Disable the integrated assembler

-fno-lax-vector-conversions

Disallow implicit conversions between vectors with a different number of elements or different element types

-fno-lto

Disable LTO mode (default)

-fno-math-builtin

Disable implicit builtin knowledge of math functions

-fno-merge-all-constants

Disallow merging of constants

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

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

-fno-operator-names

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

-fno-profile-instr-generate

Disable generation of profile instrumentation.

-fno-profile-instr-use

Disable using instrumentation data for profile-guided optimization

-fno-reroll-loops

Turn off loop reroller

-fno-rtti

Disable generation of rtti information

-fno-sanitize-blacklist Don't use blacklist file for sanitizers

-fno-sanitize-cfi-cross-dso

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

-fno-sanitize-coverage=<value>

Disable specified features of coverage instrumentation for Sanitizers

-fno-sanitize-memory-track-origins

Disable origins tracking in MemorySanitizer

-fno-sanitize-recover=<value>

Disable recovery for specified sanitizers

-fno-sanitize-trap=<value>

Disable trapping for specified sanitizers

-fno-short-wchar

Force wchar_t to be an unsigned int

-fno-show-column

Do not include column number on diagnostics

-fno-show-source-location

Do not include source location information with diagnostics

-fno-signed-char

Char is unsigned

-fno-signed-zeros

Allow optimizations that ignore the sign of floating point zeros

-fno-spell-checking

Disable spell-checking

-fno-stack-protector

Disable the use of stack protectors

-fno-standalone-debug

Limit debug information produced to reduce size of debug binary

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

-fno-trigraphs

Do not process trigraph sequences

-fno-unroll-loops

Turn off loop unroller

-fno-use-cxa-atexit

Don't use __cxa_atexit for calling destructors

-fno-use-init-array

Don't use .init_array instead of .ctors

-fobjc-arc-exceptions

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

-fobjc-arc

Synthesize retain and release calls for Objective-C pointers

-fobjc-exceptions

Enable Objective-C exceptions

-fobjc-gc-only

Use GC exclusively for Objective-C related memory management

-fobjc-gc

Enable Objective-C garbage collection

-fobjc-runtime=<value>

Specify the target Objective-C runtime kind and version

-fobjc-weak

Enable ARC-style weak references in Objective-C

-fpack-struct=<value>

Specify the default maximum struct packing alignment

-fpascal-strings

Recognize and construct Pascal-style string literals

-fpcc-struct-return

Override the default ABI to return all structs on the stack

-fplugin=<dsopath>

Load the named plugin (dynamic shared object)

-fprofile-generate=<directory>

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

-fprofile-instr-generate=<file>

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

-fprofile-instr-generate

Generate instrumented code to collect execution counts into default.profraw file (overriden by '=' form of option or LLVM_PROFILE_FILE env var)

-fprofile-instr-use=<value>

Use instrumentation data for profile-guided optimization

-fprofile-sample-use=<value>

Enable sample-based profile guided optimizations

-fprofile-use=<pathname>

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

-freciprocal-math

Allow division operations to be reassociated

-freg-struct-return

Override the default ABI to return small structs in registers

-freroll-loops

Turn on loop reroller

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

Level of field padding for AddressSanitizer

-fsanitize-blacklist=<value>

Path to blacklist file for sanitizers

-fsanitize-cfi-cross-dso

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

-fsanitize-coverage=<value>

Specify the type of coverage instrumentation for Sanitizers

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

Enable origins tracking in MemorySanitizer

-fsanitize-memory-track-origins

Enable origins tracking in MemorySanitizer

-fsanitize-memory-use-after-dtor

Enable use-after-destroy detection in MemorySanitizer

-fsanitize-recover=<value>

Enable recovery for specified sanitizers

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

-fsanitize=<check>

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

-fshort-enums

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

-fshort-wchar

Force wchar_t to be a short unsigned int

-fshow-overloads=<value>

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

-fsized-deallocation

Enable C++14 sized global deallocation functions

-fslp-vectorize-aggressive

Enable the BB vectorization passes

-fslp-vectorize

Enable the superword-level parallelism vectorization passes

-fstack-protector-all

Force the usage of stack protectors for all functions

-fstack-protector-strong

Use a strong heuristic to apply stack protectors to functions

-fstack-protector

Enable stack protectors for functions potentially vulnerable to stack smashing

-fstandalone-debug

Emit full debug info for all types used by the program

-fstrict-enums

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

-fstrict-vtable-pointers

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

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

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

-ftrapv-handler=<function name>

Specify the function to be called on overflow

-ftrapv

Trap on integer overflow

-ftrigraphs

Process trigraph sequences

-funique-section-names

Use unique names for text and data sections (ELF Only)

-funroll-loops

Turn on loop unroller

-fuse-init-array

Use .init_array instead of .ctors

-fveclib=<value>

Use the given vector functions library

-fvectorize

Enable the loop vectorization passes

-fvisibility-inlines-hidden

Give inline C++ member functions default visibility by default

-fvisibility-ms-compat

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

-fvisibility=<value>

Set the default symbol visibility for all global declarations

-fwrapv

Treat signed integer overflow as two's complement

-fwritable-strings

Store string literals as writable data

-fzvector

Enable System z vector language extension

-F <value>

Add directory to framework include search path

--gcc-toolchain=<value> Use the gcc toolchain at the given directory

-gcodeview

Generate CodeView debug information

-gdwarf-2

Generate source-level debug information with dwarf version 2

-gdwarf-3

Generate source-level debug information with dwarf version 3

-gdwarf-4

Generate source-level debug information with dwarf version 4

-gdwarf-5

Generate source-level debug information with dwarf version 5

-gline-tables-only

Emit debug line number tables only

-gmodules

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

-g

Generate source-level debug information

-help

Display available options

-H

Show header includes and nesting depth

-idirafter <value>

Add directory to AFTER include search path

-iframework <value>

Add directory to SYSTEM framework search path

-imacros <file>

Include macros from file before parsing

-include-pch <file>

Include precompiled header file

-include <file>

Include file before parsing

-index-header-map

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

-iprefix <dir>

Set the -iwithprefix/-iwithprefixbefore prefix

-iquote <directory>

Add directory to QUOTE include search path

-isysroot <dir>

Set the system root directory (usually /)

-isystem <directory>

Add directory to SYSTEM include search path

-ivfsoverlay <value>

Overlay the virtual filesystem described by file over the real file system

-iwithprefixbefore <dir>

Set directory to include search path with prefix

-iwithprefix <dir>

Set directory to SYSTEM include search path with prefix

-iwithsysroot <directory>

Add directory to SYSTEM include search path, absolute paths are relative to -isysroot

-I <value>

Add directory to include search path

-mabicalls

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

-mcrc

Allow use of CRC instructions (ARM only)

-MD

Write a depfile containing user and system headers

-meabi <value>

Set EABI type, e.g. 4, 5 or gnu (default depends on triple)

-mfix-cortex-a53-835769 Workaround Cortex-A53 erratum 835769 (AArch64 only)

-mfp32

Use 32-bit floating point registers (MIPS only)

-mfp64

Use 64-bit floating point registers (MIPS only)

-MF <file>

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

-mgeneral-regs-only

Generate code which only uses the general purpose registers (AArch64 only)

-mglobal-merge

Enable merging of globals

-MG

Add missing headers to depfile

-mhvx-double

Enable Hexagon Double Vector eXtensions

-mhvx

Enable Hexagon Vector eXtensions

--migrate

Run the migrator

-mincremental-linker-compatible

(integrated-as) Emit an object file which can be used with an incremental linker

-mios-version-min=<value>

Set iOS deployment target

-mllvm <value>

Additional arguments to forward to LLVM's option processing

-mlong-calls

Generate an indirect jump to enable jumps further than 64M

-mmacosx-version-min=<value>

Set Mac OS X deployment target

-MMD

Write a depfile containing user headers

-mms-bitfields

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

-mmsa

Enable MSA ASE (MIPS only)

-MM

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

-mno-abicalls

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

-mno-fix-cortex-a53-835769

Don't workaround Cortex-A53 erratum 835769 (AArch64 only)

-mno-global-merge

Disable merging of globals

-mno-hvx-double

Disable Hexagon Double Vector eXtensions

-mno-hvx

Disable Hexagon Vector eXtensions

-mno-implicit-float

Don't generate implicit floating point instructions

-mno-incremental-linker-compatible

(integrated-as) Emit an object file which cannot be used with an incremental linker

-mno-long-calls

Restore the default behaviour of not generating long calls

-mno-movt

Disallow use of movt/movw pairs (ARM only)

-mno-ms-bitfields

Do not set the default structure layout to be compatible with the Microsoft compiler standard

-mno-msa

Disable MSA ASE (MIPS only)

-mno-restrict-it

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

-mno-unaligned-access

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

-mnocrc

Disallow use of CRC instructions (ARM only)

-module-dependency-dir <value>

Directory to dump module dependencies to

-momit-leaf-frame-pointer

Omit frame pointer setup for leaf functions

-MP

Create phony target for each dependency (other than main file)

-mqdsp6-compat

Enable hexagon-qdsp6 backward compatibility

-MQ <value>

Specify name of main file output to quote in depfile

-mrelax-all

(integrated-as) Relax all machine instructions

-mrestrict-it

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

-mrtd

Make StdCall calling convention the default

-msoft-float

Use software floating point

-mstack-alignment=<value>

Set the stack alignment

-mstack-probe-size=<value>

Set the stack probe size

-mstackrealign

Force realign the stack at entry to every function

-mthread-model <value>

The thread model to use, e.g. posix, single (posix by default)

-MT <value>

Specify name of main file output in depfile

-munaligned-access

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

-MV

Use NMake/Jom format for the depfile

-M

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

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

Treat all #include paths starting with <prefix> as not including a system header.

-nobuiltininc

Disable builtin #include directories

-nostdinc++

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

-ObjC++

Treat source input files as Objective-C++ inputs

-objcmt-atomic-property Make migration to 'atomic' properties

-objcmt-migrate-all

Enable migration to modern ObjC

-objcmt-migrate-annotation

Enable migration to property and method annotations

-objcmt-migrate-designated-init

Enable migration to infer NS_DESIGNATED_INITIALIZER for initializer methods

-objcmt-migrate-instancetype

Enable migration to infer instancetype for method result type

-objcmt-migrate-literals

Enable migration to modern ObjC literals

-objcmt-migrate-ns-macros

Enable migration to NS_ENUM/NS_OPTIONS macros

-objcmt-migrate-property-dot-syntax

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

-objcmt-migrate-property

Enable migration to modern ObjC property

-objcmt-migrate-protocol-conformance

Enable migration to add protocol conformance on classes

-objcmt-migrate-readonly-property

Enable migration to modern ObjC readonly property

-objcmt-migrate-readwrite-property

Enable migration to modern ObjC readwrite property

-objcmt-migrate-subscripting

Enable migration to modern ObjC subscripting

-objcmt-ns-nonatomic-iosonly

Enable migration to use NS_NONATOMIC_IOSONLY macro for setting property's 'atomic' attribute

-objcmt-returns-innerpointer-property

Enable migration to annotate property with NS_RETURNS_INNER_POINTER

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

Only modify files with a filename contained in the provided directory path

-ObjC

Treat source input files as Objective-C inputs

-omptargets=<value>

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

-o <file>

Write output to <file>

-pg

Enable mcount instrumentation

-pipe

Use pipes between commands, when possible

-print-file-name=<file> Print the full library path of <file>

-print-ivar-layout

Enable Objective-C Ivar layout bitmap print trace

-print-libgcc-file-name Print the library path for "libgcc.a"

-print-prog-name=<name> Print the full program path of <name>

-print-search-dirs

Print the paths used for finding libraries and programs

-pthread

Support POSIX threads in generated code

-P

Disable linemarker output in -E mode

-Qunused-arguments

Don't emit warning for unused driver arguments

-relocatable-pch

Whether to build a relocatable precompiled header

-rewrite-legacy-objc

Rewrite Legacy Objective-C source to C++

-rewrite-objc

Rewrite Objective-C source to C++

-Rpass-analysis=<value> Report transformation analysis from optimization passes whose name matches the given POSIX regular expression

-Rpass-missed=<value>

Report missed transformations by optimization passes whose name matches the given POSIX regular expression

-Rpass=<value>

Report transformations performed by optimization passes whose name matches the given POSIX regular expression

-R<remark>

Enable the specified remark

-save-temps=<value>

Save intermediate compilation results.

-save-temps

Save intermediate compilation results

-serialize-diagnostics <value>

Serialize compiler diagnostics to a file

-std=<value>

Language standard to compile for

-stdlib=<value>

C++ standard library to use

--system-header-prefix=<prefix>

Treat all #include paths starting with <prefix> as including a system header.

-S

Only run preprocess and compilation steps

--target=<value>

Generate code for the given target

-time

Time individual commands

-traditional-cpp

Enable some traditional CPP emulation

-trigraphs

Process trigraph sequences

-undef

undef all system defines

--verify-debug-info

Verify the binary representation of debug output

-verify-pch

Load and verify that a pre-compiled header file is not stale

-v

Show commands to run and use verbose output

-Wa,<arg>

Pass the comma separated arguments in <arg> to the assembler

-Wl,<arg>

Pass the comma separated arguments in <arg> to the linker

-working-directory <value>

Resolve file paths relative to the specified directory

-Wp,<arg>

Pass the comma separated arguments in <arg> to the preprocessor

-W<warning>

Enable the specified warning

-w

Suppress all warnings

-Xanalyzer <arg>

Pass <arg> to the static analyzer

-Xassembler <arg>

Pass <arg> to the assembler

-Xclang <arg>

Pass <arg> to the clang compiler

-Xlinker <arg>

Pass <arg> to the linker

-Xpreprocessor <arg>

Pass <arg> to the preprocessor

-x <language>

Treat subsequent input files as having type <language>

-z <arg>

Pass -z <arg> to the linker

CastXML project maintained and supported by Kitware (kitware.com).

clang version 3.8.1-3 (tags/RELEASE_381/final) Target: x86_64-pc-linux-gnu Thread model: posix InstalledDir: