Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

Man Page or Keyword Search:
Man Architecture
Apropos Keyword Search (all sections) Output format
home | help
CLANG(1)		FreeBSD	General	Commands Manual		      CLANG(1)

     clang -- the Clang	C, C++,	and Objective-C	compiler

     clang [-c|-S|-E] std=standard -g
	   -Wwarnings... -pedantic
	   -Idir... -Ldir...
	   -o output-file

     clang is a	C, C++,	and Objective-C	compiler which encompasses preprocess-
     ing, parsing, optimization, code generation, assembly, and	linking.
     Depending on which	high-level mode	setting	is passed, Clang will stop
     before doing a full link.	While Clang is highly integrated, it is	impor-
     tant to understand	the stages of compilation, to understand how to	invoke
     it.  These	stages are:

     Driver  The clang executable is actually a	small driver which controls
	     the overall execution of other tools such as the compiler,	assem-
	     bler and linker.  Typically you do	not need to interact with the
	     driver, but you transparently use it to run the other tools.

	     This stage	handles	tokenization of	the input source file, macro
	     expansion,	#include expansion and handling	of other preprocessor
	     directives.  The output of	this stage is typically	called a ".i"
	     (for C), ".ii" (for C++), ".mi" (for Objective-C) , or ".mii"
	     (for Objective-C++) file.

     Parsing and Semantic Analysis
	     This stage	parses the input file, translating preprocessor	tokens
	     into a parse tree.	 Once in the form of a parser tree, it applies
	     semantic analysis to compute types	for expressions	as well	and
	     determine whether the code	is well	formed.	This stage is respon-
	     sible for generating most of the compiler warnings	as well	as
	     parse errors.  The	output of this stage is	an "Abstract Syntax
	     Tree" (AST).

     Code Generation and Optimization
	     This stage	translates an AST into low-level intermediate code
	     (known as "LLVM IR") and ultimately to machine code.  This	phase
	     is	responsible for	optimizing the generated code and handling
	     target-specific code generation.  The output of this stage	is
	     typically called a	".s" file or "assembly"	file.

	     Clang also	supports the use of an integrated assembler, in	which
	     the code generator	produces object	files directly.	This avoids
	     the overhead of generating	the ".s" file and of calling the tar-
	     get assembler.

	     This stage	runs the target	assembler to translate the output of
	     the compiler into a target	object file.  The output of this stage
	     is	typically called a ".o"	file or	"object" file.

     Linker  This stage	runs the target	linker to merge	multiple object	files
	     into an executable	or dynamic library.  The output	of this	stage
	     is	typically called an "a.out", ".dylib" or ".so" file.

     The Clang compiler	supports a large number	of options to control each of
     these stages.  In addition	to compilation of code,	Clang also supports
     other tools:

     Clang Static Analyzer

     The Clang Static Analyzer is a tool that scans source code	to try to find
     bugs through code analysis.  This tool uses many parts of Clang and is
     built into	the same driver.  Please see
     for more details on how to	use the	static analyzer.

   Stage Selection Options
     -E	     Run the preprocessor stage.

	     Run the preprocessor, parser and type checking stages.

     -S	     Run the previous stages as	well as	LLVM generation	and optimiza-
	     tion stages and target-specific code generation, producing	an
	     assembly file.

     -c	     Run all of	the above, plus	the assembler, generating a target
	     ".o" object file.

     no	stage selection	option
	     If	no stage selection option is specified,	all stages above are
	     run, and the linker is run	to combine the results into an exe-
	     cutable or	shared library.

   Language Selection and Mode Options
     -x	language
	     Treat subsequent input files as having type language.

	     Specify the language standard to compile for.

	     Specify the C++ standard library to use; supported	options	are
	     libstdc++ and libc++.

     -ansi   Same as -std=c89.

	     Treat source input	files as Objective-C++ inputs.

     -ObjC   Treat source input	files as Objective-C inputs.

	     Enable trigraphs.

	     Indicate that the file should be compiled for a freestanding, not
	     a hosted, environment.

	     Disable special handling and optimizations	of builtin functions
	     like strlen and malloc.

	     Indicate that math	functions should be treated as updating	errno.

	     Enable support for	Pascal-style strings with "\pfoo".

	     Enable support for	Microsoft extensions.

	     Set _MSC_VER. Defaults to 1300 on Windows.	Not set	otherwise.

	     Enable support for	Borland	extensions.

	     Make all string literals default to writable.  This disables
	     uniquing of strings and other optimizations.

	     Allow loose type checking rules for implicit vector conversions.

	     Enable the	"Blocks" language feature.

	     Indicate that Objective-C code should be compiled in GC-only
	     mode, which only works when Objective-C Garbage Collection	is

	     Indicate that Objective-C code should be compiled in hybrid-GC
	     mode, which works with both GC and	non-GC mode.

	     Select the	Objective-C ABI	version	to use.	Available versions are
	     1 (legacy "fragile" ABI), 2 (non-fragile ABI 1), and 3 (non-frag-
	     ile ABI 2).

	     Select the	Objective-C non-fragile	ABI version to use by default.
	     This will only be used as the Objective-C ABI when	the non-frag-
	     ile ABI is	enabled	(either	via -fobjc-nonfragile-abi, or because
	     it	is the platform	default).

	     Enable use	of the Objective-C non-fragile ABI. On platforms for
	     which this	is the default ABI, it can be disabled with

   Target Selection Options
     Clang fully supports cross	compilation as an inherent part	of its design.
     Depending on how your version of Clang is configured, it may have support
     for a number of cross compilers, or may only support a native target.

     -arch architecture
	     Specify the architecture to build for.

	     When building for Mac OS X, specify the minimum version supported
	     by	your application.

	     When building for iPhone OS, specify the minimum version sup-
	     ported by your application.

	     Specify that Clang	should generate	code for a specific processor
	     family member and later.  For example, if you specify
	     -march=i486, the compiler is allowed to generate instructions
	     that are valid on i486 and	later processors, but which may	not
	     exist on earlier ones.

   Code	Generation Options
     -O0 -O1 -O2 -O3 -Ofast -Os	-Oz -O -O4
	     Specify which optimization	level to use:

	     -O0     Means "no optimization": this level compiles the fastest
		     and generates the most debuggable code.

	     -O1     Somewhere between -O0 and -O2.

	     -O2     Moderate level of optimization which enables most opti-

	     -O3     Like -O2, except that it enables optimizations that take
		     longer to perform or that may generate larger code	(in an
		     attempt to	make the program run faster).

	     -Ofast  Enables all the optimizations from	-O3 along with other
		     aggressive	optimizations that may violate strict compli-
		     ance with language	standards.

	     -Os     Like -O2 with extra optimizations to reduce code size.

	     -Oz     Like -Os (and thus	-O2), but reduces code size further.

	     -O	     Equivalent	to -O2.

	     -O4 and higher
		     Currently equivalent to -O3

     -g	     Generate debug information.  Note that Clang debug	information
	     works best	at -O0.

     -fstandalone-debug	-fno-standalone-debug
	     Clang supports a number of	optimizations to reduce	the size of
	     debug information in the binary. They work	based on the assump-
	     tion that the debug type information can be spread	out over mul-
	     tiple compilation units.  For instance, Clang will	not emit type
	     definitions for types that	are not	needed by a module and could
	     be	replaced with a	forward	declaration.  Further, Clang will only
	     emit type info for	a dynamic C++ class in the module that con-
	     tains the vtable for the class.

	     The -fstandalone-debug option turns off these optimizations.
	     This is useful when working with 3rd-party	libraries that don't
	     come with debug information.  This	is the default on Darwin.
	     Note that Clang will never	emit type information for types	that
	     are not referenced	at all by the program.

	     Enable generation of unwind information, this allows exceptions
	     to	be thrown through Clang	compiled stack frames.	This is	on by
	     default in	x86-64.

	     Generate code to catch integer overflow errors.  Signed integer
	     overflow is undefined in C, with this flag, extra code is gener-
	     ated to detect this and abort when	it happens.

	     This flag sets the	default	visibility level.

	     This flag specifies that variables	without	initializers get com-
	     mon linkage.  It can be disabled with -fno-common.

	     Set the default thread-local storage (TLS)	model to use for
	     thread-local variables. Valid values are: "global-dynamic",
	     "local-dynamic", "initial-exec" and "local-exec". The default is
	     "global-dynamic". The default model can be	overridden with	the
	     tls_model attribute. The compiler will try	to choose a more effi-
	     cient model if possible.

     -flto -emit-llvm
	     Generate output files in LLVM formats, suitable for link time
	     optimization. When	used with -S this generates LLVM intermediate
	     language assembly files, otherwise	this generates LLVM bitcode
	     format object files (which	may be passed to the linker depending
	     on	the stage selection options).

   Driver Options
     -###    Print (but	do not run) the	commands to run	for this compilation.

     --help  Display available options.

	     Don't emit	warning	for unused driver arguments.

	     Pass the comma separated arguments	in args	to the assembler.

	     Pass the comma separated arguments	in args	to the linker.

	     Pass the comma separated arguments	in args	to the preprocessor.

     -Xanalyzer	arg
	     Pass arg to the static analyzer.

     -Xassembler arg
	     Pass arg to the assembler.

     -Xlinker arg
	     Pass arg to the linker.

     -Xpreprocessor arg
	     Pass arg to the preprocessor.

     -o	file
	     Write output to file.

	     Print the full library path of file.

	     Print the library path for	"libgcc.a".

	     Print the full program path of name.

	     Print the paths used for finding libraries	and programs.

	     Save intermediate compilation results.

     -integrated-as -no-integrated-as
	     Used to enable and	disable, respectively, the use of the inte-
	     grated assembler. Whether the integrated assembler	is on by
	     default is	target dependent.

     -time   Time individual commands.

	     Print timing summary of each stage	of compilation.

     -v	     Show commands to run and use verbose output.

   Diagnostics Options
     -fshow-column -fshow-source-location -fcaret-diagnostics
	     -fdiagnostics-fixit-info -fdiagnostics-parseable-fixits
	     -fdiagnostics-print-source-range-info -fprint-source-range-info
	     -fdiagnostics-show-option -fmessage-length
	     These options control how Clang prints out	information about
	     diagnostics (errors and warnings).	 Please	see the	Clang User's
	     Manual for	more information.

   Preprocessor	Options
	     Adds an implicit #define into the predefines buffer which is read
	     before the	source file is preprocessed.

	     Adds an implicit #undef into the predefines buffer	which is read
	     before the	source file is preprocessed.

     -include filename
	     Adds an implicit #include into the	predefines buffer which	is
	     read before the source file is preprocessed.

	     Add the specified directory to the	search path for	include	files.

	     Add the specified directory to the	search path for	framework
	     include files.

	     Do	not search the standard	system directories or compiler builtin
	     directories for include files.

	     Do	not search the standard	system directories for include files,
	     but do search compiler builtin include directories.

	     Do	not search clang's builtin directory for include files.

	     These environment variables are checked, in order,	for the	loca-
	     tion to write temporary files used	during the compilation

     CPATH   If	this environment variable is present, it is treated as a
	     delimited list of paths to	be added to the	default	system include
	     path list.	The delimiter is the platform dependent	delimitor, as
	     used in the PATH environment variable.

	     Empty components in the environment variable are ignored.

	     These environment variables specify additional paths, as for
	     CPATH, which are only used	when processing	the appropriate	lan-

	     If	-mmacosx-version-min is	unspecified, the default deployment
	     target is read from this environment variable.  This option only
	     affects darwin targets.

     To	report bugs, please visit .: Most	bug reports
     should include preprocessed source	files (use the -E option) and the full
     output of the compiler, along with	information to reproduce.

      as(1), ld(1)

     Maintained	by the Clang / LLVM Team (

FreeBSD	11.1		       February	25, 2015		  FreeBSD 11.1


Want to link to this manual page? Use this URL:

home | help