Clang Make

May 02, 2021 The IDE is wrong. Clang (and GCC) change behavior based on the name by which it is executed. So clang-12 will act as a C compiler and link the C runtime by default.clang-12 will act as a C compiler and link the C runtime by default. Browse other questions tagged ios cmake clang or ask your own question. The Overflow Blog Vote for Stack Overflow in this year’s Webby Awards!

$ export CC=/usr/bin/clang $ export CXX=/usr/bin/clang $ cmake. The C compiler identification is Clang - The CXX compiler identification is Clang The compiler specific flags can be overridden by putting them into a make override file and pointing the CMAKEUSERMAKERULESOVERRIDE variable to it. Clang is a C, C, and Objective-C compiler which encompasses preprocessing, parsing, optimization, code generation, assembly, and linking. Depending on which high-level mode setting is passed, Clang will stop before doing a full link.

DESCRIPTION¶

clang is a C, C++, and Objective-C compiler which encompassespreprocessing, parsing, optimization, code generation, assembly, and linking.Depending on which high-level mode setting is passed, Clang will stop beforedoing a full link. While Clang is highly integrated, it is important tounderstand the stages of compilation, to understand how to invoke it. Thesestages are:

Driver
The clang executable is actually a small driver which controls the overallexecution of other tools such as the compiler, assembler and linker.Typically you do not need to interact with the driver, but youtransparently use it to run the other tools.
Preprocessing
This stage handles tokenization of the input source file, macro expansion,#include expansion and handling of other preprocessor directives. Theoutput 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 aparse tree. Once in the form of a parse tree, it applies semanticanalysis to compute types for expressions as well and determine whetherthe code is well formed. This stage is responsible for generating most ofthe compiler warnings as well as parse errors. The output of this stage isan “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 foroptimizing 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 codegenerator produces object files directly. This avoids the overhead ofgenerating the “.s” file and of calling the target assembler.

Assembler
This stage runs the target assembler to translate the output of thecompiler into a target object file. The output of this stage is typicallycalled a “.o” file or “object” file.
Linker
This stage runs the target linker to merge multiple object files into anexecutable or dynamic library. The output of this stage is typically calledan “a.out”, “.dylib” or “.so” file.

Clang Static Analyzer

The Clang Static Analyzer is a tool that scans source code to try to find bugsthrough code analysis. This tool uses many parts of Clang and is built intothe same driver. Please see <https://clang-analyzer.llvm.org> for more detailson how to use the static analyzer.

OPTIONS¶

Stage Selection Options¶

-E

Run the preprocessor stage.

-fsyntax-only

Run the preprocessor, parser and type checking stages.

-S

Run the previous stages as well as LLVM generation and optimization stagesand 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 thelinker is run to combine the results into an executable or shared library.

Language Selection and Mode Options¶

-x <language>

Treat subsequent input files as having type language.

-std=<standard>

Specify the language standard to compile for.

Supported values for the C language are:

c90
ISO C 1990
ISO C 1990 with amendment 1
gnu90
iso9899:1999
ISO C 1999 with GNU extensions
iso9899:2011
ISO C 2011 with GNU extensions
iso9899:2017
ISO C 2017 with GNU extensions

The default C language standard is gnu17, except on PS4, where it isgnu99.

Supported values for the C++ language are:

c++03
gnu++03
ISO C++ 2011 with amendments
ISO C++ 2011 with amendments and GNU extensions
ISO C++ 2014 with amendments
ISO C++ 2014 with amendments and GNU extensions
ISO C++ 2017 with amendments
ISO C++ 2017 with amendments and GNU extensions
Working draft for ISO C++ 2020
Working draft for ISO C++ 2020 with GNU extensions

The default C++ language standard is gnu++14.

Clang Make It Work

Supported values for the OpenCL language are:

OpenCL 1.0
OpenCL 1.1
OpenCL 1.2
OpenCL 2.0

The default OpenCL language standard is cl1.0.

Supported values for the CUDA language are:

NVIDIA CUDA(tm)
-stdlib=<library>

Specify the C++ standard library to use; supported options are libstdc++ andlibc++. If not specified, platform default will be used.

-rtlib=<library>

Specify the compiler runtime library to use; supported options are libgcc andcompiler-rt. If not specified, platform default will be used.

-ansi

Same as -std=c89.

-ObjC, -ObjC++

Treat source input files as Objective-C and Object-C++ inputs respectively.

-trigraphs

Enable trigraphs.

-ffreestanding

Indicate that the file should be compiled for a freestanding, not a hosted,environment. Note that it is assumed that a freestanding environment willadditionally provide memcpy, memmove, memset and memcmpimplementations, as these are needed for efficient codegen for many programs.

-fno-builtin

Disable special handling and optimizations of builtin functions likestrlen() and malloc().

-fmath-errno

Indicate that math functions should be treated as updating errno.

-fpascal-strings

Enable support for Pascal-style strings with “pfoo”.

-fms-extensions

Enable support for Microsoft extensions.

-fmsc-version=

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

-fborland-extensions

Enable support for Borland extensions.

-fwritable-strings

Clang Makefile Example

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

-flax-vector-conversions, -flax-vector-conversions=<kind>, -fno-lax-vector-conversions

Allow loose type checking rules for implicit vector conversions.Possible values of <kind>:

  • none: allow no implicit conversions between vectors
  • integer: allow implicit bitcasts between integer vectors of the sameoverall bit-width
  • all: allow implicit bitcasts between any vectors of the sameoverall bit-width

<kind> defaults to integer if unspecified.

-fblocks

Enable the “Blocks” language feature.

-fobjc-abi-version=version

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

-fobjc-nonfragile-abi-version=<version>

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

-fobjc-nonfragile-abi, -fno-objc-nonfragile-abi

Enable use of the Objective-C non-fragile ABI. On platforms for which this isthe default ABI, it can be disabled with -fno-objc-nonfragile-abi.

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 anumber of cross compilers, or may only support a native target.

-arch <architecture>

Specify the architecture to build for.

-mmacosx-version-min=<version>

When building for macOS, specify the minimum version supported by yourapplication.

-miphoneos-version-min

When building for iPhone OS, specify the minimum version supported by yourapplication.

--print-supported-cpus

Print out a list of supported processors for the given target (specifiedthrough --target=<architecture> or -arch<architecture>). If notarget is specified, the system default target will be used.

-mcpu=?, -mtune=?

Acts as an alias for --print-supported-cpus.

-march=<cpu>

Specify that Clang should generate code for a specific processor familymember and later. For example, if you specify -march=i486, the compiler isallowed 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, -Og, -O, -O4
Clang

Specify which optimization level to use:

-O0 Means “no optimization”: this level compiles the fastest andgenerates the most debuggable code.

-O1 Somewhere between -O0 and -O2.

-O2 Moderate level of optimization which enables mostoptimizations.

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

-Ofast Enables all the optimizations from -O3 alongwith other aggressive optimizations that may violate strict compliance withlanguage standards.

-Os Like -O2 with extra optimizations to reduce codesize.

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

-Og Like -O1. In future versions, this option mightdisable different optimizations in order to improve debuggability.

-O Equivalent to -O1.

-O4 and higher

-g, -gline-tables-only, -gmodules

Control debug information output. Note that Clang debug information worksbest at -O0. When more than one option starting with -g isspecified, the last one wins:

-g Generate debug information.

-gline-tables-only Generate only line table debug information. Thisallows for symbolicated backtraces with inlining information, but does notinclude any information about variables, their locations or types.

-gmodules Generate debug information that contains externalreferences to types defined in Clang modules or precompiled headers insteadof emitting redundant debug type information into every object file. Thisoption transparently switches the Clang module format to object filecontainers that hold the Clang module together with the debug information.When compiling a program that uses Clang modules or precompiled headers,this option produces complete debug information with faster compiletimes and much smaller object files.

This option should not be used when building static libraries fordistribution to other machines because the debug info will containreferences to the module cache on the machine the object files in thelibrary were built on.

-fstandalone-debug -fno-standalone-debug

Clang supports a number of optimizations to reduce the size of debuginformation in the binary. They work based on the assumption that thedebug type information can be spread out over multiple compilation units.For instance, Clang will not emit type definitions for types that are notneeded by a module and could be replaced with a forward declaration.Further, Clang will only emit type info for a dynamic C++ class in themodule that contains 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 withdebug information. This is the default on Darwin. Note that Clang willnever emit type information for types that are not referenced at all by theprogram.

-feliminate-unused-debug-types

By default, Clang does not emit type information for types that are definedbut not used in a program. To retain the debug info for these unused types,the negation -fno-eliminate-unused-debug-types can be used.

-fexceptions

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

-ftrapv

Generate code to catch integer overflow errors. Signed integer overflow isundefined in C. With this flag, extra code is generated to detect this andabort when it happens.

-fvisibility

This flag sets the default visibility level.

-fcommon, -fno-common

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

-ftls-model=<model>

Set the default thread-local storage (TLS) model to use for thread-localvariables. Valid values are: “global-dynamic”, “local-dynamic”,“initial-exec” and “local-exec”. The default is “global-dynamic”. The defaultmodel can be overridden with the tls_model attribute. The compiler will tryto choose a more efficient model if possible.

-flto, -flto=full, -flto=thin, -emit-llvm

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

The default for -flto is “full”, in which theLLVM bitcode is suitable for monolithic Link Time Optimization (LTO), wherethe linker merges all such modules into a single combined module foroptimization. With “thin”, ThinLTOcompilation is invoked instead.

Note

On Darwin, when using -flto along with -g andcompiling and linking in separate steps, you also need to pass-Wl,-object_path_lto,<lto-filename>.o at the linking step to instruct theld64 linker not to delete the temporary object file generated during LinkTime Optimization (this flag is automatically passed to the linker by Clangif compilation and linking are done in a single step). This allows debuggingthe executable as well as generating the .dSYM bundle using dsymutil(1).

Driver Options¶

Clang makefile tutorial
-###

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

--help

Display available options.

-Qunused-arguments

Do not emit any warnings for unused driver arguments.

-Wa,<args>

Pass the comma separated arguments in args to the assembler.

-Wl,<args>

Pass the comma separated arguments in args to the linker.

-Wp,<args>

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-file-name=<file>

Print the full library path of file.

-print-libgcc-file-name

Print the library path for the currently used compiler runtime library(“libgcc.a” or “libclang_rt.builtins.*.a”).

-print-prog-name=<name>

Print the full program path of name.

-print-search-dirs

Print the paths used for finding libraries and programs.

-save-temps

Save intermediate compilation results.

-save-stats, -save-stats=cwd, -save-stats=obj

Save internal code generation (LLVM) statistics to a file in the currentdirectory (-save-stats/”-save-stats=cwd”) or the directoryof the output file (“-save-state=obj”).

-integrated-as, -no-integrated-as

Used to enable and disable, respectively, the use of the integratedassembler. Whether the integrated assembler is on by default is targetdependent.

-time

Time individual commands.

-ftime-report

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¶

-D<macroname>=<value>

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

-U<macroname>

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

-include <filename>

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

-I<directory>

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

-F<directory>

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

-nostdinc

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

-nostdlibinc

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

-nobuiltininc

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

ENVIRONMENT¶

TMPDIR, TEMP, TMP

These environment variables are checked, in order, for the location to writetemporary files used during the compilation process.

CPATH

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

Empty components in the environment variable are ignored.

C_INCLUDE_PATH, OBJC_INCLUDE_PATH, CPLUS_INCLUDE_PATH, OBJCPLUS_INCLUDE_PATH

These environment variables specify additional paths, as for CPATH, which areonly used when processing the appropriate language.

MACOSX_DEPLOYMENT_TARGET

If -mmacosx-version-min is unspecified, the default deploymenttarget is read from this environment variable. This option only affectsDarwin targets.

BUGS¶

To report bugs, please visit <https://bugs.llvm.org/>. Most bug reports shouldinclude preprocessed source files (use the -E option) and the fulloutput of the compiler, along with information to reproduce.

This document covers how to build the Linux kernel with Clang and LLVMutilities.

About¶

The Linux kernel has always traditionally been compiled with GNU toolchainssuch as GCC and binutils. Ongoing work has allowed for Clang and LLVM utilities to beused as viable substitutes. Distributions such as Android, ChromeOS, and OpenMandriva use Clang built kernels. LLVM is acollection of toolchain components implemented in terms of C++ objects. Clang is a front-end to LLVM thatsupports C and the GNU C extensions required by the kernel, and is pronounced“klang,” not “see-lang.”

Clang¶

The compiler used can be swapped out via CC= command line argument to make.CC= should be set when selecting a config and during a build.

Cross Compiling¶

A single Clang compiler binary will typically contain all supported backends,which can help simplify cross compiling.

CROSS_COMPILE is not used to prefix the Clang compiler binary, insteadCROSS_COMPILE is used to set a command line flag: --target=<triple>. Forexample:

LLVM Utilities¶

LLVM has substitutes for GNU binutils utilities. Kbuild supports LLVM=1to enable them.

They can be enabled individually. The full list of the parameters:

Currently, the integrated assembler is disabled by default. You can passLLVM_IAS=1 to enable it.

Supported Architectures¶

LLVM does not target all of the architectures that Linux supports andjust because a target is supported in LLVM does not mean that the kernelwill build or work without any issues. Below is a general summary ofarchitectures that currently work with CC=clang or LLVM=1. Levelof support corresponds to “S” values in the MAINTAINERS files. If anarchitecture is not present, it either means that LLVM does not targetit or there are known issues. Using the latest stable version of LLVM oreven the development tree will generally yield the best results.An architecture’s defconfig is generally expected to work well,certain configurations may have problems that have not been uncoveredyet. Bug reports are always welcome at the issue tracker below!

Clang Make It Easy

Architecture

Level of support

make command

arm

Supported

LLVM=1

arm64

Supported

LLVM=1

mips

Maintained

CC=clang

powerpc

Maintained

CC=clang

riscv

Maintained

CC=clang

s390

Maintained

CC=clang

x86

Supported

LLVM=1

Getting Help¶

Clang Make_unique

  • Mailing List: <clang-built-linux@googlegroups.com>

  • IRC: #clangbuiltlinux on chat.freenode.net

  • Telegram: @ClangBuiltLinux

Getting LLVM¶