[www-releases] r336152 - Add 6.0.1 docs
Tom Stellard via llvm-commits
llvm-commits at lists.llvm.org
Mon Jul 2 16:21:47 PDT 2018
Added: www-releases/trunk/6.0.1/tools/clang/docs/AutomaticReferenceCounting.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/6.0.1/tools/clang/docs/AutomaticReferenceCounting.html?rev=336152&view=auto
==============================================================================
--- www-releases/trunk/6.0.1/tools/clang/docs/AutomaticReferenceCounting.html (added)
+++ www-releases/trunk/6.0.1/tools/clang/docs/AutomaticReferenceCounting.html Mon Jul 2 16:21:43 2018
@@ -0,0 +1,2087 @@
+
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+ <title>Objective-C Automatic Reference Counting (ARC) — Clang 6 documentation</title>
+
+ <link rel="stylesheet" href="_static/haiku.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+ <link rel="stylesheet" href="_static/print.css" type="text/css" />
+
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: '',
+ VERSION: '6',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true
+ };
+ </script>
+ <script type="text/javascript" src="_static/jquery.js"></script>
+ <script type="text/javascript" src="_static/underscore.js"></script>
+ <script type="text/javascript" src="_static/doctools.js"></script>
+ <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+ <script type="text/javascript" src="_static/theme_extras.js"></script>
+ <link rel="top" title="Clang 6 documentation" href="index.html" />
+ <link rel="up" title="Clang Language Extensions" href="LanguageExtensions.html" />
+ <link rel="next" title="Clang command line argument reference" href="ClangCommandLineReference.html" />
+ <link rel="prev" title="Block Implementation Specification" href="Block-ABI-Apple.html" />
+ </head>
+ <body>
+ <div class="header"><h1 class="heading"><a href="index.html">
+ <span>Clang 6 documentation</span></a></h1>
+ <h2 class="heading"><span>Objective-C Automatic Reference Counting (ARC)</span></h2>
+ </div>
+ <div class="topnav">
+
+ <p>
+ « <a href="Block-ABI-Apple.html">Block Implementation Specification</a>
+ ::
+ <a class="uplink" href="index.html">Contents</a>
+ ::
+ <a href="ClangCommandLineReference.html">Clang command line argument reference</a> »
+ </p>
+
+ </div>
+ <div class="content">
+
+
+ <style>
+ .arc-term { font-style: italic; font-weight: bold; }
+ .revision { font-style: italic; }
+ .when-revised { font-weight: bold; font-style: normal; }
+
+ /*
+ * Automatic numbering is described in this article:
+ * http://dev.opera.com/articles/view/automatic-numbering-with-css-counters/
+ */
+ /*
+ * Automatic numbering for the TOC.
+ * This is wrong from the semantics point of view, since it is an ordered
+ * list, but uses "ul" tag.
+ */
+ div#contents.contents.local ul {
+ counter-reset: toc-section;
+ list-style-type: none;
+ }
+ div#contents.contents.local ul li {
+ counter-increment: toc-section;
+ background: none; // Remove bullets
+ }
+ div#contents.contents.local ul li a.reference:before {
+ content: counters(toc-section, ".") " ";
+ }
+
+ /* Automatic numbering for the body. */
+ body {
+ counter-reset: section subsection subsubsection;
+ }
+ .section h2 {
+ counter-reset: subsection subsubsection;
+ counter-increment: section;
+ }
+ .section h2 a.toc-backref:before {
+ content: counter(section) " ";
+ }
+ .section h3 {
+ counter-reset: subsubsection;
+ counter-increment: subsection;
+ }
+ .section h3 a.toc-backref:before {
+ content: counter(section) "." counter(subsection) " ";
+ }
+ .section h4 {
+ counter-increment: subsubsection;
+ }
+ .section h4 a.toc-backref:before {
+ content: counter(section) "." counter(subsection) "." counter(subsubsection) " ";
+ }
+</style><div class="section" id="objective-c-automatic-reference-counting-arc">
+<h1>Objective-C Automatic Reference Counting (ARC)<a class="headerlink" href="#objective-c-automatic-reference-counting-arc" title="Permalink to this headline">¶</a></h1>
+<div class="contents local topic" id="contents">
+<ul class="simple">
+<li><a class="reference internal" href="#about-this-document" id="id4">About this document</a><ul>
+<li><a class="reference internal" href="#purpose" id="id5">Purpose</a></li>
+<li><a class="reference internal" href="#background" id="id6">Background</a></li>
+<li><a class="reference internal" href="#evolution" id="id7">Evolution</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#general" id="id8">General</a></li>
+<li><a class="reference internal" href="#retainable-object-pointers" id="id9">Retainable object pointers</a><ul>
+<li><a class="reference internal" href="#retain-count-semantics" id="id10">Retain count semantics</a></li>
+<li><a class="reference internal" href="#retainable-object-pointers-as-operands-and-arguments" id="id11">Retainable object pointers as operands and arguments</a><ul>
+<li><a class="reference internal" href="#consumed-parameters" id="id12">Consumed parameters</a></li>
+<li><a class="reference internal" href="#retained-return-values" id="id13">Retained return values</a></li>
+<li><a class="reference internal" href="#unretained-return-values" id="id14">Unretained return values</a></li>
+<li><a class="reference internal" href="#bridged-casts" id="id15">Bridged casts</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#restrictions" id="id16">Restrictions</a><ul>
+<li><a class="reference internal" href="#conversion-of-retainable-object-pointers" id="id17">Conversion of retainable object pointers</a></li>
+<li><a class="reference internal" href="#conversion-to-retainable-object-pointer-type-of-expressions-with-known-semantics" id="id18">Conversion to retainable object pointer type of expressions with known semantics</a></li>
+<li><a class="reference internal" href="#conversion-from-retainable-object-pointer-type-in-certain-contexts" id="id19">Conversion from retainable object pointer type in certain contexts</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#ownership-qualification" id="id20">Ownership qualification</a><ul>
+<li><a class="reference internal" href="#spelling" id="id21">Spelling</a><ul>
+<li><a class="reference internal" href="#property-declarations" id="id22">Property declarations</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#semantics" id="id23">Semantics</a></li>
+<li><a class="reference internal" href="#arc-ownership-restrictions" id="id24">Restrictions</a><ul>
+<li><a class="reference internal" href="#weak-unavailable-types" id="id25">Weak-unavailable types</a></li>
+<li><a class="reference internal" href="#storage-duration-of-autoreleasing-objects" id="id26">Storage duration of <tt class="docutils literal"><span class="pre">__autoreleasing</span></tt> objects</a></li>
+<li><a class="reference internal" href="#conversion-of-pointers-to-ownership-qualified-types" id="id27">Conversion of pointers to ownership-qualified types</a></li>
+<li><a class="reference internal" href="#passing-to-an-out-parameter-by-writeback" id="id28">Passing to an out parameter by writeback</a></li>
+<li><a class="reference internal" href="#ownership-qualified-fields-of-structs-and-unions" id="id29">Ownership-qualified fields of structs and unions</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#ownership-inference" id="id30">Ownership inference</a><ul>
+<li><a class="reference internal" href="#objects" id="id31">Objects</a></li>
+<li><a class="reference internal" href="#indirect-parameters" id="id32">Indirect parameters</a></li>
+<li><a class="reference internal" href="#template-arguments" id="id33">Template arguments</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#method-families" id="id34">Method families</a><ul>
+<li><a class="reference internal" href="#explicit-method-family-control" id="id35">Explicit method family control</a></li>
+<li><a class="reference internal" href="#semantics-of-method-families" id="id36">Semantics of method families</a><ul>
+<li><a class="reference internal" href="#semantics-of-init" id="id37">Semantics of <tt class="docutils literal"><span class="pre">init</span></tt></a></li>
+<li><a class="reference internal" href="#related-result-types" id="id38">Related result types</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#optimization" id="id39">Optimization</a><ul>
+<li><a class="reference internal" href="#object-liveness" id="id40">Object liveness</a></li>
+<li><a class="reference internal" href="#no-object-lifetime-extension" id="id41">No object lifetime extension</a></li>
+<li><a class="reference internal" href="#precise-lifetime-semantics" id="id42">Precise lifetime semantics</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#miscellaneous" id="id43">Miscellaneous</a><ul>
+<li><a class="reference internal" href="#special-methods" id="id44">Special methods</a><ul>
+<li><a class="reference internal" href="#memory-management-methods" id="id45">Memory management methods</a></li>
+<li><a class="reference internal" href="#dealloc" id="id46"><tt class="docutils literal"><span class="pre">dealloc</span></tt></a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#autoreleasepool" id="id47"><tt class="docutils literal"><span class="pre">@autoreleasepool</span></tt></a></li>
+<li><a class="reference internal" href="#self" id="id48"><tt class="docutils literal"><span class="pre">self</span></tt></a></li>
+<li><a class="reference internal" href="#fast-enumeration-iteration-variables" id="id49">Fast enumeration iteration variables</a></li>
+<li><a class="reference internal" href="#blocks" id="id50">Blocks</a></li>
+<li><a class="reference internal" href="#exceptions" id="id51">Exceptions</a></li>
+<li><a class="reference internal" href="#interior-pointers" id="id52">Interior pointers</a></li>
+<li><a class="reference internal" href="#c-retainable-pointer-types" id="id53">C retainable pointer types</a><ul>
+<li><a class="reference internal" href="#auditing-of-c-retainable-pointer-interfaces" id="id54">Auditing of C retainable pointer interfaces</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#runtime-support" id="id55">Runtime support</a><ul>
+<li><a class="reference internal" href="#arc-runtime-objc-autorelease" id="id56"><tt class="docutils literal"><span class="pre">id</span> <span class="pre">objc_autorelease(id</span> <span class="pre">value);</span></tt></a></li>
+<li><a class="reference internal" href="#void-objc-autoreleasepoolpop-void-pool" id="id57"><tt class="docutils literal"><span class="pre">void</span> <span class="pre">objc_autoreleasePoolPop(void</span> <span class="pre">*pool);</span></tt></a></li>
+<li><a class="reference internal" href="#void-objc-autoreleasepoolpush-void" id="id58"><tt class="docutils literal"><span class="pre">void</span> <span class="pre">*objc_autoreleasePoolPush(void);</span></tt></a></li>
+<li><a class="reference internal" href="#arc-runtime-objc-autoreleasereturnvalue" id="id59"><tt class="docutils literal"><span class="pre">id</span> <span class="pre">objc_autoreleaseReturnValue(id</span> <span class="pre">value);</span></tt></a></li>
+<li><a class="reference internal" href="#void-objc-copyweak-id-dest-id-src" id="id60"><tt class="docutils literal"><span class="pre">void</span> <span class="pre">objc_copyWeak(id</span> <span class="pre">*dest,</span> <span class="pre">id</span> <span class="pre">*src);</span></tt></a></li>
+<li><a class="reference internal" href="#void-objc-destroyweak-id-object" id="id61"><tt class="docutils literal"><span class="pre">void</span> <span class="pre">objc_destroyWeak(id</span> <span class="pre">*object);</span></tt></a></li>
+<li><a class="reference internal" href="#arc-runtime-objc-initweak" id="id62"><tt class="docutils literal"><span class="pre">id</span> <span class="pre">objc_initWeak(id</span> <span class="pre">*object,</span> <span class="pre">id</span> <span class="pre">value);</span></tt></a></li>
+<li><a class="reference internal" href="#arc-runtime-objc-loadweak" id="id63"><tt class="docutils literal"><span class="pre">id</span> <span class="pre">objc_loadWeak(id</span> <span class="pre">*object);</span></tt></a></li>
+<li><a class="reference internal" href="#arc-runtime-objc-loadweakretained" id="id64"><tt class="docutils literal"><span class="pre">id</span> <span class="pre">objc_loadWeakRetained(id</span> <span class="pre">*object);</span></tt></a></li>
+<li><a class="reference internal" href="#void-objc-moveweak-id-dest-id-src" id="id65"><tt class="docutils literal"><span class="pre">void</span> <span class="pre">objc_moveWeak(id</span> <span class="pre">*dest,</span> <span class="pre">id</span> <span class="pre">*src);</span></tt></a></li>
+<li><a class="reference internal" href="#void-objc-release-id-value" id="id66"><tt class="docutils literal"><span class="pre">void</span> <span class="pre">objc_release(id</span> <span class="pre">value);</span></tt></a></li>
+<li><a class="reference internal" href="#arc-runtime-objc-retain" id="id67"><tt class="docutils literal"><span class="pre">id</span> <span class="pre">objc_retain(id</span> <span class="pre">value);</span></tt></a></li>
+<li><a class="reference internal" href="#arc-runtime-objc-retainautorelease" id="id68"><tt class="docutils literal"><span class="pre">id</span> <span class="pre">objc_retainAutorelease(id</span> <span class="pre">value);</span></tt></a></li>
+<li><a class="reference internal" href="#arc-runtime-objc-retainautoreleasereturnvalue" id="id69"><tt class="docutils literal"><span class="pre">id</span> <span class="pre">objc_retainAutoreleaseReturnValue(id</span> <span class="pre">value);</span></tt></a></li>
+<li><a class="reference internal" href="#arc-runtime-objc-retainautoreleasedreturnvalue" id="id70"><tt class="docutils literal"><span class="pre">id</span> <span class="pre">objc_retainAutoreleasedReturnValue(id</span> <span class="pre">value);</span></tt></a></li>
+<li><a class="reference internal" href="#arc-runtime-objc-retainblock" id="id71"><tt class="docutils literal"><span class="pre">id</span> <span class="pre">objc_retainBlock(id</span> <span class="pre">value);</span></tt></a></li>
+<li><a class="reference internal" href="#arc-runtime-objc-storestrong" id="id72"><tt class="docutils literal"><span class="pre">id</span> <span class="pre">objc_storeStrong(id</span> <span class="pre">*object,</span> <span class="pre">id</span> <span class="pre">value);</span></tt></a></li>
+<li><a class="reference internal" href="#arc-runtime-objc-storeweak" id="id73"><tt class="docutils literal"><span class="pre">id</span> <span class="pre">objc_storeWeak(id</span> <span class="pre">*object,</span> <span class="pre">id</span> <span class="pre">value);</span></tt></a></li>
+</ul>
+</li>
+</ul>
+</div>
+<div class="section" id="about-this-document">
+<span id="arc-meta"></span><h2><a class="toc-backref" href="#id4">About this document</a><a class="headerlink" href="#about-this-document" title="Permalink to this headline">¶</a></h2>
+<div class="section" id="purpose">
+<span id="arc-meta-purpose"></span><h3><a class="toc-backref" href="#id5">Purpose</a><a class="headerlink" href="#purpose" title="Permalink to this headline">¶</a></h3>
+<p>The first and primary purpose of this document is to serve as a complete
+technical specification of Automatic Reference Counting. Given a core
+Objective-C compiler and runtime, it should be possible to write a compiler and
+runtime which implements these new semantics.</p>
+<p>The secondary purpose is to act as a rationale for why ARC was designed in this
+way. This should remain tightly focused on the technical design and should not
+stray into marketing speculation.</p>
+</div>
+<div class="section" id="background">
+<span id="arc-meta-background"></span><h3><a class="toc-backref" href="#id6">Background</a><a class="headerlink" href="#background" title="Permalink to this headline">¶</a></h3>
+<p>This document assumes a basic familiarity with C.</p>
+<p><span class="arc-term">Blocks</span> are a C language extension for creating anonymous functions.
+Users interact with and transfer block objects using <span class="arc-term">block
+pointers</span>, which are represented like a normal pointer. A block may capture
+values from local variables; when this occurs, memory must be dynamically
+allocated. The initial allocation is done on the stack, but the runtime
+provides a <tt class="docutils literal"><span class="pre">Block_copy</span></tt> function which, given a block pointer, either copies
+the underlying block object to the heap, setting its reference count to 1 and
+returning the new block pointer, or (if the block object is already on the
+heap) increases its reference count by 1. The paired function is
+<tt class="docutils literal"><span class="pre">Block_release</span></tt>, which decreases the reference count by 1 and destroys the
+object if the count reaches zero and is on the heap.</p>
+<p>Objective-C is a set of language extensions, significant enough to be
+considered a different language. It is a strict superset of C. The extensions
+can also be imposed on C++, producing a language called Objective-C++. The
+primary feature is a single-inheritance object system; we briefly describe the
+modern dialect.</p>
+<p>Objective-C defines a new type kind, collectively called the <span class="arc-term">object
+pointer types</span>. This kind has two notable builtin members, <tt class="docutils literal"><span class="pre">id</span></tt> and
+<tt class="docutils literal"><span class="pre">Class</span></tt>; <tt class="docutils literal"><span class="pre">id</span></tt> is the final supertype of all object pointers. The validity
+of conversions between object pointer types is not checked at runtime. Users
+may define <span class="arc-term">classes</span>; each class is a type, and the pointer to that
+type is an object pointer type. A class may have a superclass; its pointer
+type is a subtype of its superclass’s pointer type. A class has a set of
+<span class="arc-term">ivars</span>, fields which appear on all instances of that class. For
+every class <em>T</em> there’s an associated metaclass; it has no fields, its
+superclass is the metaclass of <em>T</em>‘s superclass, and its metaclass is a global
+class. Every class has a global object whose class is the class’s metaclass;
+metaclasses have no associated type, so pointers to this object have type
+<tt class="docutils literal"><span class="pre">Class</span></tt>.</p>
+<p>A class declaration (<tt class="docutils literal"><span class="pre">@interface</span></tt>) declares a set of <span class="arc-term">methods</span>. A
+method has a return type, a list of argument types, and a <span class="arc-term">selector</span>:
+a name like <tt class="docutils literal"><span class="pre">foo:bar:baz:</span></tt>, where the number of colons corresponds to the
+number of formal arguments. A method may be an instance method, in which case
+it can be invoked on objects of the class, or a class method, in which case it
+can be invoked on objects of the metaclass. A method may be invoked by
+providing an object (called the <span class="arc-term">receiver</span>) and a list of formal
+arguments interspersed with the selector, like so:</p>
+<div class="highlight-objc"><div class="highlight"><pre><span class="p">[</span><span class="n">receiver</span> <span class="nl">foo:</span> <span class="n">fooArg</span> <span class="nl">bar:</span> <span class="n">barArg</span> <span class="nl">baz:</span> <span class="n">bazArg</span><span class="p">]</span>
+</pre></div>
+</div>
+<p>This looks in the dynamic class of the receiver for a method with this name,
+then in that class’s superclass, etc., until it finds something it can execute.
+The receiver “expression” may also be the name of a class, in which case the
+actual receiver is the class object for that class, or (within method
+definitions) it may be <tt class="docutils literal"><span class="pre">super</span></tt>, in which case the lookup algorithm starts
+with the static superclass instead of the dynamic class. The actual methods
+dynamically found in a class are not those declared in the <tt class="docutils literal"><span class="pre">@interface</span></tt>, but
+those defined in a separate <tt class="docutils literal"><span class="pre">@implementation</span></tt> declaration; however, when
+compiling a call, typechecking is done based on the methods declared in the
+<tt class="docutils literal"><span class="pre">@interface</span></tt>.</p>
+<p>Method declarations may also be grouped into <span class="arc-term">protocols</span>, which are not
+inherently associated with any class, but which classes may claim to follow.
+Object pointer types may be qualified with additional protocols that the object
+is known to support.</p>
+<p><span class="arc-term">Class extensions</span> are collections of ivars and methods, designed to
+allow a class’s <tt class="docutils literal"><span class="pre">@interface</span></tt> to be split across multiple files; however,
+there is still a primary implementation file which must see the
+<tt class="docutils literal"><span class="pre">@interface</span></tt>s of all class extensions. <span class="arc-term">Categories</span> allow
+methods (but not ivars) to be declared <em>post hoc</em> on an arbitrary class; the
+methods in the category’s <tt class="docutils literal"><span class="pre">@implementation</span></tt> will be dynamically added to that
+class’s method tables which the category is loaded at runtime, replacing those
+methods in case of a collision.</p>
+<p>In the standard environment, objects are allocated on the heap, and their
+lifetime is manually managed using a reference count. This is done using two
+instance methods which all classes are expected to implement: <tt class="docutils literal"><span class="pre">retain</span></tt>
+increases the object’s reference count by 1, whereas <tt class="docutils literal"><span class="pre">release</span></tt> decreases it
+by 1 and calls the instance method <tt class="docutils literal"><span class="pre">dealloc</span></tt> if the count reaches 0. To
+simplify certain operations, there is also an <span class="arc-term">autorelease pool</span>, a
+thread-local list of objects to call <tt class="docutils literal"><span class="pre">release</span></tt> on later; an object can be
+added to this pool by calling <tt class="docutils literal"><span class="pre">autorelease</span></tt> on it.</p>
+<p>Block pointers may be converted to type <tt class="docutils literal"><span class="pre">id</span></tt>; block objects are laid out in a
+way that makes them compatible with Objective-C objects. There is a builtin
+class that all block objects are considered to be objects of; this class
+implements <tt class="docutils literal"><span class="pre">retain</span></tt> by adjusting the reference count, not by calling
+<tt class="docutils literal"><span class="pre">Block_copy</span></tt>.</p>
+</div>
+<div class="section" id="evolution">
+<span id="arc-meta-evolution"></span><h3><a class="toc-backref" href="#id7">Evolution</a><a class="headerlink" href="#evolution" title="Permalink to this headline">¶</a></h3>
+<p>ARC is under continual evolution, and this document must be updated as the
+language progresses.</p>
+<p>If a change increases the expressiveness of the language, for example by
+lifting a restriction or by adding new syntax, the change will be annotated
+with a revision marker, like so:</p>
+<blockquote>
+<div>ARC applies to Objective-C pointer types, block pointer types, and
+<span class="when-revised">[beginning Apple 8.0, LLVM 3.8]</span> <span class="revision">BPTRs declared
+within</span> <tt class="docutils literal"><span class="pre">extern</span> <span class="pre">"BCPL"</span></tt> blocks.</div></blockquote>
+<p>For now, it is sensible to version this document by the releases of its sole
+implementation (and its host project), clang. “LLVM X.Y” refers to an
+open-source release of clang from the LLVM project. “Apple X.Y” refers to an
+Apple-provided release of the Apple LLVM Compiler. Other organizations that
+prepare their own, separately-versioned clang releases and wish to maintain
+similar information in this document should send requests to cfe-dev.</p>
+<p>If a change decreases the expressiveness of the language, for example by
+imposing a new restriction, this should be taken as an oversight in the
+original specification and something to be avoided in all versions. Such
+changes are generally to be avoided.</p>
+</div>
+</div>
+<div class="section" id="general">
+<span id="arc-general"></span><h2><a class="toc-backref" href="#id8">General</a><a class="headerlink" href="#general" title="Permalink to this headline">¶</a></h2>
+<p>Automatic Reference Counting implements automatic memory management for
+Objective-C objects and blocks, freeing the programmer from the need to
+explicitly insert retains and releases. It does not provide a cycle collector;
+users must explicitly manage the lifetime of their objects, breaking cycles
+manually or with weak or unsafe references.</p>
+<p>ARC may be explicitly enabled with the compiler flag <tt class="docutils literal"><span class="pre">-fobjc-arc</span></tt>. It may
+also be explicitly disabled with the compiler flag <tt class="docutils literal"><span class="pre">-fno-objc-arc</span></tt>. The last
+of these two flags appearing on the compile line “wins”.</p>
+<p>If ARC is enabled, <tt class="docutils literal"><span class="pre">__has_feature(objc_arc)</span></tt> will expand to 1 in the
+preprocessor. For more information about <tt class="docutils literal"><span class="pre">__has_feature</span></tt>, see the
+<a class="reference internal" href="LanguageExtensions.html#langext-has-feature-has-extension"><em>language extensions</em></a> document.</p>
+</div>
+<div class="section" id="retainable-object-pointers">
+<span id="arc-objects"></span><h2><a class="toc-backref" href="#id9">Retainable object pointers</a><a class="headerlink" href="#retainable-object-pointers" title="Permalink to this headline">¶</a></h2>
+<p>This section describes retainable object pointers, their basic operations, and
+the restrictions imposed on their use under ARC. Note in particular that it
+covers the rules for pointer <em>values</em> (patterns of bits indicating the location
+of a pointed-to object), not pointer <em>objects</em> (locations in memory which store
+pointer values). The rules for objects are covered in the next section.</p>
+<p>A <span class="arc-term">retainable object pointer</span> (or “retainable pointer”) is a value of
+a <span class="arc-term">retainable object pointer type</span> (“retainable type”). There are
+three kinds of retainable object pointer types:</p>
+<ul class="simple">
+<li>block pointers (formed by applying the caret (<tt class="docutils literal"><span class="pre">^</span></tt>) declarator sigil to a
+function type)</li>
+<li>Objective-C object pointers (<tt class="docutils literal"><span class="pre">id</span></tt>, <tt class="docutils literal"><span class="pre">Class</span></tt>, <tt class="docutils literal"><span class="pre">NSFoo*</span></tt>, etc.)</li>
+<li>typedefs marked with <tt class="docutils literal"><span class="pre">__attribute__((NSObject))</span></tt></li>
+</ul>
+<p>Other pointer types, such as <tt class="docutils literal"><span class="pre">int*</span></tt> and <tt class="docutils literal"><span class="pre">CFStringRef</span></tt>, are not subject to
+ARC’s semantics and restrictions.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p>We are not at liberty to require all code to be recompiled with ARC;
+therefore, ARC must interoperate with Objective-C code which manages retains
+and releases manually. In general, there are three requirements in order for
+a compiler-supported reference-count system to provide reliable
+interoperation:</p>
+<ul class="last simple">
+<li>The type system must reliably identify which objects are to be managed. An
+<tt class="docutils literal"><span class="pre">int*</span></tt> might be a pointer to a <tt class="docutils literal"><span class="pre">malloc</span></tt>‘ed array, or it might be an
+interior pointer to such an array, or it might point to some field or local
+variable. In contrast, values of the retainable object pointer types are
+never interior.</li>
+<li>The type system must reliably indicate how to manage objects of a type.
+This usually means that the type must imply a procedure for incrementing
+and decrementing retain counts. Supporting single-ownership objects
+requires a lot more explicit mediation in the language.</li>
+<li>There must be reliable conventions for whether and when “ownership” is
+passed between caller and callee, for both arguments and return values.
+Objective-C methods follow such a convention very reliably, at least for
+system libraries on Mac OS X, and functions always pass objects at +0. The
+C-based APIs for Core Foundation objects, on the other hand, have much more
+varied transfer semantics.</li>
+</ul>
+</div>
+<p>The use of <tt class="docutils literal"><span class="pre">__attribute__((NSObject))</span></tt> typedefs is not recommended. If it’s
+absolutely necessary to use this attribute, be very explicit about using the
+typedef, and do not assume that it will be preserved by language features like
+<tt class="docutils literal"><span class="pre">__typeof</span></tt> and C++ template argument substitution.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">Any compiler operation which incidentally strips type “sugar” from a type
+will yield a type without the attribute, which may result in unexpected
+behavior.</p>
+</div>
+<div class="section" id="retain-count-semantics">
+<span id="arc-objects-retains"></span><h3><a class="toc-backref" href="#id10">Retain count semantics</a><a class="headerlink" href="#retain-count-semantics" title="Permalink to this headline">¶</a></h3>
+<p>A retainable object pointer is either a <span class="arc-term">null pointer</span> or a pointer
+to a valid object. Furthermore, if it has block pointer type and is not
+<tt class="docutils literal"><span class="pre">null</span></tt> then it must actually be a pointer to a block object, and if it has
+<tt class="docutils literal"><span class="pre">Class</span></tt> type (possibly protocol-qualified) then it must actually be a pointer
+to a class object. Otherwise ARC does not enforce the Objective-C type system
+as long as the implementing methods follow the signature of the static type.
+It is undefined behavior if ARC is exposed to an invalid pointer.</p>
+<p>For ARC’s purposes, a valid object is one with “well-behaved” retaining
+operations. Specifically, the object must be laid out such that the
+Objective-C message send machinery can successfully send it the following
+messages:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">retain</span></tt>, taking no arguments and returning a pointer to the object.</li>
+<li><tt class="docutils literal"><span class="pre">release</span></tt>, taking no arguments and returning <tt class="docutils literal"><span class="pre">void</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">autorelease</span></tt>, taking no arguments and returning a pointer to the object.</li>
+</ul>
+<p>The behavior of these methods is constrained in the following ways. The term
+<span class="arc-term">high-level semantics</span> is an intentionally vague term; the intent is
+that programmers must implement these methods in a way such that the compiler,
+modifying code in ways it deems safe according to these constraints, will not
+violate their requirements. For example, if the user puts logging statements
+in <tt class="docutils literal"><span class="pre">retain</span></tt>, they should not be surprised if those statements are executed
+more or less often depending on optimization settings. These constraints are
+not exhaustive of the optimization opportunities: values held in local
+variables are subject to additional restrictions, described later in this
+document.</p>
+<p>It is undefined behavior if a computation history featuring a send of
+<tt class="docutils literal"><span class="pre">retain</span></tt> followed by a send of <tt class="docutils literal"><span class="pre">release</span></tt> to the same object, with no
+intervening <tt class="docutils literal"><span class="pre">release</span></tt> on that object, is not equivalent under the high-level
+semantics to a computation history in which these sends are removed. Note that
+this implies that these methods may not raise exceptions.</p>
+<p>It is undefined behavior if a computation history features any use whatsoever
+of an object following the completion of a send of <tt class="docutils literal"><span class="pre">release</span></tt> that is not
+preceded by a send of <tt class="docutils literal"><span class="pre">retain</span></tt> to the same object.</p>
+<p>The behavior of <tt class="docutils literal"><span class="pre">autorelease</span></tt> must be equivalent to sending <tt class="docutils literal"><span class="pre">release</span></tt> when
+one of the autorelease pools currently in scope is popped. It may not throw an
+exception.</p>
+<p>When the semantics call for performing one of these operations on a retainable
+object pointer, if that pointer is <tt class="docutils literal"><span class="pre">null</span></tt> then the effect is a no-op.</p>
+<p>All of the semantics described in this document are subject to additional
+<a class="reference internal" href="#arc-optimization"><em>optimization rules</em></a> which permit the removal or
+optimization of operations based on local knowledge of data flow. The
+semantics describe the high-level behaviors that the compiler implements, not
+an exact sequence of operations that a program will be compiled into.</p>
+</div>
+<div class="section" id="retainable-object-pointers-as-operands-and-arguments">
+<span id="arc-objects-operands"></span><h3><a class="toc-backref" href="#id11">Retainable object pointers as operands and arguments</a><a class="headerlink" href="#retainable-object-pointers-as-operands-and-arguments" title="Permalink to this headline">¶</a></h3>
+<p>In general, ARC does not perform retain or release operations when simply using
+a retainable object pointer as an operand within an expression. This includes:</p>
+<ul class="simple">
+<li>loading a retainable pointer from an object with non-weak <a class="reference internal" href="#arc-ownership"><em>ownership</em></a>,</li>
+<li>passing a retainable pointer as an argument to a function or method, and</li>
+<li>receiving a retainable pointer as the result of a function or method call.</li>
+</ul>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">While this might seem uncontroversial, it is actually unsafe when multiple
+expressions are evaluated in “parallel”, as with binary operators and calls,
+because (for example) one expression might load from an object while another
+writes to it. However, C and C++ already call this undefined behavior
+because the evaluations are unsequenced, and ARC simply exploits that here to
+avoid needing to retain arguments across a large number of calls.</p>
+</div>
+<p>The remainder of this section describes exceptions to these rules, how those
+exceptions are detected, and what those exceptions imply semantically.</p>
+<div class="section" id="consumed-parameters">
+<span id="arc-objects-operands-consumed"></span><h4><a class="toc-backref" href="#id12">Consumed parameters</a><a class="headerlink" href="#consumed-parameters" title="Permalink to this headline">¶</a></h4>
+<p>A function or method parameter of retainable object pointer type may be marked
+as <span class="arc-term">consumed</span>, signifying that the callee expects to take ownership
+of a +1 retain count. This is done by adding the <tt class="docutils literal"><span class="pre">ns_consumed</span></tt> attribute to
+the parameter declaration, like so:</p>
+<div class="highlight-objc"><div class="highlight"><pre><span class="kt">void</span> <span class="n">foo</span><span class="p">(</span><span class="n">__attribute</span><span class="p">((</span><span class="n">ns_consumed</span><span class="p">))</span> <span class="kt">id</span> <span class="n">x</span><span class="p">);</span>
+<span class="o">-</span> <span class="p">(</span><span class="kt">void</span><span class="p">)</span> <span class="nl">foo:</span> <span class="p">(</span><span class="kt">id</span><span class="p">)</span> <span class="n">__attribute</span><span class="p">((</span><span class="n">ns_consumed</span><span class="p">))</span> <span class="n">x</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>This attribute is part of the type of the function or method, not the type of
+the parameter. It controls only how the argument is passed and received.</p>
+<p>When passing such an argument, ARC retains the argument prior to making the
+call.</p>
+<p>When receiving such an argument, ARC releases the argument at the end of the
+function, subject to the usual optimizations for local values.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">This formalizes direct transfers of ownership from a caller to a callee. The
+most common scenario here is passing the <tt class="docutils literal"><span class="pre">self</span></tt> parameter to <tt class="docutils literal"><span class="pre">init</span></tt>, but
+it is useful to generalize. Typically, local optimization will remove any
+extra retains and releases: on the caller side the retain will be merged with
+a +1 source, and on the callee side the release will be rolled into the
+initialization of the parameter.</p>
+</div>
+<p>The implicit <tt class="docutils literal"><span class="pre">self</span></tt> parameter of a method may be marked as consumed by adding
+<tt class="docutils literal"><span class="pre">__attribute__((ns_consumes_self))</span></tt> to the method declaration. Methods in
+the <tt class="docutils literal"><span class="pre">init</span></tt> <a class="reference internal" href="#arc-method-families"><em>family</em></a> are treated as if they were
+implicitly marked with this attribute.</p>
+<p>It is undefined behavior if an Objective-C message send to a method with
+<tt class="docutils literal"><span class="pre">ns_consumed</span></tt> parameters (other than self) is made with a null receiver. It
+is undefined behavior if the method to which an Objective-C message send
+statically resolves to has a different set of <tt class="docutils literal"><span class="pre">ns_consumed</span></tt> parameters than
+the method it dynamically resolves to. It is undefined behavior if a block or
+function call is made through a static type with a different set of
+<tt class="docutils literal"><span class="pre">ns_consumed</span></tt> parameters than the implementation of the called block or
+function.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">Consumed parameters with null receiver are a guaranteed leak. Mismatches
+with consumed parameters will cause over-retains or over-releases, depending
+on the direction. The rule about function calls is really just an
+application of the existing C/C++ rule about calling functions through an
+incompatible function type, but it’s useful to state it explicitly.</p>
+</div>
+</div>
+<div class="section" id="retained-return-values">
+<span id="arc-object-operands-retained-return-values"></span><h4><a class="toc-backref" href="#id13">Retained return values</a><a class="headerlink" href="#retained-return-values" title="Permalink to this headline">¶</a></h4>
+<p>A function or method which returns a retainable object pointer type may be
+marked as returning a retained value, signifying that the caller expects to take
+ownership of a +1 retain count. This is done by adding the
+<tt class="docutils literal"><span class="pre">ns_returns_retained</span></tt> attribute to the function or method declaration, like
+so:</p>
+<div class="highlight-objc"><div class="highlight"><pre><span class="kt">id</span> <span class="n">foo</span><span class="p">(</span><span class="kt">void</span><span class="p">)</span> <span class="n">__attribute</span><span class="p">((</span><span class="n">ns_returns_retained</span><span class="p">));</span>
+<span class="o">-</span> <span class="p">(</span><span class="kt">id</span><span class="p">)</span> <span class="n">foo</span> <span class="n">__attribute</span><span class="p">((</span><span class="n">ns_returns_retained</span><span class="p">));</span>
+</pre></div>
+</div>
+<p>This attribute is part of the type of the function or method.</p>
+<p>When returning from such a function or method, ARC retains the value at the
+point of evaluation of the return statement, before leaving all local scopes.</p>
+<p>When receiving a return result from such a function or method, ARC releases the
+value at the end of the full-expression it is contained within, subject to the
+usual optimizations for local values.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">This formalizes direct transfers of ownership from a callee to a caller. The
+most common scenario this models is the retained return from <tt class="docutils literal"><span class="pre">init</span></tt>,
+<tt class="docutils literal"><span class="pre">alloc</span></tt>, <tt class="docutils literal"><span class="pre">new</span></tt>, and <tt class="docutils literal"><span class="pre">copy</span></tt> methods, but there are other cases in the
+frameworks. After optimization there are typically no extra retains and
+releases required.</p>
+</div>
+<p>Methods in the <tt class="docutils literal"><span class="pre">alloc</span></tt>, <tt class="docutils literal"><span class="pre">copy</span></tt>, <tt class="docutils literal"><span class="pre">init</span></tt>, <tt class="docutils literal"><span class="pre">mutableCopy</span></tt>, and <tt class="docutils literal"><span class="pre">new</span></tt>
+<a class="reference internal" href="#arc-method-families"><em>families</em></a> are implicitly marked
+<tt class="docutils literal"><span class="pre">__attribute__((ns_returns_retained))</span></tt>. This may be suppressed by explicitly
+marking the method <tt class="docutils literal"><span class="pre">__attribute__((ns_returns_not_retained))</span></tt>.</p>
+<p>It is undefined behavior if the method to which an Objective-C message send
+statically resolves has different retain semantics on its result from the
+method it dynamically resolves to. It is undefined behavior if a block or
+function call is made through a static type with different retain semantics on
+its result from the implementation of the called block or function.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">Mismatches with returned results will cause over-retains or over-releases,
+depending on the direction. Again, the rule about function calls is really
+just an application of the existing C/C++ rule about calling functions
+through an incompatible function type.</p>
+</div>
+</div>
+<div class="section" id="unretained-return-values">
+<span id="arc-objects-operands-unretained-returns"></span><h4><a class="toc-backref" href="#id14">Unretained return values</a><a class="headerlink" href="#unretained-return-values" title="Permalink to this headline">¶</a></h4>
+<p>A method or function which returns a retainable object type but does not return
+a retained value must ensure that the object is still valid across the return
+boundary.</p>
+<p>When returning from such a function or method, ARC retains the value at the
+point of evaluation of the return statement, then leaves all local scopes, and
+then balances out the retain while ensuring that the value lives across the
+call boundary. In the worst case, this may involve an <tt class="docutils literal"><span class="pre">autorelease</span></tt>, but
+callers must not assume that the value is actually in the autorelease pool.</p>
+<p>ARC performs no extra mandatory work on the caller side, although it may elect
+to do something to shorten the lifetime of the returned value.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">It is common in non-ARC code to not return an autoreleased value; therefore
+the convention does not force either path. It is convenient to not be
+required to do unnecessary retains and autoreleases; this permits
+optimizations such as eliding retain/autoreleases when it can be shown that
+the original pointer will still be valid at the point of return.</p>
+</div>
+<p>A method or function may be marked with
+<tt class="docutils literal"><span class="pre">__attribute__((ns_returns_autoreleased))</span></tt> to indicate that it returns a
+pointer which is guaranteed to be valid at least as long as the innermost
+autorelease pool. There are no additional semantics enforced in the definition
+of such a method; it merely enables optimizations in callers.</p>
+</div>
+<div class="section" id="bridged-casts">
+<span id="arc-objects-operands-casts"></span><h4><a class="toc-backref" href="#id15">Bridged casts</a><a class="headerlink" href="#bridged-casts" title="Permalink to this headline">¶</a></h4>
+<p>A <span class="arc-term">bridged cast</span> is a C-style cast annotated with one of three
+keywords:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">(__bridge</span> <span class="pre">T)</span> <span class="pre">op</span></tt> casts the operand to the destination type <tt class="docutils literal"><span class="pre">T</span></tt>. If
+<tt class="docutils literal"><span class="pre">T</span></tt> is a retainable object pointer type, then <tt class="docutils literal"><span class="pre">op</span></tt> must have a
+non-retainable pointer type. If <tt class="docutils literal"><span class="pre">T</span></tt> is a non-retainable pointer type,
+then <tt class="docutils literal"><span class="pre">op</span></tt> must have a retainable object pointer type. Otherwise the cast
+is ill-formed. There is no transfer of ownership, and ARC inserts no retain
+operations.</li>
+<li><tt class="docutils literal"><span class="pre">(__bridge_retained</span> <span class="pre">T)</span> <span class="pre">op</span></tt> casts the operand, which must have retainable
+object pointer type, to the destination type, which must be a non-retainable
+pointer type. ARC retains the value, subject to the usual optimizations on
+local values, and the recipient is responsible for balancing that +1.</li>
+<li><tt class="docutils literal"><span class="pre">(__bridge_transfer</span> <span class="pre">T)</span> <span class="pre">op</span></tt> casts the operand, which must have
+non-retainable pointer type, to the destination type, which must be a
+retainable object pointer type. ARC will release the value at the end of
+the enclosing full-expression, subject to the usual optimizations on local
+values.</li>
+</ul>
+<p>These casts are required in order to transfer objects in and out of ARC
+control; see the rationale in the section on <a class="reference internal" href="#arc-objects-restrictions-conversion"><em>conversion of retainable
+object pointers</em></a>.</p>
+<p>Using a <tt class="docutils literal"><span class="pre">__bridge_retained</span></tt> or <tt class="docutils literal"><span class="pre">__bridge_transfer</span></tt> cast purely to convince
+ARC to emit an unbalanced retain or release, respectively, is poor form.</p>
+</div>
+</div>
+<div class="section" id="restrictions">
+<span id="arc-objects-restrictions"></span><h3><a class="toc-backref" href="#id16">Restrictions</a><a class="headerlink" href="#restrictions" title="Permalink to this headline">¶</a></h3>
+<div class="section" id="conversion-of-retainable-object-pointers">
+<span id="arc-objects-restrictions-conversion"></span><h4><a class="toc-backref" href="#id17">Conversion of retainable object pointers</a><a class="headerlink" href="#conversion-of-retainable-object-pointers" title="Permalink to this headline">¶</a></h4>
+<p>In general, a program which attempts to implicitly or explicitly convert a
+value of retainable object pointer type to any non-retainable type, or
+vice-versa, is ill-formed. For example, an Objective-C object pointer shall
+not be converted to <tt class="docutils literal"><span class="pre">void*</span></tt>. As an exception, cast to <tt class="docutils literal"><span class="pre">intptr_t</span></tt> is
+allowed because such casts are not transferring ownership. The <a class="reference internal" href="#arc-objects-operands-casts"><em>bridged
+casts</em></a> may be used to perform these conversions
+where necessary.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">We cannot ensure the correct management of the lifetime of objects if they
+may be freely passed around as unmanaged types. The bridged casts are
+provided so that the programmer may explicitly describe whether the cast
+transfers control into or out of ARC.</p>
+</div>
+<p>However, the following exceptions apply.</p>
+</div>
+<div class="section" id="conversion-to-retainable-object-pointer-type-of-expressions-with-known-semantics">
+<span id="arc-objects-restrictions-conversion-with-known-semantics"></span><h4><a class="toc-backref" href="#id18">Conversion to retainable object pointer type of expressions with known semantics</a><a class="headerlink" href="#conversion-to-retainable-object-pointer-type-of-expressions-with-known-semantics" title="Permalink to this headline">¶</a></h4>
+<p><span class="when-revised">[beginning Apple 4.0, LLVM 3.1]</span>
+<span class="revision">These exceptions have been greatly expanded; they previously applied
+only to a much-reduced subset which is difficult to categorize but which
+included null pointers, message sends (under the given rules), and the various
+global constants.</span></p>
+<p>An unbridged conversion to a retainable object pointer type from a type other
+than a retainable object pointer type is ill-formed, as discussed above, unless
+the operand of the cast has a syntactic form which is known retained, known
+unretained, or known retain-agnostic.</p>
+<p>An expression is <span class="arc-term">known retain-agnostic</span> if it is:</p>
+<ul class="simple">
+<li>an Objective-C string literal,</li>
+<li>a load from a <tt class="docutils literal"><span class="pre">const</span></tt> system global variable of <a class="reference internal" href="#arc-misc-c-retainable"><em>C retainable pointer
+type</em></a>, or</li>
+<li>a null pointer constant.</li>
+</ul>
+<p>An expression is <span class="arc-term">known unretained</span> if it is an rvalue of <a class="reference internal" href="#arc-misc-c-retainable"><em>C
+retainable pointer type</em></a> and it is:</p>
+<ul class="simple">
+<li>a direct call to a function, and either that function has the
+<tt class="docutils literal"><span class="pre">cf_returns_not_retained</span></tt> attribute or it is an <a class="reference internal" href="#arc-misc-c-retainable-audit"><em>audited</em></a> function that does not have the
+<tt class="docutils literal"><span class="pre">cf_returns_retained</span></tt> attribute and does not follow the create/copy naming
+convention,</li>
+<li>a message send, and the declared method either has the
+<tt class="docutils literal"><span class="pre">cf_returns_not_retained</span></tt> attribute or it has neither the
+<tt class="docutils literal"><span class="pre">cf_returns_retained</span></tt> attribute nor a <a class="reference internal" href="#arc-method-families"><em>selector family</em></a> that implies a retained result, or</li>
+<li><span class="when-revised">[beginning LLVM 3.6]</span> <span class="revision">a load from a</span> <tt class="docutils literal"><span class="pre">const</span></tt>
+<span class="revision">non-system global variable.</span></li>
+</ul>
+<p>An expression is <span class="arc-term">known retained</span> if it is an rvalue of <a class="reference internal" href="#arc-misc-c-retainable"><em>C
+retainable pointer type</em></a> and it is:</p>
+<ul class="simple">
+<li>a message send, and the declared method either has the
+<tt class="docutils literal"><span class="pre">cf_returns_retained</span></tt> attribute, or it does not have the
+<tt class="docutils literal"><span class="pre">cf_returns_not_retained</span></tt> attribute but it does have a <a class="reference internal" href="#arc-method-families"><em>selector
+family</em></a> that implies a retained result.</li>
+</ul>
+<p>Furthermore:</p>
+<ul class="simple">
+<li>a comma expression is classified according to its right-hand side,</li>
+<li>a statement expression is classified according to its result expression, if
+it has one,</li>
+<li>an lvalue-to-rvalue conversion applied to an Objective-C property lvalue is
+classified according to the underlying message send, and</li>
+<li>a conditional operator is classified according to its second and third
+operands, if they agree in classification, or else the other if one is known
+retain-agnostic.</li>
+</ul>
+<p>If the cast operand is known retained, the conversion is treated as a
+<tt class="docutils literal"><span class="pre">__bridge_transfer</span></tt> cast. If the cast operand is known unretained or known
+retain-agnostic, the conversion is treated as a <tt class="docutils literal"><span class="pre">__bridge</span></tt> cast.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p>Bridging casts are annoying. Absent the ability to completely automate the
+management of CF objects, however, we are left with relatively poor attempts
+to reduce the need for a glut of explicit bridges. Hence these rules.</p>
+<p>We’ve so far consciously refrained from implicitly turning retained CF
+results from function calls into <tt class="docutils literal"><span class="pre">__bridge_transfer</span></tt> casts. The worry is
+that some code patterns — for example, creating a CF value, assigning it
+to an ObjC-typed local, and then calling <tt class="docutils literal"><span class="pre">CFRelease</span></tt> when done — are a
+bit too likely to be accidentally accepted, leading to mysterious behavior.</p>
+<p class="last">For loads from <tt class="docutils literal"><span class="pre">const</span></tt> global variables of <a class="reference internal" href="#arc-misc-c-retainable"><em>C retainable pointer type</em></a>, it is reasonable to assume that global system
+constants were initialitzed with true constants (e.g. string literals), but
+user constants might have been initialized with something dynamically
+allocated, using a global initializer.</p>
+</div>
+</div>
+<div class="section" id="conversion-from-retainable-object-pointer-type-in-certain-contexts">
+<span id="arc-objects-restrictions-conversion-exception-contextual"></span><h4><a class="toc-backref" href="#id19">Conversion from retainable object pointer type in certain contexts</a><a class="headerlink" href="#conversion-from-retainable-object-pointer-type-in-certain-contexts" title="Permalink to this headline">¶</a></h4>
+<p><span class="when-revised">[beginning Apple 4.0, LLVM 3.1]</span></p>
+<p>If an expression of retainable object pointer type is explicitly cast to a
+<a class="reference internal" href="#arc-misc-c-retainable"><em>C retainable pointer type</em></a>, the program is
+ill-formed as discussed above unless the result is immediately used:</p>
+<ul class="simple">
+<li>to initialize a parameter in an Objective-C message send where the parameter
+is not marked with the <tt class="docutils literal"><span class="pre">cf_consumed</span></tt> attribute, or</li>
+<li>to initialize a parameter in a direct call to an
+<a class="reference internal" href="#arc-misc-c-retainable-audit"><em>audited</em></a> function where the parameter is
+not marked with the <tt class="docutils literal"><span class="pre">cf_consumed</span></tt> attribute.</li>
+</ul>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">Consumed parameters are left out because ARC would naturally balance them
+with a retain, which was judged too treacherous. This is in part because
+several of the most common consuming functions are in the <tt class="docutils literal"><span class="pre">Release</span></tt> family,
+and it would be quite unfortunate for explicit releases to be silently
+balanced out in this way.</p>
+</div>
+</div>
+</div>
+</div>
+<div class="section" id="ownership-qualification">
+<span id="arc-ownership"></span><h2><a class="toc-backref" href="#id20">Ownership qualification</a><a class="headerlink" href="#ownership-qualification" title="Permalink to this headline">¶</a></h2>
+<p>This section describes the behavior of <em>objects</em> of retainable object pointer
+type; that is, locations in memory which store retainable object pointers.</p>
+<p>A type is a <span class="arc-term">retainable object owner type</span> if it is a retainable
+object pointer type or an array type whose element type is a retainable object
+owner type.</p>
+<p>An <span class="arc-term">ownership qualifier</span> is a type qualifier which applies only to
+retainable object owner types. An array type is ownership-qualified according
+to its element type, and adding an ownership qualifier to an array type so
+qualifies its element type.</p>
+<p>A program is ill-formed if it attempts to apply an ownership qualifier to a
+type which is already ownership-qualified, even if it is the same qualifier.
+There is a single exception to this rule: an ownership qualifier may be applied
+to a substituted template type parameter, which overrides the ownership
+qualifier provided by the template argument.</p>
+<p>When forming a function type, the result type is adjusted so that any
+top-level ownership qualifier is deleted.</p>
+<p>Except as described under the <a class="reference internal" href="#arc-ownership-inference"><em>inference rules</em></a>,
+a program is ill-formed if it attempts to form a pointer or reference type to a
+retainable object owner type which lacks an ownership qualifier.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">These rules, together with the inference rules, ensure that all objects and
+lvalues of retainable object pointer type have an ownership qualifier. The
+ability to override an ownership qualifier during template substitution is
+required to counteract the <a class="reference internal" href="#arc-ownership-inference-template-arguments"><em>inference of __strong for template type
+arguments</em></a>. Ownership qualifiers
+on return types are dropped because they serve no purpose there except to
+cause spurious problems with overloading and templates.</p>
+</div>
+<p>There are four ownership qualifiers:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">__autoreleasing</span></tt></li>
+<li><tt class="docutils literal"><span class="pre">__strong</span></tt></li>
+<li><tt class="docutils literal"><span class="pre">__unsafe_unretained</span></tt></li>
+<li><tt class="docutils literal"><span class="pre">__weak</span></tt></li>
+</ul>
+<p>A type is <span class="arc-term">nontrivially ownership-qualified</span> if it is qualified with
+<tt class="docutils literal"><span class="pre">__autoreleasing</span></tt>, <tt class="docutils literal"><span class="pre">__strong</span></tt>, or <tt class="docutils literal"><span class="pre">__weak</span></tt>.</p>
+<div class="section" id="spelling">
+<span id="arc-ownership-spelling"></span><h3><a class="toc-backref" href="#id21">Spelling</a><a class="headerlink" href="#spelling" title="Permalink to this headline">¶</a></h3>
+<p>The names of the ownership qualifiers are reserved for the implementation. A
+program may not assume that they are or are not implemented with macros, or
+what those macros expand to.</p>
+<p>An ownership qualifier may be written anywhere that any other type qualifier
+may be written.</p>
+<p>If an ownership qualifier appears in the <em>declaration-specifiers</em>, the
+following rules apply:</p>
+<ul class="simple">
+<li>if the type specifier is a retainable object owner type, the qualifier
+initially applies to that type;</li>
+<li>otherwise, if the outermost non-array declarator is a pointer
+or block pointer declarator, the qualifier initially applies to
+that type;</li>
+<li>otherwise the program is ill-formed.</li>
+<li>If the qualifier is so applied at a position in the declaration
+where the next-innermost declarator is a function declarator, and
+there is an block declarator within that function declarator, then
+the qualifier applies instead to that block declarator and this rule
+is considered afresh beginning from the new position.</li>
+</ul>
+<p>If an ownership qualifier appears on the declarator name, or on the declared
+object, it is applied to the innermost pointer or block-pointer type.</p>
+<p>If an ownership qualifier appears anywhere else in a declarator, it applies to
+the type there.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">Ownership qualifiers are like <tt class="docutils literal"><span class="pre">const</span></tt> and <tt class="docutils literal"><span class="pre">volatile</span></tt> in the sense
+that they may sensibly apply at multiple distinct positions within a
+declarator. However, unlike those qualifiers, there are many
+situations where they are not meaningful, and so we make an effort
+to “move” the qualifier to a place where it will be meaningful. The
+general goal is to allow the programmer to write, say, <tt class="docutils literal"><span class="pre">__strong</span></tt>
+before the entire declaration and have it apply in the leftmost
+sensible place.</p>
+</div>
+<div class="section" id="property-declarations">
+<span id="arc-ownership-spelling-property"></span><h4><a class="toc-backref" href="#id22">Property declarations</a><a class="headerlink" href="#property-declarations" title="Permalink to this headline">¶</a></h4>
+<p>A property of retainable object pointer type may have ownership. If the
+property’s type is ownership-qualified, then the property has that ownership.
+If the property has one of the following modifiers, then the property has the
+corresponding ownership. A property is ill-formed if it has conflicting
+sources of ownership, or if it has redundant ownership modifiers, or if it has
+<tt class="docutils literal"><span class="pre">__autoreleasing</span></tt> ownership.</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">assign</span></tt> implies <tt class="docutils literal"><span class="pre">__unsafe_unretained</span></tt> ownership.</li>
+<li><tt class="docutils literal"><span class="pre">copy</span></tt> implies <tt class="docutils literal"><span class="pre">__strong</span></tt> ownership, as well as the usual behavior of
+copy semantics on the setter.</li>
+<li><tt class="docutils literal"><span class="pre">retain</span></tt> implies <tt class="docutils literal"><span class="pre">__strong</span></tt> ownership.</li>
+<li><tt class="docutils literal"><span class="pre">strong</span></tt> implies <tt class="docutils literal"><span class="pre">__strong</span></tt> ownership.</li>
+<li><tt class="docutils literal"><span class="pre">unsafe_unretained</span></tt> implies <tt class="docutils literal"><span class="pre">__unsafe_unretained</span></tt> ownership.</li>
+<li><tt class="docutils literal"><span class="pre">weak</span></tt> implies <tt class="docutils literal"><span class="pre">__weak</span></tt> ownership.</li>
+</ul>
+<p>With the exception of <tt class="docutils literal"><span class="pre">weak</span></tt>, these modifiers are available in non-ARC
+modes.</p>
+<p>A property’s specified ownership is preserved in its metadata, but otherwise
+the meaning is purely conventional unless the property is synthesized. If a
+property is synthesized, then the <span class="arc-term">associated instance variable</span> is
+the instance variable which is named, possibly implicitly, by the
+<tt class="docutils literal"><span class="pre">@synthesize</span></tt> declaration. If the associated instance variable already
+exists, then its ownership qualification must equal the ownership of the
+property; otherwise, the instance variable is created with that ownership
+qualification.</p>
+<p>A property of retainable object pointer type which is synthesized without a
+source of ownership has the ownership of its associated instance variable, if it
+already exists; otherwise, <span class="when-revised">[beginning Apple 3.1, LLVM 3.1]</span>
+<span class="revision">its ownership is implicitly</span> <tt class="docutils literal"><span class="pre">strong</span></tt>. Prior to this revision, it
+was ill-formed to synthesize such a property.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">Using <tt class="docutils literal"><span class="pre">strong</span></tt> by default is safe and consistent with the generic ARC rule
+about <a class="reference internal" href="#arc-ownership-inference-variables"><em>inferring ownership</em></a>. It is,
+unfortunately, inconsistent with the non-ARC rule which states that such
+properties are implicitly <tt class="docutils literal"><span class="pre">assign</span></tt>. However, that rule is clearly
+untenable in ARC, since it leads to default-unsafe code. The main merit to
+banning the properties is to avoid confusion with non-ARC practice, which did
+not ultimately strike us as sufficient to justify requiring extra syntax and
+(more importantly) forcing novices to understand ownership rules just to
+declare a property when the default is so reasonable. Changing the rule away
+from non-ARC practice was acceptable because we had conservatively banned the
+synthesis in order to give ourselves exactly this leeway.</p>
+</div>
+<p>Applying <tt class="docutils literal"><span class="pre">__attribute__((NSObject))</span></tt> to a property not of retainable object
+pointer type has the same behavior it does outside of ARC: it requires the
+property type to be some sort of pointer and permits the use of modifiers other
+than <tt class="docutils literal"><span class="pre">assign</span></tt>. These modifiers only affect the synthesized getter and
+setter; direct accesses to the ivar (even if synthesized) still have primitive
+semantics, and the value in the ivar will not be automatically released during
+deallocation.</p>
+</div>
+</div>
+<div class="section" id="semantics">
+<span id="arc-ownership-semantics"></span><h3><a class="toc-backref" href="#id23">Semantics</a><a class="headerlink" href="#semantics" title="Permalink to this headline">¶</a></h3>
+<p>There are five <span class="arc-term">managed operations</span> which may be performed on an
+object of retainable object pointer type. Each qualifier specifies different
+semantics for each of these operations. It is still undefined behavior to
+access an object outside of its lifetime.</p>
+<p>A load or store with “primitive semantics” has the same semantics as the
+respective operation would have on an <tt class="docutils literal"><span class="pre">void*</span></tt> lvalue with the same alignment
+and non-ownership qualification.</p>
+<p><span class="arc-term">Reading</span> occurs when performing a lvalue-to-rvalue conversion on an
+object lvalue.</p>
+<ul class="simple">
+<li>For <tt class="docutils literal"><span class="pre">__weak</span></tt> objects, the current pointee is retained and then released at
+the end of the current full-expression. This must execute atomically with
+respect to assignments and to the final release of the pointee.</li>
+<li>For all other objects, the lvalue is loaded with primitive semantics.</li>
+</ul>
+<p><span class="arc-term">Assignment</span> occurs when evaluating an assignment operator. The
+semantics vary based on the qualification:</p>
+<ul class="simple">
+<li>For <tt class="docutils literal"><span class="pre">__strong</span></tt> objects, the new pointee is first retained; second, the
+lvalue is loaded with primitive semantics; third, the new pointee is stored
+into the lvalue with primitive semantics; and finally, the old pointee is
+released. This is not performed atomically; external synchronization must be
+used to make this safe in the face of concurrent loads and stores.</li>
+<li>For <tt class="docutils literal"><span class="pre">__weak</span></tt> objects, the lvalue is updated to point to the new pointee,
+unless the new pointee is an object currently undergoing deallocation, in
+which case the lvalue is updated to a null pointer. This must execute
+atomically with respect to other assignments to the object, to reads from the
+object, and to the final release of the new pointee.</li>
+<li>For <tt class="docutils literal"><span class="pre">__unsafe_unretained</span></tt> objects, the new pointee is stored into the
+lvalue using primitive semantics.</li>
+<li>For <tt class="docutils literal"><span class="pre">__autoreleasing</span></tt> objects, the new pointee is retained, autoreleased,
+and stored into the lvalue using primitive semantics.</li>
+</ul>
+<p><span class="arc-term">Initialization</span> occurs when an object’s lifetime begins, which
+depends on its storage duration. Initialization proceeds in two stages:</p>
+<ol class="arabic simple">
+<li>First, a null pointer is stored into the lvalue using primitive semantics.
+This step is skipped if the object is <tt class="docutils literal"><span class="pre">__unsafe_unretained</span></tt>.</li>
+<li>Second, if the object has an initializer, that expression is evaluated and
+then assigned into the object using the usual assignment semantics.</li>
+</ol>
+<p><span class="arc-term">Destruction</span> occurs when an object’s lifetime ends. In all cases it
+is semantically equivalent to assigning a null pointer to the object, with the
+proviso that of course the object cannot be legally read after the object’s
+lifetime ends.</p>
+<p><span class="arc-term">Moving</span> occurs in specific situations where an lvalue is “moved
+from”, meaning that its current pointee will be used but the object may be left
+in a different (but still valid) state. This arises with <tt class="docutils literal"><span class="pre">__block</span></tt> variables
+and rvalue references in C++. For <tt class="docutils literal"><span class="pre">__strong</span></tt> lvalues, moving is equivalent
+to loading the lvalue with primitive semantics, writing a null pointer to it
+with primitive semantics, and then releasing the result of the load at the end
+of the current full-expression. For all other lvalues, moving is equivalent to
+reading the object.</p>
+</div>
+<div class="section" id="arc-ownership-restrictions">
+<span id="id1"></span><h3><a class="toc-backref" href="#id24">Restrictions</a><a class="headerlink" href="#arc-ownership-restrictions" title="Permalink to this headline">¶</a></h3>
+<div class="section" id="weak-unavailable-types">
+<span id="arc-ownership-restrictions-weak"></span><h4><a class="toc-backref" href="#id25">Weak-unavailable types</a><a class="headerlink" href="#weak-unavailable-types" title="Permalink to this headline">¶</a></h4>
+<p>It is explicitly permitted for Objective-C classes to not support <tt class="docutils literal"><span class="pre">__weak</span></tt>
+references. It is undefined behavior to perform an operation with weak
+assignment semantics with a pointer to an Objective-C object whose class does
+not support <tt class="docutils literal"><span class="pre">__weak</span></tt> references.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">Historically, it has been possible for a class to provide its own
+reference-count implementation by overriding <tt class="docutils literal"><span class="pre">retain</span></tt>, <tt class="docutils literal"><span class="pre">release</span></tt>, etc.
+However, weak references to an object require coordination with its class’s
+reference-count implementation because, among other things, weak loads and
+stores must be atomic with respect to the final release. Therefore, existing
+custom reference-count implementations will generally not support weak
+references without additional effort. This is unavoidable without breaking
+binary compatibility.</p>
+</div>
+<p>A class may indicate that it does not support weak references by providing the
+<tt class="docutils literal"><span class="pre">objc_arc_weak_reference_unavailable</span></tt> attribute on the class’s interface declaration. A
+retainable object pointer type is <strong>weak-unavailable</strong> if
+is a pointer to an (optionally protocol-qualified) Objective-C class <tt class="docutils literal"><span class="pre">T</span></tt> where
+<tt class="docutils literal"><span class="pre">T</span></tt> or one of its superclasses has the <tt class="docutils literal"><span class="pre">objc_arc_weak_reference_unavailable</span></tt>
+attribute. A program is ill-formed if it applies the <tt class="docutils literal"><span class="pre">__weak</span></tt> ownership
+qualifier to a weak-unavailable type or if the value operand of a weak
+assignment operation has a weak-unavailable type.</p>
+</div>
+<div class="section" id="storage-duration-of-autoreleasing-objects">
+<span id="arc-ownership-restrictions-autoreleasing"></span><h4><a class="toc-backref" href="#id26">Storage duration of <tt class="docutils literal"><span class="pre">__autoreleasing</span></tt> objects</a><a class="headerlink" href="#storage-duration-of-autoreleasing-objects" title="Permalink to this headline">¶</a></h4>
+<p>A program is ill-formed if it declares an <tt class="docutils literal"><span class="pre">__autoreleasing</span></tt> object of
+non-automatic storage duration. A program is ill-formed if it captures an
+<tt class="docutils literal"><span class="pre">__autoreleasing</span></tt> object in a block or, unless by reference, in a C++11
+lambda.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">Autorelease pools are tied to the current thread and scope by their nature.
+While it is possible to have temporary objects whose instance variables are
+filled with autoreleased objects, there is no way that ARC can provide any
+sort of safety guarantee there.</p>
+</div>
+<p>It is undefined behavior if a non-null pointer is assigned to an
+<tt class="docutils literal"><span class="pre">__autoreleasing</span></tt> object while an autorelease pool is in scope and then that
+object is read after the autorelease pool’s scope is left.</p>
+</div>
+<div class="section" id="conversion-of-pointers-to-ownership-qualified-types">
+<span id="arc-ownership-restrictions-conversion-indirect"></span><h4><a class="toc-backref" href="#id27">Conversion of pointers to ownership-qualified types</a><a class="headerlink" href="#conversion-of-pointers-to-ownership-qualified-types" title="Permalink to this headline">¶</a></h4>
+<p>A program is ill-formed if an expression of type <tt class="docutils literal"><span class="pre">T*</span></tt> is converted,
+explicitly or implicitly, to the type <tt class="docutils literal"><span class="pre">U*</span></tt>, where <tt class="docutils literal"><span class="pre">T</span></tt> and <tt class="docutils literal"><span class="pre">U</span></tt> have
+different ownership qualification, unless:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">T</span></tt> is qualified with <tt class="docutils literal"><span class="pre">__strong</span></tt>, <tt class="docutils literal"><span class="pre">__autoreleasing</span></tt>, or
+<tt class="docutils literal"><span class="pre">__unsafe_unretained</span></tt>, and <tt class="docutils literal"><span class="pre">U</span></tt> is qualified with both <tt class="docutils literal"><span class="pre">const</span></tt> and
+<tt class="docutils literal"><span class="pre">__unsafe_unretained</span></tt>; or</li>
+<li>either <tt class="docutils literal"><span class="pre">T</span></tt> or <tt class="docutils literal"><span class="pre">U</span></tt> is <tt class="docutils literal"><span class="pre">cv</span> <span class="pre">void</span></tt>, where <tt class="docutils literal"><span class="pre">cv</span></tt> is an optional sequence
+of non-ownership qualifiers; or</li>
+<li>the conversion is requested with a <tt class="docutils literal"><span class="pre">reinterpret_cast</span></tt> in Objective-C++; or</li>
+<li>the conversion is a well-formed <a class="reference internal" href="#arc-ownership-restrictions-pass-by-writeback"><em>pass-by-writeback</em></a>.</li>
+</ul>
+<p>The analogous rule applies to <tt class="docutils literal"><span class="pre">T&</span></tt> and <tt class="docutils literal"><span class="pre">U&</span></tt> in Objective-C++.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">These rules provide a reasonable level of type-safety for indirect pointers,
+as long as the underlying memory is not deallocated. The conversion to
+<tt class="docutils literal"><span class="pre">const</span> <span class="pre">__unsafe_unretained</span></tt> is permitted because the semantics of reads are
+equivalent across all these ownership semantics, and that’s a very useful and
+common pattern. The interconversion with <tt class="docutils literal"><span class="pre">void*</span></tt> is useful for allocating
+memory or otherwise escaping the type system, but use it carefully.
+<tt class="docutils literal"><span class="pre">reinterpret_cast</span></tt> is considered to be an obvious enough sign of taking
+responsibility for any problems.</p>
+</div>
+<p>It is undefined behavior to access an ownership-qualified object through an
+lvalue of a differently-qualified type, except that any non-<tt class="docutils literal"><span class="pre">__weak</span></tt> object
+may be read through an <tt class="docutils literal"><span class="pre">__unsafe_unretained</span></tt> lvalue.</p>
+<p>It is undefined behavior if a managed operation is performed on a <tt class="docutils literal"><span class="pre">__strong</span></tt>
+or <tt class="docutils literal"><span class="pre">__weak</span></tt> object without a guarantee that it contains a primitive zero
+bit-pattern, or if the storage for such an object is freed or reused without the
+object being first assigned a null pointer.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">ARC cannot differentiate between an assignment operator which is intended to
+“initialize” dynamic memory and one which is intended to potentially replace
+a value. Therefore the object’s pointer must be valid before letting ARC at
+it. Similarly, C and Objective-C do not provide any language hooks for
+destroying objects held in dynamic memory, so it is the programmer’s
+responsibility to avoid leaks (<tt class="docutils literal"><span class="pre">__strong</span></tt> objects) and consistency errors
+(<tt class="docutils literal"><span class="pre">__weak</span></tt> objects).</p>
+</div>
+<p>These requirements are followed automatically in Objective-C++ when creating
+objects of retainable object owner type with <tt class="docutils literal"><span class="pre">new</span></tt> or <tt class="docutils literal"><span class="pre">new[]</span></tt> and destroying
+them with <tt class="docutils literal"><span class="pre">delete</span></tt>, <tt class="docutils literal"><span class="pre">delete[]</span></tt>, or a pseudo-destructor expression. Note
+that arrays of nontrivially-ownership-qualified type are not ABI compatible with
+non-ARC code because the element type is non-POD: such arrays that are
+<tt class="docutils literal"><span class="pre">new[]</span></tt>‘d in ARC translation units cannot be <tt class="docutils literal"><span class="pre">delete[]</span></tt>‘d in non-ARC
+translation units and vice-versa.</p>
+</div>
+<div class="section" id="passing-to-an-out-parameter-by-writeback">
+<span id="arc-ownership-restrictions-pass-by-writeback"></span><h4><a class="toc-backref" href="#id28">Passing to an out parameter by writeback</a><a class="headerlink" href="#passing-to-an-out-parameter-by-writeback" title="Permalink to this headline">¶</a></h4>
+<p>If the argument passed to a parameter of type <tt class="docutils literal"><span class="pre">T</span> <span class="pre">__autoreleasing</span> <span class="pre">*</span></tt> has type
+<tt class="docutils literal"><span class="pre">U</span> <span class="pre">oq</span> <span class="pre">*</span></tt>, where <tt class="docutils literal"><span class="pre">oq</span></tt> is an ownership qualifier, then the argument is a
+candidate for <span class="arc-term">pass-by-writeback`</span> if:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">oq</span></tt> is <tt class="docutils literal"><span class="pre">__strong</span></tt> or <tt class="docutils literal"><span class="pre">__weak</span></tt>, and</li>
+<li>it would be legal to initialize a <tt class="docutils literal"><span class="pre">T</span> <span class="pre">__strong</span> <span class="pre">*</span></tt> with a <tt class="docutils literal"><span class="pre">U</span> <span class="pre">__strong</span> <span class="pre">*</span></tt>.</li>
+</ul>
+<p>For purposes of overload resolution, an implicit conversion sequence requiring
+a pass-by-writeback is always worse than an implicit conversion sequence not
+requiring a pass-by-writeback.</p>
+<p>The pass-by-writeback is ill-formed if the argument expression does not have a
+legal form:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">&var</span></tt>, where <tt class="docutils literal"><span class="pre">var</span></tt> is a scalar variable of automatic storage duration
+with retainable object pointer type</li>
+<li>a conditional expression where the second and third operands are both legal
+forms</li>
+<li>a cast whose operand is a legal form</li>
+<li>a null pointer constant</li>
+</ul>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">The restriction in the form of the argument serves two purposes. First, it
+makes it impossible to pass the address of an array to the argument, which
+serves to protect against an otherwise serious risk of mis-inferring an
+“array” argument as an out-parameter. Second, it makes it much less likely
+that the user will see confusing aliasing problems due to the implementation,
+below, where their store to the writeback temporary is not immediately seen
+in the original argument variable.</p>
+</div>
+<p>A pass-by-writeback is evaluated as follows:</p>
+<ol class="arabic simple">
+<li>The argument is evaluated to yield a pointer <tt class="docutils literal"><span class="pre">p</span></tt> of type <tt class="docutils literal"><span class="pre">U</span> <span class="pre">oq</span> <span class="pre">*</span></tt>.</li>
+<li>If <tt class="docutils literal"><span class="pre">p</span></tt> is a null pointer, then a null pointer is passed as the argument,
+and no further work is required for the pass-by-writeback.</li>
+<li>Otherwise, a temporary of type <tt class="docutils literal"><span class="pre">T</span> <span class="pre">__autoreleasing</span></tt> is created and
+initialized to a null pointer.</li>
+<li>If the parameter is not an Objective-C method parameter marked <tt class="docutils literal"><span class="pre">out</span></tt>,
+then <tt class="docutils literal"><span class="pre">*p</span></tt> is read, and the result is written into the temporary with
+primitive semantics.</li>
+<li>The address of the temporary is passed as the argument to the actual call.</li>
+<li>After the call completes, the temporary is loaded with primitive
+semantics, and that value is assigned into <tt class="docutils literal"><span class="pre">*p</span></tt>.</li>
+</ol>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">This is all admittedly convoluted. In an ideal world, we would see that a
+local variable is being passed to an out-parameter and retroactively modify
+its type to be <tt class="docutils literal"><span class="pre">__autoreleasing</span></tt> rather than <tt class="docutils literal"><span class="pre">__strong</span></tt>. This would be
+remarkably difficult and not always well-founded under the C type system.
+However, it was judged unacceptably invasive to require programmers to write
+<tt class="docutils literal"><span class="pre">__autoreleasing</span></tt> on all the variables they intend to use for
+out-parameters. This was the least bad solution.</p>
+</div>
+</div>
+<div class="section" id="ownership-qualified-fields-of-structs-and-unions">
+<span id="arc-ownership-restrictions-records"></span><h4><a class="toc-backref" href="#id29">Ownership-qualified fields of structs and unions</a><a class="headerlink" href="#ownership-qualified-fields-of-structs-and-unions" title="Permalink to this headline">¶</a></h4>
+<p>A program is ill-formed if it declares a member of a C struct or union to have
+a nontrivially ownership-qualified type.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">The resulting type would be non-POD in the C++ sense, but C does not give us
+very good language tools for managing the lifetime of aggregates, so it is
+more convenient to simply forbid them. It is still possible to manage this
+with a <tt class="docutils literal"><span class="pre">void*</span></tt> or an <tt class="docutils literal"><span class="pre">__unsafe_unretained</span></tt> object.</p>
+</div>
+<p>This restriction does not apply in Objective-C++. However, nontrivally
+ownership-qualified types are considered non-POD: in C++11 terms, they are not
+trivially default constructible, copy constructible, move constructible, copy
+assignable, move assignable, or destructible. It is a violation of C++’s One
+Definition Rule to use a class outside of ARC that, under ARC, would have a
+nontrivially ownership-qualified member.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">Unlike in C, we can express all the necessary ARC semantics for
+ownership-qualified subobjects as suboperations of the (default) special
+member functions for the class. These functions then become non-trivial.
+This has the non-obvious result that the class will have a non-trivial copy
+constructor and non-trivial destructor; if this would not normally be true
+outside of ARC, objects of the type will be passed and returned in an
+ABI-incompatible manner.</p>
+</div>
+</div>
+</div>
+<div class="section" id="ownership-inference">
+<span id="arc-ownership-inference"></span><h3><a class="toc-backref" href="#id30">Ownership inference</a><a class="headerlink" href="#ownership-inference" title="Permalink to this headline">¶</a></h3>
+<div class="section" id="objects">
+<span id="arc-ownership-inference-variables"></span><h4><a class="toc-backref" href="#id31">Objects</a><a class="headerlink" href="#objects" title="Permalink to this headline">¶</a></h4>
+<p>If an object is declared with retainable object owner type, but without an
+explicit ownership qualifier, its type is implicitly adjusted to have
+<tt class="docutils literal"><span class="pre">__strong</span></tt> qualification.</p>
+<p>As a special case, if the object’s base type is <tt class="docutils literal"><span class="pre">Class</span></tt> (possibly
+protocol-qualified), the type is adjusted to have <tt class="docutils literal"><span class="pre">__unsafe_unretained</span></tt>
+qualification instead.</p>
+</div>
+<div class="section" id="indirect-parameters">
+<span id="arc-ownership-inference-indirect-parameters"></span><h4><a class="toc-backref" href="#id32">Indirect parameters</a><a class="headerlink" href="#indirect-parameters" title="Permalink to this headline">¶</a></h4>
+<p>If a function or method parameter has type <tt class="docutils literal"><span class="pre">T*</span></tt>, where <tt class="docutils literal"><span class="pre">T</span></tt> is an
+ownership-unqualified retainable object pointer type, then:</p>
+<ul class="simple">
+<li>if <tt class="docutils literal"><span class="pre">T</span></tt> is <tt class="docutils literal"><span class="pre">const</span></tt>-qualified or <tt class="docutils literal"><span class="pre">Class</span></tt>, then it is implicitly
+qualified with <tt class="docutils literal"><span class="pre">__unsafe_unretained</span></tt>;</li>
+<li>otherwise, it is implicitly qualified with <tt class="docutils literal"><span class="pre">__autoreleasing</span></tt>.</li>
+</ul>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last"><tt class="docutils literal"><span class="pre">__autoreleasing</span></tt> exists mostly for this case, the Cocoa convention for
+out-parameters. Since a pointer to <tt class="docutils literal"><span class="pre">const</span></tt> is obviously not an
+out-parameter, we instead use a type more useful for passing arrays. If the
+user instead intends to pass in a <em>mutable</em> array, inferring
+<tt class="docutils literal"><span class="pre">__autoreleasing</span></tt> is the wrong thing to do; this directs some of the
+caution in the following rules about writeback.</p>
+</div>
+<p>Such a type written anywhere else would be ill-formed by the general rule
+requiring ownership qualifiers.</p>
+<p>This rule does not apply in Objective-C++ if a parameter’s type is dependent in
+a template pattern and is only <em>instantiated</em> to a type which would be a
+pointer to an unqualified retainable object pointer type. Such code is still
+ill-formed.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">The convention is very unlikely to be intentional in template code.</p>
+</div>
+</div>
+<div class="section" id="template-arguments">
+<span id="arc-ownership-inference-template-arguments"></span><h4><a class="toc-backref" href="#id33">Template arguments</a><a class="headerlink" href="#template-arguments" title="Permalink to this headline">¶</a></h4>
+<p>If a template argument for a template type parameter is an retainable object
+owner type that does not have an explicit ownership qualifier, it is adjusted
+to have <tt class="docutils literal"><span class="pre">__strong</span></tt> qualification. This adjustment occurs regardless of
+whether the template argument was deduced or explicitly specified.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last"><tt class="docutils literal"><span class="pre">__strong</span></tt> is a useful default for containers (e.g., <tt class="docutils literal"><span class="pre">std::vector<id></span></tt>),
+which would otherwise require explicit qualification. Moreover, unqualified
+retainable object pointer types are unlikely to be useful within templates,
+since they generally need to have a qualifier applied to the before being
+used.</p>
+</div>
+</div>
+</div>
+</div>
+<div class="section" id="method-families">
+<span id="arc-method-families"></span><h2><a class="toc-backref" href="#id34">Method families</a><a class="headerlink" href="#method-families" title="Permalink to this headline">¶</a></h2>
+<p>An Objective-C method may fall into a <span class="arc-term">method family</span>, which is a
+conventional set of behaviors ascribed to it by the Cocoa conventions.</p>
+<p>A method is in a certain method family if:</p>
+<ul class="simple">
+<li>it has a <tt class="docutils literal"><span class="pre">objc_method_family</span></tt> attribute placing it in that family; or if
+not that,</li>
+<li>it does not have an <tt class="docutils literal"><span class="pre">objc_method_family</span></tt> attribute placing it in a
+different or no family, and</li>
+<li>its selector falls into the corresponding selector family, and</li>
+<li>its signature obeys the added restrictions of the method family.</li>
+</ul>
+<p>A selector is in a certain selector family if, ignoring any leading
+underscores, the first component of the selector either consists entirely of
+the name of the method family or it begins with that name followed by a
+character other than a lowercase letter. For example, <tt class="docutils literal"><span class="pre">_perform:with:</span></tt> and
+<tt class="docutils literal"><span class="pre">performWith:</span></tt> would fall into the <tt class="docutils literal"><span class="pre">perform</span></tt> family (if we recognized one),
+but <tt class="docutils literal"><span class="pre">performing:with</span></tt> would not.</p>
+<p>The families and their added restrictions are:</p>
+<ul>
+<li><p class="first"><tt class="docutils literal"><span class="pre">alloc</span></tt> methods must return a retainable object pointer type.</p>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">copy</span></tt> methods must return a retainable object pointer type.</p>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">mutableCopy</span></tt> methods must return a retainable object pointer type.</p>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">new</span></tt> methods must return a retainable object pointer type.</p>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">init</span></tt> methods must be instance methods and must return an Objective-C
+pointer type. Additionally, a program is ill-formed if it declares or
+contains a call to an <tt class="docutils literal"><span class="pre">init</span></tt> method whose return type is neither <tt class="docutils literal"><span class="pre">id</span></tt> nor
+a pointer to a super-class or sub-class of the declaring class (if the method
+was declared on a class) or the static receiver type of the call (if it was
+declared on a protocol).</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p>There are a fair number of existing methods with <tt class="docutils literal"><span class="pre">init</span></tt>-like selectors
+which nonetheless don’t follow the <tt class="docutils literal"><span class="pre">init</span></tt> conventions. Typically these
+are either accidental naming collisions or helper methods called during
+initialization. Because of the peculiar retain/release behavior of
+<tt class="docutils literal"><span class="pre">init</span></tt> methods, it’s very important not to treat these methods as
+<tt class="docutils literal"><span class="pre">init</span></tt> methods if they aren’t meant to be. It was felt that implicitly
+defining these methods out of the family based on the exact relationship
+between the return type and the declaring class would be much too subtle
+and fragile. Therefore we identify a small number of legitimate-seeming
+return types and call everything else an error. This serves the secondary
+purpose of encouraging programmers not to accidentally give methods names
+in the <tt class="docutils literal"><span class="pre">init</span></tt> family.</p>
+<p class="last">Note that a method with an <tt class="docutils literal"><span class="pre">init</span></tt>-family selector which returns a
+non-Objective-C type (e.g. <tt class="docutils literal"><span class="pre">void</span></tt>) is perfectly well-formed; it simply
+isn’t in the <tt class="docutils literal"><span class="pre">init</span></tt> family.</p>
+</div>
+</li>
+</ul>
+<p>A program is ill-formed if a method’s declarations, implementations, and
+overrides do not all have the same method family.</p>
+<div class="section" id="explicit-method-family-control">
+<span id="arc-family-attribute"></span><h3><a class="toc-backref" href="#id35">Explicit method family control</a><a class="headerlink" href="#explicit-method-family-control" title="Permalink to this headline">¶</a></h3>
+<p>A method may be annotated with the <tt class="docutils literal"><span class="pre">objc_method_family</span></tt> attribute to
+precisely control which method family it belongs to. If a method in an
+<tt class="docutils literal"><span class="pre">@implementation</span></tt> does not have this attribute, but there is a method
+declared in the corresponding <tt class="docutils literal"><span class="pre">@interface</span></tt> that does, then the attribute is
+copied to the declaration in the <tt class="docutils literal"><span class="pre">@implementation</span></tt>. The attribute is
+available outside of ARC, and may be tested for with the preprocessor query
+<tt class="docutils literal"><span class="pre">__has_attribute(objc_method_family)</span></tt>.</p>
+<p>The attribute is spelled
+<tt class="docutils literal"><span class="pre">__attribute__((objc_method_family(</span></tt> <em>family</em> <tt class="docutils literal"><span class="pre">)))</span></tt>. If <em>family</em> is
+<tt class="docutils literal"><span class="pre">none</span></tt>, the method has no family, even if it would otherwise be considered to
+have one based on its selector and type. Otherwise, <em>family</em> must be one of
+<tt class="docutils literal"><span class="pre">alloc</span></tt>, <tt class="docutils literal"><span class="pre">copy</span></tt>, <tt class="docutils literal"><span class="pre">init</span></tt>, <tt class="docutils literal"><span class="pre">mutableCopy</span></tt>, or <tt class="docutils literal"><span class="pre">new</span></tt>, in which case the
+method is considered to belong to the corresponding family regardless of its
+selector. It is an error if a method that is explicitly added to a family in
+this way does not meet the requirements of the family other than the selector
+naming convention.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">The rules codified in this document describe the standard conventions of
+Objective-C. However, as these conventions have not heretofore been enforced
+by an unforgiving mechanical system, they are only imperfectly kept,
+especially as they haven’t always even been precisely defined. While it is
+possible to define low-level ownership semantics with attributes like
+<tt class="docutils literal"><span class="pre">ns_returns_retained</span></tt>, this attribute allows the user to communicate
+semantic intent, which is of use both to ARC (which, e.g., treats calls to
+<tt class="docutils literal"><span class="pre">init</span></tt> specially) and the static analyzer.</p>
+</div>
+</div>
+<div class="section" id="semantics-of-method-families">
+<span id="arc-family-semantics"></span><h3><a class="toc-backref" href="#id36">Semantics of method families</a><a class="headerlink" href="#semantics-of-method-families" title="Permalink to this headline">¶</a></h3>
+<p>A method’s membership in a method family may imply non-standard semantics for
+its parameters and return type.</p>
+<p>Methods in the <tt class="docutils literal"><span class="pre">alloc</span></tt>, <tt class="docutils literal"><span class="pre">copy</span></tt>, <tt class="docutils literal"><span class="pre">mutableCopy</span></tt>, and <tt class="docutils literal"><span class="pre">new</span></tt> families —
+that is, methods in all the currently-defined families except <tt class="docutils literal"><span class="pre">init</span></tt> —
+implicitly <a class="reference internal" href="#arc-object-operands-retained-return-values"><em>return a retained object</em></a> as if they were annotated with
+the <tt class="docutils literal"><span class="pre">ns_returns_retained</span></tt> attribute. This can be overridden by annotating
+the method with either of the <tt class="docutils literal"><span class="pre">ns_returns_autoreleased</span></tt> or
+<tt class="docutils literal"><span class="pre">ns_returns_not_retained</span></tt> attributes.</p>
+<p>Properties also follow same naming rules as methods. This means that those in
+the <tt class="docutils literal"><span class="pre">alloc</span></tt>, <tt class="docutils literal"><span class="pre">copy</span></tt>, <tt class="docutils literal"><span class="pre">mutableCopy</span></tt>, and <tt class="docutils literal"><span class="pre">new</span></tt> families provide access
+to <a class="reference internal" href="#arc-object-operands-retained-return-values"><em>retained objects</em></a>. This
+can be overridden by annotating the property with <tt class="docutils literal"><span class="pre">ns_returns_not_retained</span></tt>
+attribute.</p>
+<div class="section" id="semantics-of-init">
+<span id="arc-family-semantics-init"></span><h4><a class="toc-backref" href="#id37">Semantics of <tt class="docutils literal"><span class="pre">init</span></tt></a><a class="headerlink" href="#semantics-of-init" title="Permalink to this headline">¶</a></h4>
+<p>Methods in the <tt class="docutils literal"><span class="pre">init</span></tt> family implicitly <a class="reference internal" href="#arc-objects-operands-consumed"><em>consume</em></a> their <tt class="docutils literal"><span class="pre">self</span></tt> parameter and <a class="reference internal" href="#arc-object-operands-retained-return-values"><em>return a
+retained object</em></a>. Neither of
+these properties can be altered through attributes.</p>
+<p>A call to an <tt class="docutils literal"><span class="pre">init</span></tt> method with a receiver that is either <tt class="docutils literal"><span class="pre">self</span></tt> (possibly
+parenthesized or casted) or <tt class="docutils literal"><span class="pre">super</span></tt> is called a <span class="arc-term">delegate init
+call</span>. It is an error for a delegate init call to be made except from an
+<tt class="docutils literal"><span class="pre">init</span></tt> method, and excluding blocks within such methods.</p>
+<p>As an exception to the <a class="reference internal" href="#arc-misc-self"><em>usual rule</em></a>, the variable <tt class="docutils literal"><span class="pre">self</span></tt>
+is mutable in an <tt class="docutils literal"><span class="pre">init</span></tt> method and has the usual semantics for a <tt class="docutils literal"><span class="pre">__strong</span></tt>
+variable. However, it is undefined behavior and the program is ill-formed, no
+diagnostic required, if an <tt class="docutils literal"><span class="pre">init</span></tt> method attempts to use the previous value
+of <tt class="docutils literal"><span class="pre">self</span></tt> after the completion of a delegate init call. It is conventional,
+but not required, for an <tt class="docutils literal"><span class="pre">init</span></tt> method to return <tt class="docutils literal"><span class="pre">self</span></tt>.</p>
+<p>It is undefined behavior for a program to cause two or more calls to <tt class="docutils literal"><span class="pre">init</span></tt>
+methods on the same object, except that each <tt class="docutils literal"><span class="pre">init</span></tt> method invocation may
+perform at most one delegate init call.</p>
+</div>
+<div class="section" id="related-result-types">
+<span id="arc-family-semantics-result-type"></span><h4><a class="toc-backref" href="#id38">Related result types</a><a class="headerlink" href="#related-result-types" title="Permalink to this headline">¶</a></h4>
+<p>Certain methods are candidates to have <span class="arc-term">related result types</span>:</p>
+<ul class="simple">
+<li>class methods in the <tt class="docutils literal"><span class="pre">alloc</span></tt> and <tt class="docutils literal"><span class="pre">new</span></tt> method families</li>
+<li>instance methods in the <tt class="docutils literal"><span class="pre">init</span></tt> family</li>
+<li>the instance method <tt class="docutils literal"><span class="pre">self</span></tt></li>
+<li>outside of ARC, the instance methods <tt class="docutils literal"><span class="pre">retain</span></tt> and <tt class="docutils literal"><span class="pre">autorelease</span></tt></li>
+</ul>
+<p>If the formal result type of such a method is <tt class="docutils literal"><span class="pre">id</span></tt> or protocol-qualified
+<tt class="docutils literal"><span class="pre">id</span></tt>, or a type equal to the declaring class or a superclass, then it is said
+to have a related result type. In this case, when invoked in an explicit
+message send, it is assumed to return a type related to the type of the
+receiver:</p>
+<ul class="simple">
+<li>if it is a class method, and the receiver is a class name <tt class="docutils literal"><span class="pre">T</span></tt>, the message
+send expression has type <tt class="docutils literal"><span class="pre">T*</span></tt>; otherwise</li>
+<li>if it is an instance method, and the receiver has type <tt class="docutils literal"><span class="pre">T</span></tt>, the message
+send expression has type <tt class="docutils literal"><span class="pre">T</span></tt>; otherwise</li>
+<li>the message send expression has the normal result type of the method.</li>
+</ul>
+<p>This is a new rule of the Objective-C language and applies outside of ARC.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">ARC’s automatic code emission is more prone than most code to signature
+errors, i.e. errors where a call was emitted against one method signature,
+but the implementing method has an incompatible signature. Having more
+precise type information helps drastically lower this risk, as well as
+catching a number of latent bugs.</p>
+</div>
+</div>
+</div>
+</div>
+<div class="section" id="optimization">
+<span id="arc-optimization"></span><h2><a class="toc-backref" href="#id39">Optimization</a><a class="headerlink" href="#optimization" title="Permalink to this headline">¶</a></h2>
+<p>Within this section, the word <span class="arc-term">function</span> will be used to
+refer to any structured unit of code, be it a C function, an
+Objective-C method, or a block.</p>
+<p>This specification describes ARC as performing specific <tt class="docutils literal"><span class="pre">retain</span></tt> and
+<tt class="docutils literal"><span class="pre">release</span></tt> operations on retainable object pointers at specific
+points during the execution of a program. These operations make up a
+non-contiguous subsequence of the computation history of the program.
+The portion of this sequence for a particular retainable object
+pointer for which a specific function execution is directly
+responsible is the <span class="arc-term">formal local retain history</span> of the
+object pointer. The corresponding actual sequence executed is the
+<cite>dynamic local retain history</cite>.</p>
+<p>However, under certain circumstances, ARC is permitted to re-order and
+eliminate operations in a manner which may alter the overall
+computation history beyond what is permitted by the general “as if”
+rule of C/C++ and the <a class="reference internal" href="#arc-objects-retains"><em>restrictions</em></a> on
+the implementation of <tt class="docutils literal"><span class="pre">retain</span></tt> and <tt class="docutils literal"><span class="pre">release</span></tt>.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p>Specifically, ARC is sometimes permitted to optimize <tt class="docutils literal"><span class="pre">release</span></tt>
+operations in ways which might cause an object to be deallocated
+before it would otherwise be. Without this, it would be almost
+impossible to eliminate any <tt class="docutils literal"><span class="pre">retain</span></tt>/<tt class="docutils literal"><span class="pre">release</span></tt> pairs. For
+example, consider the following code:</p>
+<div class="highlight-objc"><div class="highlight"><pre><span class="kt">id</span> <span class="n">x</span> <span class="o">=</span> <span class="n">_ivar</span><span class="p">;</span>
+<span class="p">[</span><span class="n">x</span> <span class="n">foo</span><span class="p">];</span>
+</pre></div>
+</div>
+<p class="last">If we were not permitted in any event to shorten the lifetime of the
+object in <tt class="docutils literal"><span class="pre">x</span></tt>, then we would not be able to eliminate this retain
+and release unless we could prove that the message send could not
+modify <tt class="docutils literal"><span class="pre">_ivar</span></tt> (or deallocate <tt class="docutils literal"><span class="pre">self</span></tt>). Since message sends are
+opaque to the optimizer, this is not possible, and so ARC’s hands
+would be almost completely tied.</p>
+</div>
+<p>ARC makes no guarantees about the execution of a computation history
+which contains undefined behavior. In particular, ARC makes no
+guarantees in the presence of race conditions.</p>
+<p>ARC may assume that any retainable object pointers it receives or
+generates are instantaneously valid from that point until a point
+which, by the concurrency model of the host language, happens-after
+the generation of the pointer and happens-before a release of that
+object (possibly via an aliasing pointer or indirectly due to
+destruction of a different object).</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">There is very little point in trying to guarantee correctness in the
+presence of race conditions. ARC does not have a stack-scanning
+garbage collector, and guaranteeing the atomicity of every load and
+store operation would be prohibitive and preclude a vast amount of
+optimization.</p>
+</div>
+<p>ARC may assume that non-ARC code engages in sensible balancing
+behavior and does not rely on exact or minimum retain count values
+except as guaranteed by <tt class="docutils literal"><span class="pre">__strong</span></tt> object invariants or +1 transfer
+conventions. For example, if an object is provably double-retained
+and double-released, ARC may eliminate the inner retain and release;
+it does not need to guard against code which performs an unbalanced
+release followed by a “balancing” retain.</p>
+<div class="section" id="object-liveness">
+<span id="arc-optimization-liveness"></span><h3><a class="toc-backref" href="#id40">Object liveness</a><a class="headerlink" href="#object-liveness" title="Permalink to this headline">¶</a></h3>
+<p>ARC may not allow a retainable object <tt class="docutils literal"><span class="pre">X</span></tt> to be deallocated at a
+time <tt class="docutils literal"><span class="pre">T</span></tt> in a computation history if:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">X</span></tt> is the value stored in a <tt class="docutils literal"><span class="pre">__strong</span></tt> object <tt class="docutils literal"><span class="pre">S</span></tt> with
+<a class="reference internal" href="#arc-optimization-precise"><em>precise lifetime semantics</em></a>, or</li>
+<li><tt class="docutils literal"><span class="pre">X</span></tt> is the value stored in a <tt class="docutils literal"><span class="pre">__strong</span></tt> object <tt class="docutils literal"><span class="pre">S</span></tt> with
+imprecise lifetime semantics and, at some point after <tt class="docutils literal"><span class="pre">T</span></tt> but
+before the next store to <tt class="docutils literal"><span class="pre">S</span></tt>, the computation history features a
+load from <tt class="docutils literal"><span class="pre">S</span></tt> and in some way depends on the value loaded, or</li>
+<li><tt class="docutils literal"><span class="pre">X</span></tt> is a value described as being released at the end of the
+current full-expression and, at some point after <tt class="docutils literal"><span class="pre">T</span></tt> but before
+the end of the full-expression, the computation history depends
+on that value.</li>
+</ul>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p>The intent of the second rule is to say that objects held in normal
+<tt class="docutils literal"><span class="pre">__strong</span></tt> local variables may be released as soon as the value in
+the variable is no longer being used: either the variable stops
+being used completely or a new value is stored in the variable.</p>
+<p class="last">The intent of the third rule is to say that return values may be
+released after they’ve been used.</p>
+</div>
+<p>A computation history depends on a pointer value <tt class="docutils literal"><span class="pre">P</span></tt> if it:</p>
+<ul class="simple">
+<li>performs a pointer comparison with <tt class="docutils literal"><span class="pre">P</span></tt>,</li>
+<li>loads from <tt class="docutils literal"><span class="pre">P</span></tt>,</li>
+<li>stores to <tt class="docutils literal"><span class="pre">P</span></tt>,</li>
+<li>depends on a pointer value <tt class="docutils literal"><span class="pre">Q</span></tt> derived via pointer arithmetic
+from <tt class="docutils literal"><span class="pre">P</span></tt> (including an instance-variable or field access), or</li>
+<li>depends on a pointer value <tt class="docutils literal"><span class="pre">Q</span></tt> loaded from <tt class="docutils literal"><span class="pre">P</span></tt>.</li>
+</ul>
+<p>Dependency applies only to values derived directly or indirectly from
+a particular expression result and does not occur merely because a
+separate pointer value dynamically aliases <tt class="docutils literal"><span class="pre">P</span></tt>. Furthermore, this
+dependency is not carried by values that are stored to objects.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p>The restrictions on dependency are intended to make this analysis
+feasible by an optimizer with only incomplete information about a
+program. Essentially, dependence is carried to “obvious” uses of a
+pointer. Merely passing a pointer argument to a function does not
+itself cause dependence, but since generally the optimizer will not
+be able to prove that the function doesn’t depend on that parameter,
+it will be forced to conservatively assume it does.</p>
+<p>Dependency propagates to values loaded from a pointer because those
+values might be invalidated by deallocating the object. For
+example, given the code <tt class="docutils literal"><span class="pre">__strong</span> <span class="pre">id</span> <span class="pre">x</span> <span class="pre">=</span> <span class="pre">p->ivar;</span></tt>, ARC must not
+move the release of <tt class="docutils literal"><span class="pre">p</span></tt> to between the load of <tt class="docutils literal"><span class="pre">p->ivar</span></tt> and the
+retain of that value for storing into <tt class="docutils literal"><span class="pre">x</span></tt>.</p>
+<p>Dependency does not propagate through stores of dependent pointer
+values because doing so would allow dependency to outlive the
+full-expression which produced the original value. For example, the
+address of an instance variable could be written to some global
+location and then freely accessed during the lifetime of the local,
+or a function could return an inner pointer of an object and store
+it to a local. These cases would be potentially impossible to
+reason about and so would basically prevent any optimizations based
+on imprecise lifetime. There are also uncommon enough to make it
+reasonable to require the precise-lifetime annotation if someone
+really wants to rely on them.</p>
+<p class="last">Dependency does propagate through return values of pointer type.
+The compelling source of need for this rule is a property accessor
+which returns an un-autoreleased result; the calling function must
+have the chance to operate on the value, e.g. to retain it, before
+ARC releases the original pointer. Note again, however, that
+dependence does not survive a store, so ARC does not guarantee the
+continued validity of the return value past the end of the
+full-expression.</p>
+</div>
+</div>
+<div class="section" id="no-object-lifetime-extension">
+<span id="arc-optimization-object-lifetime"></span><h3><a class="toc-backref" href="#id41">No object lifetime extension</a><a class="headerlink" href="#no-object-lifetime-extension" title="Permalink to this headline">¶</a></h3>
+<p>If, in the formal computation history of the program, an object <tt class="docutils literal"><span class="pre">X</span></tt>
+has been deallocated by the time of an observable side-effect, then
+ARC must cause <tt class="docutils literal"><span class="pre">X</span></tt> to be deallocated by no later than the occurrence
+of that side-effect, except as influenced by the re-ordering of the
+destruction of objects.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p>This rule is intended to prohibit ARC from observably extending the
+lifetime of a retainable object, other than as specified in this
+document. Together with the rule limiting the transformation of
+releases, this rule requires ARC to eliminate retains and release
+only in pairs.</p>
+<p class="last">ARC’s power to reorder the destruction of objects is critical to its
+ability to do any optimization, for essentially the same reason that
+it must retain the power to decrease the lifetime of an object.
+Unfortunately, while it’s generally poor style for the destruction
+of objects to have arbitrary side-effects, it’s certainly possible.
+Hence the caveat.</p>
+</div>
+</div>
+<div class="section" id="precise-lifetime-semantics">
+<span id="arc-optimization-precise"></span><h3><a class="toc-backref" href="#id42">Precise lifetime semantics</a><a class="headerlink" href="#precise-lifetime-semantics" title="Permalink to this headline">¶</a></h3>
+<p>In general, ARC maintains an invariant that a retainable object pointer held in
+a <tt class="docutils literal"><span class="pre">__strong</span></tt> object will be retained for the full formal lifetime of the
+object. Objects subject to this invariant have <span class="arc-term">precise lifetime
+semantics</span>.</p>
+<p>By default, local variables of automatic storage duration do not have precise
+lifetime semantics. Such objects are simply strong references which hold
+values of retainable object pointer type, and these values are still fully
+subject to the optimizations on values under local control.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">Applying these precise-lifetime semantics strictly would be prohibitive.
+Many useful optimizations that might theoretically decrease the lifetime of
+an object would be rendered impossible. Essentially, it promises too much.</p>
+</div>
+<p>A local variable of retainable object owner type and automatic storage duration
+may be annotated with the <tt class="docutils literal"><span class="pre">objc_precise_lifetime</span></tt> attribute to indicate that
+it should be considered to be an object with precise lifetime semantics.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">Nonetheless, it is sometimes useful to be able to force an object to be
+released at a precise time, even if that object does not appear to be used.
+This is likely to be uncommon enough that the syntactic weight of explicitly
+requesting these semantics will not be burdensome, and may even make the code
+clearer.</p>
+</div>
+</div>
+</div>
+<div class="section" id="miscellaneous">
+<span id="arc-misc"></span><h2><a class="toc-backref" href="#id43">Miscellaneous</a><a class="headerlink" href="#miscellaneous" title="Permalink to this headline">¶</a></h2>
+<div class="section" id="special-methods">
+<span id="arc-misc-special-methods"></span><h3><a class="toc-backref" href="#id44">Special methods</a><a class="headerlink" href="#special-methods" title="Permalink to this headline">¶</a></h3>
+<div class="section" id="memory-management-methods">
+<span id="arc-misc-special-methods-retain"></span><h4><a class="toc-backref" href="#id45">Memory management methods</a><a class="headerlink" href="#memory-management-methods" title="Permalink to this headline">¶</a></h4>
+<p>A program is ill-formed if it contains a method definition, message send, or
+<tt class="docutils literal"><span class="pre">@selector</span></tt> expression for any of the following selectors:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">autorelease</span></tt></li>
+<li><tt class="docutils literal"><span class="pre">release</span></tt></li>
+<li><tt class="docutils literal"><span class="pre">retain</span></tt></li>
+<li><tt class="docutils literal"><span class="pre">retainCount</span></tt></li>
+</ul>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p><tt class="docutils literal"><span class="pre">retainCount</span></tt> is banned because ARC robs it of consistent semantics. The
+others were banned after weighing three options for how to deal with message
+sends:</p>
+<p><strong>Honoring</strong> them would work out very poorly if a programmer naively or
+accidentally tried to incorporate code written for manual retain/release code
+into an ARC program. At best, such code would do twice as much work as
+necessary; quite frequently, however, ARC and the explicit code would both
+try to balance the same retain, leading to crashes. The cost is losing the
+ability to perform “unrooted” retains, i.e. retains not logically
+corresponding to a strong reference in the object graph.</p>
+<p><strong>Ignoring</strong> them would badly violate user expectations about their code.
+While it <em>would</em> make it easier to develop code simultaneously for ARC and
+non-ARC, there is very little reason to do so except for certain library
+developers. ARC and non-ARC translation units share an execution model and
+can seamlessly interoperate. Within a translation unit, a developer who
+faithfully maintains their code in non-ARC mode is suffering all the
+restrictions of ARC for zero benefit, while a developer who isn’t testing the
+non-ARC mode is likely to be unpleasantly surprised if they try to go back to
+it.</p>
+<p><strong>Banning</strong> them has the disadvantage of making it very awkward to migrate
+existing code to ARC. The best answer to that, given a number of other
+changes and restrictions in ARC, is to provide a specialized tool to assist
+users in that migration.</p>
+<p class="last">Implementing these methods was banned because they are too integral to the
+semantics of ARC; many tricks which worked tolerably under manual reference
+counting will misbehave if ARC performs an ephemeral extra retain or two. If
+absolutely required, it is still possible to implement them in non-ARC code,
+for example in a category; the implementations must obey the <a class="reference internal" href="#arc-objects-retains"><em>semantics</em></a> laid out elsewhere in this document.</p>
+</div>
+</div>
+<div class="section" id="dealloc">
+<span id="arc-misc-special-methods-dealloc"></span><h4><a class="toc-backref" href="#id46"><tt class="docutils literal"><span class="pre">dealloc</span></tt></a><a class="headerlink" href="#dealloc" title="Permalink to this headline">¶</a></h4>
+<p>A program is ill-formed if it contains a message send or <tt class="docutils literal"><span class="pre">@selector</span></tt>
+expression for the selector <tt class="docutils literal"><span class="pre">dealloc</span></tt>.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">There are no legitimate reasons to call <tt class="docutils literal"><span class="pre">dealloc</span></tt> directly.</p>
+</div>
+<p>A class may provide a method definition for an instance method named
+<tt class="docutils literal"><span class="pre">dealloc</span></tt>. This method will be called after the final <tt class="docutils literal"><span class="pre">release</span></tt> of the
+object but before it is deallocated or any of its instance variables are
+destroyed. The superclass’s implementation of <tt class="docutils literal"><span class="pre">dealloc</span></tt> will be called
+automatically when the method returns.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">Even though ARC destroys instance variables automatically, there are still
+legitimate reasons to write a <tt class="docutils literal"><span class="pre">dealloc</span></tt> method, such as freeing
+non-retainable resources. Failing to call <tt class="docutils literal"><span class="pre">[super</span> <span class="pre">dealloc]</span></tt> in such a
+method is nearly always a bug. Sometimes, the object is simply trying to
+prevent itself from being destroyed, but <tt class="docutils literal"><span class="pre">dealloc</span></tt> is really far too late
+for the object to be raising such objections. Somewhat more legitimately, an
+object may have been pool-allocated and should not be deallocated with
+<tt class="docutils literal"><span class="pre">free</span></tt>; for now, this can only be supported with a <tt class="docutils literal"><span class="pre">dealloc</span></tt>
+implementation outside of ARC. Such an implementation must be very careful
+to do all the other work that <tt class="docutils literal"><span class="pre">NSObject</span></tt>‘s <tt class="docutils literal"><span class="pre">dealloc</span></tt> would, which is
+outside the scope of this document to describe.</p>
+</div>
+<p>The instance variables for an ARC-compiled class will be destroyed at some
+point after control enters the <tt class="docutils literal"><span class="pre">dealloc</span></tt> method for the root class of the
+class. The ordering of the destruction of instance variables is unspecified,
+both within a single class and between subclasses and superclasses.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p>The traditional, non-ARC pattern for destroying instance variables is to
+destroy them immediately before calling <tt class="docutils literal"><span class="pre">[super</span> <span class="pre">dealloc]</span></tt>. Unfortunately,
+message sends from the superclass are quite capable of reaching methods in
+the subclass, and those methods may well read or write to those instance
+variables. Making such message sends from dealloc is generally discouraged,
+since the subclass may well rely on other invariants that were broken during
+<tt class="docutils literal"><span class="pre">dealloc</span></tt>, but it’s not so inescapably dangerous that we felt comfortable
+calling it undefined behavior. Therefore we chose to delay destroying the
+instance variables to a point at which message sends are clearly disallowed:
+the point at which the root class’s deallocation routines take over.</p>
+<p class="last">In most code, the difference is not observable. It can, however, be observed
+if an instance variable holds a strong reference to an object whose
+deallocation will trigger a side-effect which must be carefully ordered with
+respect to the destruction of the super class. Such code violates the design
+principle that semantically important behavior should be explicit. A simple
+fix is to clear the instance variable manually during <tt class="docutils literal"><span class="pre">dealloc</span></tt>; a more
+holistic solution is to move semantically important side-effects out of
+<tt class="docutils literal"><span class="pre">dealloc</span></tt> and into a separate teardown phase which can rely on working with
+well-formed objects.</p>
+</div>
+</div>
+</div>
+<div class="section" id="autoreleasepool">
+<span id="arc-misc-autoreleasepool"></span><h3><a class="toc-backref" href="#id47"><tt class="docutils literal"><span class="pre">@autoreleasepool</span></tt></a><a class="headerlink" href="#autoreleasepool" title="Permalink to this headline">¶</a></h3>
+<p>To simplify the use of autorelease pools, and to bring them under the control
+of the compiler, a new kind of statement is available in Objective-C. It is
+written <tt class="docutils literal"><span class="pre">@autoreleasepool</span></tt> followed by a <em>compound-statement</em>, i.e. by a new
+scope delimited by curly braces. Upon entry to this block, the current state
+of the autorelease pool is captured. When the block is exited normally,
+whether by fallthrough or directed control flow (such as <tt class="docutils literal"><span class="pre">return</span></tt> or
+<tt class="docutils literal"><span class="pre">break</span></tt>), the autorelease pool is restored to the saved state, releasing all
+the objects in it. When the block is exited with an exception, the pool is not
+drained.</p>
+<p><tt class="docutils literal"><span class="pre">@autoreleasepool</span></tt> may be used in non-ARC translation units, with equivalent
+semantics.</p>
+<p>A program is ill-formed if it refers to the <tt class="docutils literal"><span class="pre">NSAutoreleasePool</span></tt> class.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">Autorelease pools are clearly important for the compiler to reason about, but
+it is far too much to expect the compiler to accurately reason about control
+dependencies between two calls. It is also very easy to accidentally forget
+to drain an autorelease pool when using the manual API, and this can
+significantly inflate the process’s high-water-mark. The introduction of a
+new scope is unfortunate but basically required for sane interaction with the
+rest of the language. Not draining the pool during an unwind is apparently
+required by the Objective-C exceptions implementation.</p>
+</div>
+</div>
+<div class="section" id="self">
+<span id="arc-misc-self"></span><h3><a class="toc-backref" href="#id48"><tt class="docutils literal"><span class="pre">self</span></tt></a><a class="headerlink" href="#self" title="Permalink to this headline">¶</a></h3>
+<p>The <tt class="docutils literal"><span class="pre">self</span></tt> parameter variable of an Objective-C method is never actually
+retained by the implementation. It is undefined behavior, or at least
+dangerous, to cause an object to be deallocated during a message send to that
+object.</p>
+<p>To make this safe, for Objective-C instance methods <tt class="docutils literal"><span class="pre">self</span></tt> is implicitly
+<tt class="docutils literal"><span class="pre">const</span></tt> unless the method is in the <a class="reference internal" href="#arc-family-semantics-init"><em>init family</em></a>. Further, <tt class="docutils literal"><span class="pre">self</span></tt> is <strong>always</strong> implicitly
+<tt class="docutils literal"><span class="pre">const</span></tt> within a class method.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">The cost of retaining <tt class="docutils literal"><span class="pre">self</span></tt> in all methods was found to be prohibitive, as
+it tends to be live across calls, preventing the optimizer from proving that
+the retain and release are unnecessary — for good reason, as it’s quite
+possible in theory to cause an object to be deallocated during its execution
+without this retain and release. Since it’s extremely uncommon to actually
+do so, even unintentionally, and since there’s no natural way for the
+programmer to remove this retain/release pair otherwise (as there is for
+other parameters by, say, making the variable <tt class="docutils literal"><span class="pre">__unsafe_unretained</span></tt>), we
+chose to make this optimizing assumption and shift some amount of risk to the
+user.</p>
+</div>
+</div>
+<div class="section" id="fast-enumeration-iteration-variables">
+<span id="arc-misc-enumeration"></span><h3><a class="toc-backref" href="#id49">Fast enumeration iteration variables</a><a class="headerlink" href="#fast-enumeration-iteration-variables" title="Permalink to this headline">¶</a></h3>
+<p>If a variable is declared in the condition of an Objective-C fast enumeration
+loop, and the variable has no explicit ownership qualifier, then it is
+qualified with <tt class="docutils literal"><span class="pre">const</span> <span class="pre">__strong</span></tt> and objects encountered during the
+enumeration are not actually retained.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">This is an optimization made possible because fast enumeration loops promise
+to keep the objects retained during enumeration, and the collection itself
+cannot be synchronously modified. It can be overridden by explicitly
+qualifying the variable with <tt class="docutils literal"><span class="pre">__strong</span></tt>, which will make the variable
+mutable again and cause the loop to retain the objects it encounters.</p>
+</div>
+</div>
+<div class="section" id="blocks">
+<span id="arc-misc-blocks"></span><h3><a class="toc-backref" href="#id50">Blocks</a><a class="headerlink" href="#blocks" title="Permalink to this headline">¶</a></h3>
+<p>The implicit <tt class="docutils literal"><span class="pre">const</span></tt> capture variables created when evaluating a block
+literal expression have the same ownership semantics as the local variables
+they capture. The capture is performed by reading from the captured variable
+and initializing the capture variable with that value; the capture variable is
+destroyed when the block literal is, i.e. at the end of the enclosing scope.</p>
+<p>The <a class="reference internal" href="#arc-ownership-inference"><em>inference</em></a> rules apply equally to
+<tt class="docutils literal"><span class="pre">__block</span></tt> variables, which is a shift in semantics from non-ARC, where
+<tt class="docutils literal"><span class="pre">__block</span></tt> variables did not implicitly retain during capture.</p>
+<p><tt class="docutils literal"><span class="pre">__block</span></tt> variables of retainable object owner type are moved off the stack
+by initializing the heap copy with the result of moving from the stack copy.</p>
+<p>With the exception of retains done as part of initializing a <tt class="docutils literal"><span class="pre">__strong</span></tt>
+parameter variable or reading a <tt class="docutils literal"><span class="pre">__weak</span></tt> variable, whenever these semantics
+call for retaining a value of block-pointer type, it has the effect of a
+<tt class="docutils literal"><span class="pre">Block_copy</span></tt>. The optimizer may remove such copies when it sees that the
+result is used only as an argument to a call.</p>
+</div>
+<div class="section" id="exceptions">
+<span id="arc-misc-exceptions"></span><h3><a class="toc-backref" href="#id51">Exceptions</a><a class="headerlink" href="#exceptions" title="Permalink to this headline">¶</a></h3>
+<p>By default in Objective C, ARC is not exception-safe for normal releases:</p>
+<ul class="simple">
+<li>It does not end the lifetime of <tt class="docutils literal"><span class="pre">__strong</span></tt> variables when their scopes are
+abnormally terminated by an exception.</li>
+<li>It does not perform releases which would occur at the end of a
+full-expression if that full-expression throws an exception.</li>
+</ul>
+<p>A program may be compiled with the option <tt class="docutils literal"><span class="pre">-fobjc-arc-exceptions</span></tt> in order to
+enable these, or with the option <tt class="docutils literal"><span class="pre">-fno-objc-arc-exceptions</span></tt> to explicitly
+disable them, with the last such argument “winning”.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">The standard Cocoa convention is that exceptions signal programmer error and
+are not intended to be recovered from. Making code exceptions-safe by
+default would impose severe runtime and code size penalties on code that
+typically does not actually care about exceptions safety. Therefore,
+ARC-generated code leaks by default on exceptions, which is just fine if the
+process is going to be immediately terminated anyway. Programs which do care
+about recovering from exceptions should enable the option.</p>
+</div>
+<p>In Objective-C++, <tt class="docutils literal"><span class="pre">-fobjc-arc-exceptions</span></tt> is enabled by default.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">C++ already introduces pervasive exceptions-cleanup code of the sort that ARC
+introduces. C++ programmers who have not already disabled exceptions are
+much more likely to actual require exception-safety.</p>
+</div>
+<p>ARC does end the lifetimes of <tt class="docutils literal"><span class="pre">__weak</span></tt> objects when an exception terminates
+their scope unless exceptions are disabled in the compiler.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">The consequence of a local <tt class="docutils literal"><span class="pre">__weak</span></tt> object not being destroyed is very
+likely to be corruption of the Objective-C runtime, so we want to be safer
+here. Of course, potentially massive leaks are about as likely to take down
+the process as this corruption is if the program does try to recover from
+exceptions.</p>
+</div>
+</div>
+<div class="section" id="interior-pointers">
+<span id="arc-misc-interior"></span><h3><a class="toc-backref" href="#id52">Interior pointers</a><a class="headerlink" href="#interior-pointers" title="Permalink to this headline">¶</a></h3>
+<p>An Objective-C method returning a non-retainable pointer may be annotated with
+the <tt class="docutils literal"><span class="pre">objc_returns_inner_pointer</span></tt> attribute to indicate that it returns a
+handle to the internal data of an object, and that this reference will be
+invalidated if the object is destroyed. When such a message is sent to an
+object, the object’s lifetime will be extended until at least the earliest of:</p>
+<ul class="simple">
+<li>the last use of the returned pointer, or any pointer derived from it, in the
+calling function or</li>
+<li>the autorelease pool is restored to a previous state.</li>
+</ul>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p>Rationale: not all memory and resources are managed with reference counts; it
+is common for objects to manage private resources in their own, private way.
+Typically these resources are completely encapsulated within the object, but
+some classes offer their users direct access for efficiency. If ARC is not
+aware of methods that return such “interior” pointers, its optimizations can
+cause the owning object to be reclaimed too soon. This attribute informs ARC
+that it must tread lightly.</p>
+<p class="last">The extension rules are somewhat intentionally vague. The autorelease pool
+limit is there to permit a simple implementation to simply retain and
+autorelease the receiver. The other limit permits some amount of
+optimization. The phrase “derived from” is intended to encompass the results
+both of pointer transformations, such as casts and arithmetic, and of loading
+from such derived pointers; furthermore, it applies whether or not such
+derivations are applied directly in the calling code or by other utility code
+(for example, the C library routine <tt class="docutils literal"><span class="pre">strchr</span></tt>). However, the implementation
+never need account for uses after a return from the code which calls the
+method returning an interior pointer.</p>
+</div>
+<p>As an exception, no extension is required if the receiver is loaded directly
+from a <tt class="docutils literal"><span class="pre">__strong</span></tt> object with <a class="reference internal" href="#arc-optimization-precise"><em>precise lifetime semantics</em></a>.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">Implicit autoreleases carry the risk of significantly inflating memory use,
+so it’s important to provide users a way of avoiding these autoreleases.
+Tying this to precise lifetime semantics is ideal, as for local variables
+this requires a very explicit annotation, which allows ARC to trust the user
+with good cheer.</p>
+</div>
+</div>
+<div class="section" id="c-retainable-pointer-types">
+<span id="arc-misc-c-retainable"></span><h3><a class="toc-backref" href="#id53">C retainable pointer types</a><a class="headerlink" href="#c-retainable-pointer-types" title="Permalink to this headline">¶</a></h3>
+<p>A type is a <span class="arc-term">C retainable pointer type</span> if it is a pointer to
+(possibly qualified) <tt class="docutils literal"><span class="pre">void</span></tt> or a pointer to a (possibly qualifier) <tt class="docutils literal"><span class="pre">struct</span></tt>
+or <tt class="docutils literal"><span class="pre">class</span></tt> type.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">ARC does not manage pointers of CoreFoundation type (or any of the related
+families of retainable C pointers which interoperate with Objective-C for
+retain/release operation). In fact, ARC does not even know how to
+distinguish these types from arbitrary C pointer types. The intent of this
+concept is to filter out some obviously non-object types while leaving a hook
+for later tightening if a means of exhaustively marking CF types is made
+available.</p>
+</div>
+<div class="section" id="auditing-of-c-retainable-pointer-interfaces">
+<span id="arc-misc-c-retainable-audit"></span><h4><a class="toc-backref" href="#id54">Auditing of C retainable pointer interfaces</a><a class="headerlink" href="#auditing-of-c-retainable-pointer-interfaces" title="Permalink to this headline">¶</a></h4>
+<p><span class="when-revised">[beginning Apple 4.0, LLVM 3.1]</span></p>
+<p>A C function may be marked with the <tt class="docutils literal"><span class="pre">cf_audited_transfer</span></tt> attribute to
+express that, except as otherwise marked with attributes, it obeys the
+parameter (consuming vs. non-consuming) and return (retained vs. non-retained)
+conventions for a C function of its name, namely:</p>
+<ul class="simple">
+<li>A parameter of C retainable pointer type is assumed to not be consumed
+unless it is marked with the <tt class="docutils literal"><span class="pre">cf_consumed</span></tt> attribute, and</li>
+<li>A result of C retainable pointer type is assumed to not be returned retained
+unless the function is either marked <tt class="docutils literal"><span class="pre">cf_returns_retained</span></tt> or it follows
+the create/copy naming convention and is not marked
+<tt class="docutils literal"><span class="pre">cf_returns_not_retained</span></tt>.</li>
+</ul>
+<p>A function obeys the <span class="arc-term">create/copy</span> naming convention if its name
+contains as a substring:</p>
+<ul class="simple">
+<li>either “Create” or “Copy” not followed by a lowercase letter, or</li>
+<li>either “create” or “copy” not followed by a lowercase letter and
+not preceded by any letter, whether uppercase or lowercase.</li>
+</ul>
+<p>A second attribute, <tt class="docutils literal"><span class="pre">cf_unknown_transfer</span></tt>, signifies that a function’s
+transfer semantics cannot be accurately captured using any of these
+annotations. A program is ill-formed if it annotates the same function with
+both <tt class="docutils literal"><span class="pre">cf_audited_transfer</span></tt> and <tt class="docutils literal"><span class="pre">cf_unknown_transfer</span></tt>.</p>
+<p>A pragma is provided to facilitate the mass annotation of interfaces:</p>
+<div class="highlight-objc"><div class="highlight"><pre><span class="cp">#pragma clang arc_cf_code_audited begin</span>
+<span class="p">...</span>
+<span class="cp">#pragma clang arc_cf_code_audited end</span>
+</pre></div>
+</div>
+<p>All C functions declared within the extent of this pragma are treated as if
+annotated with the <tt class="docutils literal"><span class="pre">cf_audited_transfer</span></tt> attribute unless they otherwise have
+the <tt class="docutils literal"><span class="pre">cf_unknown_transfer</span></tt> attribute. The pragma is accepted in all language
+modes. A program is ill-formed if it attempts to change files, whether by
+including a file or ending the current file, within the extent of this pragma.</p>
+<p>It is possible to test for all the features in this section with
+<tt class="docutils literal"><span class="pre">__has_feature(arc_cf_code_audited)</span></tt>.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">A significant inconvenience in ARC programming is the necessity of
+interacting with APIs based around C retainable pointers. These features are
+designed to make it relatively easy for API authors to quickly review and
+annotate their interfaces, in turn improving the fidelity of tools such as
+the static analyzer and ARC. The single-file restriction on the pragma is
+designed to eliminate the risk of accidentally annotating some other header’s
+interfaces.</p>
+</div>
+</div>
+</div>
+</div>
+<div class="section" id="runtime-support">
+<span id="arc-runtime"></span><h2><a class="toc-backref" href="#id55">Runtime support</a><a class="headerlink" href="#runtime-support" title="Permalink to this headline">¶</a></h2>
+<p>This section describes the interaction between the ARC runtime and the code
+generated by the ARC compiler. This is not part of the ARC language
+specification; instead, it is effectively a language-specific ABI supplement,
+akin to the “Itanium” generic ABI for C++.</p>
+<p>Ownership qualification does not alter the storage requirements for objects,
+except that it is undefined behavior if a <tt class="docutils literal"><span class="pre">__weak</span></tt> object is inadequately
+aligned for an object of type <tt class="docutils literal"><span class="pre">id</span></tt>. The other qualifiers may be used on
+explicitly under-aligned memory.</p>
+<p>The runtime tracks <tt class="docutils literal"><span class="pre">__weak</span></tt> objects which holds non-null values. It is
+undefined behavior to direct modify a <tt class="docutils literal"><span class="pre">__weak</span></tt> object which is being tracked
+by the runtime except through an
+<a class="reference internal" href="#arc-runtime-objc-storeweak"><em>objc_storeWeak</em></a>,
+<a class="reference internal" href="#arc-runtime-objc-destroyweak"><em>objc_destroyWeak</em></a>, or
+<a class="reference internal" href="#arc-runtime-objc-moveweak"><em>objc_moveWeak</em></a> call.</p>
+<p>The runtime must provide a number of new entrypoints which the compiler may
+emit, which are described in the remainder of this section.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p>Several of these functions are semantically equivalent to a message send; we
+emit calls to C functions instead because:</p>
+<ul class="simple">
+<li>the machine code to do so is significantly smaller,</li>
+<li>it is much easier to recognize the C functions in the ARC optimizer, and</li>
+<li>a sufficient sophisticated runtime may be able to avoid the message send in
+common cases.</li>
+</ul>
+<p class="last">Several other of these functions are “fused” operations which can be
+described entirely in terms of other operations. We use the fused operations
+primarily as a code-size optimization, although in some cases there is also a
+real potential for avoiding redundant operations in the runtime.</p>
+</div>
+<div class="section" id="arc-runtime-objc-autorelease">
+<span id="id-objc-autorelease-id-value"></span><h3><a class="toc-backref" href="#id56"><tt class="docutils literal"><span class="pre">id</span> <span class="pre">objc_autorelease(id</span> <span class="pre">value);</span></tt></a><a class="headerlink" href="#arc-runtime-objc-autorelease" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <tt class="docutils literal"><span class="pre">value</span></tt> is null or a pointer to a valid object.</p>
+<p>If <tt class="docutils literal"><span class="pre">value</span></tt> is null, this call has no effect. Otherwise, it adds the object
+to the innermost autorelease pool exactly as if the object had been sent the
+<tt class="docutils literal"><span class="pre">autorelease</span></tt> message.</p>
+<p>Always returns <tt class="docutils literal"><span class="pre">value</span></tt>.</p>
+</div>
+<div class="section" id="void-objc-autoreleasepoolpop-void-pool">
+<span id="arc-runtime-objc-autoreleasepoolpop"></span><h3><a class="toc-backref" href="#id57"><tt class="docutils literal"><span class="pre">void</span> <span class="pre">objc_autoreleasePoolPop(void</span> <span class="pre">*pool);</span></tt></a><a class="headerlink" href="#void-objc-autoreleasepoolpop-void-pool" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <tt class="docutils literal"><span class="pre">pool</span></tt> is the result of a previous call to
+<a class="reference internal" href="#arc-runtime-objc-autoreleasepoolpush"><em>objc_autoreleasePoolPush</em></a> on the
+current thread, where neither <tt class="docutils literal"><span class="pre">pool</span></tt> nor any enclosing pool have previously
+been popped.</p>
+<p>Releases all the objects added to the given autorelease pool and any
+autorelease pools it encloses, then sets the current autorelease pool to the
+pool directly enclosing <tt class="docutils literal"><span class="pre">pool</span></tt>.</p>
+</div>
+<div class="section" id="void-objc-autoreleasepoolpush-void">
+<span id="arc-runtime-objc-autoreleasepoolpush"></span><h3><a class="toc-backref" href="#id58"><tt class="docutils literal"><span class="pre">void</span> <span class="pre">*objc_autoreleasePoolPush(void);</span></tt></a><a class="headerlink" href="#void-objc-autoreleasepoolpush-void" title="Permalink to this headline">¶</a></h3>
+<p>Creates a new autorelease pool that is enclosed by the current pool, makes that
+the current pool, and returns an opaque “handle” to it.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">While the interface is described as an explicit hierarchy of pools, the rules
+allow the implementation to just keep a stack of objects, using the stack
+depth as the opaque pool handle.</p>
+</div>
+</div>
+<div class="section" id="arc-runtime-objc-autoreleasereturnvalue">
+<span id="id-objc-autoreleasereturnvalue-id-value"></span><h3><a class="toc-backref" href="#id59"><tt class="docutils literal"><span class="pre">id</span> <span class="pre">objc_autoreleaseReturnValue(id</span> <span class="pre">value);</span></tt></a><a class="headerlink" href="#arc-runtime-objc-autoreleasereturnvalue" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <tt class="docutils literal"><span class="pre">value</span></tt> is null or a pointer to a valid object.</p>
+<p>If <tt class="docutils literal"><span class="pre">value</span></tt> is null, this call has no effect. Otherwise, it makes a best
+effort to hand off ownership of a retain count on the object to a call to
+<a class="reference internal" href="#arc-runtime-objc-retainautoreleasedreturnvalue"><em>objc_retainAutoreleasedReturnValue</em></a> for the same object in an
+enclosing call frame. If this is not possible, the object is autoreleased as
+above.</p>
+<p>Always returns <tt class="docutils literal"><span class="pre">value</span></tt>.</p>
+</div>
+<div class="section" id="void-objc-copyweak-id-dest-id-src">
+<span id="arc-runtime-objc-copyweak"></span><h3><a class="toc-backref" href="#id60"><tt class="docutils literal"><span class="pre">void</span> <span class="pre">objc_copyWeak(id</span> <span class="pre">*dest,</span> <span class="pre">id</span> <span class="pre">*src);</span></tt></a><a class="headerlink" href="#void-objc-copyweak-id-dest-id-src" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <tt class="docutils literal"><span class="pre">src</span></tt> is a valid pointer which either contains a null pointer
+or has been registered as a <tt class="docutils literal"><span class="pre">__weak</span></tt> object. <tt class="docutils literal"><span class="pre">dest</span></tt> is a valid pointer
+which has not been registered as a <tt class="docutils literal"><span class="pre">__weak</span></tt> object.</p>
+<p><tt class="docutils literal"><span class="pre">dest</span></tt> is initialized to be equivalent to <tt class="docutils literal"><span class="pre">src</span></tt>, potentially registering it
+with the runtime. Equivalent to the following code:</p>
+<div class="highlight-objc"><div class="highlight"><pre><span class="kt">void</span> <span class="nf">objc_copyWeak</span><span class="p">(</span><span class="kt">id</span> <span class="o">*</span><span class="n">dest</span><span class="p">,</span> <span class="kt">id</span> <span class="o">*</span><span class="n">src</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">objc_release</span><span class="p">(</span><span class="n">objc_initWeak</span><span class="p">(</span><span class="n">dest</span><span class="p">,</span> <span class="n">objc_loadWeakRetained</span><span class="p">(</span><span class="n">src</span><span class="p">)));</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>Must be atomic with respect to calls to <tt class="docutils literal"><span class="pre">objc_storeWeak</span></tt> on <tt class="docutils literal"><span class="pre">src</span></tt>.</p>
+</div>
+<div class="section" id="void-objc-destroyweak-id-object">
+<span id="arc-runtime-objc-destroyweak"></span><h3><a class="toc-backref" href="#id61"><tt class="docutils literal"><span class="pre">void</span> <span class="pre">objc_destroyWeak(id</span> <span class="pre">*object);</span></tt></a><a class="headerlink" href="#void-objc-destroyweak-id-object" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <tt class="docutils literal"><span class="pre">object</span></tt> is a valid pointer which either contains a null
+pointer or has been registered as a <tt class="docutils literal"><span class="pre">__weak</span></tt> object.</p>
+<p><tt class="docutils literal"><span class="pre">object</span></tt> is unregistered as a weak object, if it ever was. The current value
+of <tt class="docutils literal"><span class="pre">object</span></tt> is left unspecified; otherwise, equivalent to the following code:</p>
+<div class="highlight-objc"><div class="highlight"><pre><span class="kt">void</span> <span class="nf">objc_destroyWeak</span><span class="p">(</span><span class="kt">id</span> <span class="o">*</span><span class="n">object</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">objc_storeWeak</span><span class="p">(</span><span class="n">object</span><span class="p">,</span> <span class="nb">nil</span><span class="p">);</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>Does not need to be atomic with respect to calls to <tt class="docutils literal"><span class="pre">objc_storeWeak</span></tt> on
+<tt class="docutils literal"><span class="pre">object</span></tt>.</p>
+</div>
+<div class="section" id="arc-runtime-objc-initweak">
+<span id="id-objc-initweak-id-object-id-value"></span><h3><a class="toc-backref" href="#id62"><tt class="docutils literal"><span class="pre">id</span> <span class="pre">objc_initWeak(id</span> <span class="pre">*object,</span> <span class="pre">id</span> <span class="pre">value);</span></tt></a><a class="headerlink" href="#arc-runtime-objc-initweak" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <tt class="docutils literal"><span class="pre">object</span></tt> is a valid pointer which has not been registered as
+a <tt class="docutils literal"><span class="pre">__weak</span></tt> object. <tt class="docutils literal"><span class="pre">value</span></tt> is null or a pointer to a valid object.</p>
+<p>If <tt class="docutils literal"><span class="pre">value</span></tt> is a null pointer or the object to which it points has begun
+deallocation, <tt class="docutils literal"><span class="pre">object</span></tt> is zero-initialized. Otherwise, <tt class="docutils literal"><span class="pre">object</span></tt> is
+registered as a <tt class="docutils literal"><span class="pre">__weak</span></tt> object pointing to <tt class="docutils literal"><span class="pre">value</span></tt>. Equivalent to the
+following code:</p>
+<div class="highlight-objc"><div class="highlight"><pre><span class="kt">id</span> <span class="nf">objc_initWeak</span><span class="p">(</span><span class="kt">id</span> <span class="o">*</span><span class="n">object</span><span class="p">,</span> <span class="kt">id</span> <span class="n">value</span><span class="p">)</span> <span class="p">{</span>
+ <span class="o">*</span><span class="n">object</span> <span class="o">=</span> <span class="nb">nil</span><span class="p">;</span>
+ <span class="k">return</span> <span class="n">objc_storeWeak</span><span class="p">(</span><span class="n">object</span><span class="p">,</span> <span class="n">value</span><span class="p">);</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>Returns the value of <tt class="docutils literal"><span class="pre">object</span></tt> after the call.</p>
+<p>Does not need to be atomic with respect to calls to <tt class="docutils literal"><span class="pre">objc_storeWeak</span></tt> on
+<tt class="docutils literal"><span class="pre">object</span></tt>.</p>
+</div>
+<div class="section" id="arc-runtime-objc-loadweak">
+<span id="id-objc-loadweak-id-object"></span><h3><a class="toc-backref" href="#id63"><tt class="docutils literal"><span class="pre">id</span> <span class="pre">objc_loadWeak(id</span> <span class="pre">*object);</span></tt></a><a class="headerlink" href="#arc-runtime-objc-loadweak" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <tt class="docutils literal"><span class="pre">object</span></tt> is a valid pointer which either contains a null
+pointer or has been registered as a <tt class="docutils literal"><span class="pre">__weak</span></tt> object.</p>
+<p>If <tt class="docutils literal"><span class="pre">object</span></tt> is registered as a <tt class="docutils literal"><span class="pre">__weak</span></tt> object, and the last value stored
+into <tt class="docutils literal"><span class="pre">object</span></tt> has not yet been deallocated or begun deallocation, retains and
+autoreleases that value and returns it. Otherwise returns null. Equivalent to
+the following code:</p>
+<div class="highlight-objc"><div class="highlight"><pre><span class="kt">id</span> <span class="nf">objc_loadWeak</span><span class="p">(</span><span class="kt">id</span> <span class="o">*</span><span class="n">object</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="n">objc_autorelease</span><span class="p">(</span><span class="n">objc_loadWeakRetained</span><span class="p">(</span><span class="n">object</span><span class="p">));</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>Must be atomic with respect to calls to <tt class="docutils literal"><span class="pre">objc_storeWeak</span></tt> on <tt class="docutils literal"><span class="pre">object</span></tt>.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">Loading weak references would be inherently prone to race conditions without
+the retain.</p>
+</div>
+</div>
+<div class="section" id="arc-runtime-objc-loadweakretained">
+<span id="id-objc-loadweakretained-id-object"></span><h3><a class="toc-backref" href="#id64"><tt class="docutils literal"><span class="pre">id</span> <span class="pre">objc_loadWeakRetained(id</span> <span class="pre">*object);</span></tt></a><a class="headerlink" href="#arc-runtime-objc-loadweakretained" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <tt class="docutils literal"><span class="pre">object</span></tt> is a valid pointer which either contains a null
+pointer or has been registered as a <tt class="docutils literal"><span class="pre">__weak</span></tt> object.</p>
+<p>If <tt class="docutils literal"><span class="pre">object</span></tt> is registered as a <tt class="docutils literal"><span class="pre">__weak</span></tt> object, and the last value stored
+into <tt class="docutils literal"><span class="pre">object</span></tt> has not yet been deallocated or begun deallocation, retains
+that value and returns it. Otherwise returns null.</p>
+<p>Must be atomic with respect to calls to <tt class="docutils literal"><span class="pre">objc_storeWeak</span></tt> on <tt class="docutils literal"><span class="pre">object</span></tt>.</p>
+</div>
+<div class="section" id="void-objc-moveweak-id-dest-id-src">
+<span id="arc-runtime-objc-moveweak"></span><h3><a class="toc-backref" href="#id65"><tt class="docutils literal"><span class="pre">void</span> <span class="pre">objc_moveWeak(id</span> <span class="pre">*dest,</span> <span class="pre">id</span> <span class="pre">*src);</span></tt></a><a class="headerlink" href="#void-objc-moveweak-id-dest-id-src" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <tt class="docutils literal"><span class="pre">src</span></tt> is a valid pointer which either contains a null pointer
+or has been registered as a <tt class="docutils literal"><span class="pre">__weak</span></tt> object. <tt class="docutils literal"><span class="pre">dest</span></tt> is a valid pointer
+which has not been registered as a <tt class="docutils literal"><span class="pre">__weak</span></tt> object.</p>
+<p><tt class="docutils literal"><span class="pre">dest</span></tt> is initialized to be equivalent to <tt class="docutils literal"><span class="pre">src</span></tt>, potentially registering it
+with the runtime. <tt class="docutils literal"><span class="pre">src</span></tt> may then be left in its original state, in which
+case this call is equivalent to <a class="reference internal" href="#arc-runtime-objc-copyweak"><em>objc_copyWeak</em></a>, or it may be left as null.</p>
+<p>Must be atomic with respect to calls to <tt class="docutils literal"><span class="pre">objc_storeWeak</span></tt> on <tt class="docutils literal"><span class="pre">src</span></tt>.</p>
+</div>
+<div class="section" id="void-objc-release-id-value">
+<span id="arc-runtime-objc-release"></span><h3><a class="toc-backref" href="#id66"><tt class="docutils literal"><span class="pre">void</span> <span class="pre">objc_release(id</span> <span class="pre">value);</span></tt></a><a class="headerlink" href="#void-objc-release-id-value" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <tt class="docutils literal"><span class="pre">value</span></tt> is null or a pointer to a valid object.</p>
+<p>If <tt class="docutils literal"><span class="pre">value</span></tt> is null, this call has no effect. Otherwise, it performs a
+release operation exactly as if the object had been sent the <tt class="docutils literal"><span class="pre">release</span></tt>
+message.</p>
+</div>
+<div class="section" id="arc-runtime-objc-retain">
+<span id="id-objc-retain-id-value"></span><h3><a class="toc-backref" href="#id67"><tt class="docutils literal"><span class="pre">id</span> <span class="pre">objc_retain(id</span> <span class="pre">value);</span></tt></a><a class="headerlink" href="#arc-runtime-objc-retain" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <tt class="docutils literal"><span class="pre">value</span></tt> is null or a pointer to a valid object.</p>
+<p>If <tt class="docutils literal"><span class="pre">value</span></tt> is null, this call has no effect. Otherwise, it performs a retain
+operation exactly as if the object had been sent the <tt class="docutils literal"><span class="pre">retain</span></tt> message.</p>
+<p>Always returns <tt class="docutils literal"><span class="pre">value</span></tt>.</p>
+</div>
+<div class="section" id="arc-runtime-objc-retainautorelease">
+<span id="id-objc-retainautorelease-id-value"></span><h3><a class="toc-backref" href="#id68"><tt class="docutils literal"><span class="pre">id</span> <span class="pre">objc_retainAutorelease(id</span> <span class="pre">value);</span></tt></a><a class="headerlink" href="#arc-runtime-objc-retainautorelease" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <tt class="docutils literal"><span class="pre">value</span></tt> is null or a pointer to a valid object.</p>
+<p>If <tt class="docutils literal"><span class="pre">value</span></tt> is null, this call has no effect. Otherwise, it performs a retain
+operation followed by an autorelease operation. Equivalent to the following
+code:</p>
+<div class="highlight-objc"><div class="highlight"><pre><span class="kt">id</span> <span class="nf">objc_retainAutorelease</span><span class="p">(</span><span class="kt">id</span> <span class="n">value</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="n">objc_autorelease</span><span class="p">(</span><span class="n">objc_retain</span><span class="p">(</span><span class="n">value</span><span class="p">));</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>Always returns <tt class="docutils literal"><span class="pre">value</span></tt>.</p>
+</div>
+<div class="section" id="arc-runtime-objc-retainautoreleasereturnvalue">
+<span id="id-objc-retainautoreleasereturnvalue-id-value"></span><h3><a class="toc-backref" href="#id69"><tt class="docutils literal"><span class="pre">id</span> <span class="pre">objc_retainAutoreleaseReturnValue(id</span> <span class="pre">value);</span></tt></a><a class="headerlink" href="#arc-runtime-objc-retainautoreleasereturnvalue" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <tt class="docutils literal"><span class="pre">value</span></tt> is null or a pointer to a valid object.</p>
+<p>If <tt class="docutils literal"><span class="pre">value</span></tt> is null, this call has no effect. Otherwise, it performs a retain
+operation followed by the operation described in
+<a class="reference internal" href="#arc-runtime-objc-autoreleasereturnvalue"><em>objc_autoreleaseReturnValue</em></a>.
+Equivalent to the following code:</p>
+<div class="highlight-objc"><div class="highlight"><pre><span class="kt">id</span> <span class="nf">objc_retainAutoreleaseReturnValue</span><span class="p">(</span><span class="kt">id</span> <span class="n">value</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="n">objc_autoreleaseReturnValue</span><span class="p">(</span><span class="n">objc_retain</span><span class="p">(</span><span class="n">value</span><span class="p">));</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>Always returns <tt class="docutils literal"><span class="pre">value</span></tt>.</p>
+</div>
+<div class="section" id="arc-runtime-objc-retainautoreleasedreturnvalue">
+<span id="id-objc-retainautoreleasedreturnvalue-id-value"></span><h3><a class="toc-backref" href="#id70"><tt class="docutils literal"><span class="pre">id</span> <span class="pre">objc_retainAutoreleasedReturnValue(id</span> <span class="pre">value);</span></tt></a><a class="headerlink" href="#arc-runtime-objc-retainautoreleasedreturnvalue" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <tt class="docutils literal"><span class="pre">value</span></tt> is null or a pointer to a valid object.</p>
+<p>If <tt class="docutils literal"><span class="pre">value</span></tt> is null, this call has no effect. Otherwise, it attempts to
+accept a hand off of a retain count from a call to
+<a class="reference internal" href="#arc-runtime-objc-autoreleasereturnvalue"><em>objc_autoreleaseReturnValue</em></a> on
+<tt class="docutils literal"><span class="pre">value</span></tt> in a recently-called function or something it calls. If that fails,
+it performs a retain operation exactly like <a class="reference internal" href="#arc-runtime-objc-retain"><em>objc_retain</em></a>.</p>
+<p>Always returns <tt class="docutils literal"><span class="pre">value</span></tt>.</p>
+</div>
+<div class="section" id="arc-runtime-objc-retainblock">
+<span id="id-objc-retainblock-id-value"></span><h3><a class="toc-backref" href="#id71"><tt class="docutils literal"><span class="pre">id</span> <span class="pre">objc_retainBlock(id</span> <span class="pre">value);</span></tt></a><a class="headerlink" href="#arc-runtime-objc-retainblock" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <tt class="docutils literal"><span class="pre">value</span></tt> is null or a pointer to a valid block object.</p>
+<p>If <tt class="docutils literal"><span class="pre">value</span></tt> is null, this call has no effect. Otherwise, if the block pointed
+to by <tt class="docutils literal"><span class="pre">value</span></tt> is still on the stack, it is copied to the heap and the address
+of the copy is returned. Otherwise a retain operation is performed on the
+block exactly as if it had been sent the <tt class="docutils literal"><span class="pre">retain</span></tt> message.</p>
+</div>
+<div class="section" id="arc-runtime-objc-storestrong">
+<span id="id-objc-storestrong-id-object-id-value"></span><h3><a class="toc-backref" href="#id72"><tt class="docutils literal"><span class="pre">id</span> <span class="pre">objc_storeStrong(id</span> <span class="pre">*object,</span> <span class="pre">id</span> <span class="pre">value);</span></tt></a><a class="headerlink" href="#arc-runtime-objc-storestrong" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <tt class="docutils literal"><span class="pre">object</span></tt> is a valid pointer to a <tt class="docutils literal"><span class="pre">__strong</span></tt> object which is
+adequately aligned for a pointer. <tt class="docutils literal"><span class="pre">value</span></tt> is null or a pointer to a valid
+object.</p>
+<p>Performs the complete sequence for assigning to a <tt class="docutils literal"><span class="pre">__strong</span></tt> object of
+non-block type <a class="footnote-reference" href="#id3" id="id2">[*]</a>. Equivalent to the following code:</p>
+<div class="highlight-objc"><div class="highlight"><pre><span class="kt">void</span> <span class="nf">objc_storeStrong</span><span class="p">(</span><span class="kt">id</span> <span class="o">*</span><span class="n">object</span><span class="p">,</span> <span class="kt">id</span> <span class="n">value</span><span class="p">)</span> <span class="p">{</span>
+ <span class="kt">id</span> <span class="n">oldValue</span> <span class="o">=</span> <span class="o">*</span><span class="n">object</span><span class="p">;</span>
+ <span class="n">value</span> <span class="o">=</span> <span class="p">[</span><span class="n">value</span> <span class="n">retain</span><span class="p">];</span>
+ <span class="o">*</span><span class="n">object</span> <span class="o">=</span> <span class="n">value</span><span class="p">;</span>
+ <span class="p">[</span><span class="n">oldValue</span> <span class="n">release</span><span class="p">];</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<table class="docutils footnote" frame="void" id="id3" rules="none">
+<colgroup><col class="label" /><col /></colgroup>
+<tbody valign="top">
+<tr><td class="label"><a class="fn-backref" href="#id2">[*]</a></td><td>This does not imply that a <tt class="docutils literal"><span class="pre">__strong</span></tt> object of block type is an
+invalid argument to this function. Rather it implies that an <tt class="docutils literal"><span class="pre">objc_retain</span></tt>
+and not an <tt class="docutils literal"><span class="pre">objc_retainBlock</span></tt> operation will be emitted if the argument is
+a block.</td></tr>
+</tbody>
+</table>
+</div>
+<div class="section" id="arc-runtime-objc-storeweak">
+<span id="id-objc-storeweak-id-object-id-value"></span><h3><a class="toc-backref" href="#id73"><tt class="docutils literal"><span class="pre">id</span> <span class="pre">objc_storeWeak(id</span> <span class="pre">*object,</span> <span class="pre">id</span> <span class="pre">value);</span></tt></a><a class="headerlink" href="#arc-runtime-objc-storeweak" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <tt class="docutils literal"><span class="pre">object</span></tt> is a valid pointer which either contains a null
+pointer or has been registered as a <tt class="docutils literal"><span class="pre">__weak</span></tt> object. <tt class="docutils literal"><span class="pre">value</span></tt> is null or a
+pointer to a valid object.</p>
+<p>If <tt class="docutils literal"><span class="pre">value</span></tt> is a null pointer or the object to which it points has begun
+deallocation, <tt class="docutils literal"><span class="pre">object</span></tt> is assigned null and unregistered as a <tt class="docutils literal"><span class="pre">__weak</span></tt>
+object. Otherwise, <tt class="docutils literal"><span class="pre">object</span></tt> is registered as a <tt class="docutils literal"><span class="pre">__weak</span></tt> object or has its
+registration updated to point to <tt class="docutils literal"><span class="pre">value</span></tt>.</p>
+<p>Returns the value of <tt class="docutils literal"><span class="pre">object</span></tt> after the call.</p>
+</div>
+</div>
+</div>
+
+
+ </div>
+ <div class="bottomnav">
+
+ <p>
+ « <a href="Block-ABI-Apple.html">Block Implementation Specification</a>
+ ::
+ <a class="uplink" href="index.html">Contents</a>
+ ::
+ <a href="ClangCommandLineReference.html">Clang command line argument reference</a> »
+ </p>
+
+ </div>
+
+ <div class="footer">
+ © Copyright 2007-2018, The Clang Team.
+ Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/6.0.1/tools/clang/docs/Block-ABI-Apple.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/6.0.1/tools/clang/docs/Block-ABI-Apple.html?rev=336152&view=auto
==============================================================================
--- www-releases/trunk/6.0.1/tools/clang/docs/Block-ABI-Apple.html (added)
+++ www-releases/trunk/6.0.1/tools/clang/docs/Block-ABI-Apple.html Mon Jul 2 16:21:43 2018
@@ -0,0 +1,913 @@
+
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+ <title>Block Implementation Specification — Clang 6 documentation</title>
+
+ <link rel="stylesheet" href="_static/haiku.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+ <link rel="stylesheet" href="_static/print.css" type="text/css" />
+
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: '',
+ VERSION: '6',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true
+ };
+ </script>
+ <script type="text/javascript" src="_static/jquery.js"></script>
+ <script type="text/javascript" src="_static/underscore.js"></script>
+ <script type="text/javascript" src="_static/doctools.js"></script>
+ <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+ <script type="text/javascript" src="_static/theme_extras.js"></script>
+ <link rel="top" title="Clang 6 documentation" href="index.html" />
+ <link rel="up" title="Clang Language Extensions" href="LanguageExtensions.html" />
+ <link rel="next" title="Objective-C Automatic Reference Counting (ARC)" href="AutomaticReferenceCounting.html" />
+ <link rel="prev" title="Language Specification for Blocks" href="BlockLanguageSpec.html" />
+ </head>
+ <body>
+ <div class="header"><h1 class="heading"><a href="index.html">
+ <span>Clang 6 documentation</span></a></h1>
+ <h2 class="heading"><span>Block Implementation Specification</span></h2>
+ </div>
+ <div class="topnav">
+
+ <p>
+ « <a href="BlockLanguageSpec.html">Language Specification for Blocks</a>
+ ::
+ <a class="uplink" href="index.html">Contents</a>
+ ::
+ <a href="AutomaticReferenceCounting.html">Objective-C Automatic Reference Counting (ARC)</a> »
+ </p>
+
+ </div>
+ <div class="content">
+
+
+ <div class="section" id="block-implementation-specification">
+<h1>Block Implementation Specification<a class="headerlink" href="#block-implementation-specification" title="Permalink to this headline">¶</a></h1>
+<div class="contents local topic" id="contents">
+<ul class="simple">
+<li><a class="reference internal" href="#history" id="id1">History</a></li>
+<li><a class="reference internal" href="#high-level" id="id2">High Level</a></li>
+<li><a class="reference internal" href="#imported-variables" id="id3">Imported Variables</a><ul>
+<li><a class="reference internal" href="#imported-const-copy-variables" id="id4">Imported <tt class="docutils literal"><span class="pre">const</span></tt> copy variables</a></li>
+<li><a class="reference internal" href="#imported-const-copy-of-block-reference" id="id5">Imported <tt class="docutils literal"><span class="pre">const</span></tt> copy of <tt class="docutils literal"><span class="pre">Block</span></tt> reference</a><ul>
+<li><a class="reference internal" href="#importing-attribute-nsobject-variables" id="id6">Importing <tt class="docutils literal"><span class="pre">__attribute__((NSObject))</span></tt> variables</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#imported-block-marked-variables" id="id7">Imported <tt class="docutils literal"><span class="pre">__block</span></tt> marked variables</a><ul>
+<li><a class="reference internal" href="#layout-of-block-marked-variables" id="id8">Layout of <tt class="docutils literal"><span class="pre">__block</span></tt> marked variables</a></li>
+<li><a class="reference internal" href="#access-to-block-variables-from-within-its-lexical-scope" id="id9">Access to <tt class="docutils literal"><span class="pre">__block</span></tt> variables from within its lexical scope</a></li>
+<li><a class="reference internal" href="#importing-block-variables-into-blocks" id="id10">Importing <tt class="docutils literal"><span class="pre">__block</span></tt> variables into <tt class="docutils literal"><span class="pre">Blocks</span></tt></a></li>
+<li><a class="reference internal" href="#importing-attribute-nsobject-block-variables" id="id11">Importing <tt class="docutils literal"><span class="pre">__attribute__((NSObject))</span></tt> <tt class="docutils literal"><span class="pre">__block</span></tt> variables</a></li>
+<li><a class="reference internal" href="#block-escapes" id="id12"><tt class="docutils literal"><span class="pre">__block</span></tt> escapes</a></li>
+<li><a class="reference internal" href="#nesting" id="id13">Nesting</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#objective-c-extensions-to-blocks" id="id14">Objective C Extensions to <tt class="docutils literal"><span class="pre">Blocks</span></tt></a><ul>
+<li><a class="reference internal" href="#importing-objects" id="id15">Importing Objects</a></li>
+<li><a class="reference internal" href="#blocks-as-objects" id="id16"><tt class="docutils literal"><span class="pre">Blocks</span></tt> as Objects</a></li>
+<li><a class="reference internal" href="#weak-block-support" id="id17"><tt class="docutils literal"><span class="pre">__weak</span> <span class="pre">__block</span></tt> Support</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#c-support" id="id18">C++ Support</a></li>
+<li><a class="reference internal" href="#runtime-helper-functions" id="id19">Runtime Helper Functions</a></li>
+<li><a class="reference internal" href="#copyright" id="id20">Copyright</a></li>
+</ul>
+</div>
+<div class="section" id="history">
+<h2><a class="toc-backref" href="#id1">History</a><a class="headerlink" href="#history" title="Permalink to this headline">¶</a></h2>
+<ul class="simple">
+<li>2008/7/14 - created.</li>
+<li>2008/8/21 - revised, C++.</li>
+<li>2008/9/24 - add <tt class="docutils literal"><span class="pre">NULL</span></tt> <tt class="docutils literal"><span class="pre">isa</span></tt> field to <tt class="docutils literal"><span class="pre">__block</span></tt> storage.</li>
+<li>2008/10/1 - revise block layout to use a <tt class="docutils literal"><span class="pre">static</span></tt> descriptor structure.</li>
+<li>2008/10/6 - revise block layout to use an unsigned long int flags.</li>
+<li>2008/10/28 - specify use of <tt class="docutils literal"><span class="pre">_Block_object_assign</span></tt> and
+<tt class="docutils literal"><span class="pre">_Block_object_dispose</span></tt> for all “Object” types in helper functions.</li>
+<li>2008/10/30 - revise new layout to have invoke function in same place.</li>
+<li>2008/10/30 - add <tt class="docutils literal"><span class="pre">__weak</span></tt> support.</li>
+<li>2010/3/16 - rev for stret return, signature field.</li>
+<li>2010/4/6 - improved wording.</li>
+<li>2013/1/6 - improved wording and converted to rst.</li>
+</ul>
+<p>This document describes the Apple ABI implementation specification of Blocks.</p>
+<p>The first shipping version of this ABI is found in Mac OS X 10.6, and shall be
+referred to as 10.6.ABI. As of 2010/3/16, the following describes the ABI
+contract with the runtime and the compiler, and, as necessary, will be referred
+to as ABI.2010.3.16.</p>
+<p>Since the Apple ABI references symbols from other elements of the system, any
+attempt to use this ABI on systems prior to SnowLeopard is undefined.</p>
+</div>
+<div class="section" id="high-level">
+<h2><a class="toc-backref" href="#id2">High Level</a><a class="headerlink" href="#high-level" title="Permalink to this headline">¶</a></h2>
+<p>The ABI of <tt class="docutils literal"><span class="pre">Blocks</span></tt> consist of their layout and the runtime functions required
+by the compiler. A <tt class="docutils literal"><span class="pre">Block</span></tt> consists of a structure of the following form:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="k">struct</span> <span class="n">Block_literal_1</span> <span class="p">{</span>
+ <span class="kt">void</span> <span class="o">*</span><span class="n">isa</span><span class="p">;</span> <span class="c1">// initialized to &_NSConcreteStackBlock or &_NSConcreteGlobalBlock</span>
+ <span class="kt">int</span> <span class="n">flags</span><span class="p">;</span>
+ <span class="kt">int</span> <span class="n">reserved</span><span class="p">;</span>
+ <span class="kt">void</span> <span class="p">(</span><span class="o">*</span><span class="n">invoke</span><span class="p">)(</span><span class="kt">void</span> <span class="o">*</span><span class="p">,</span> <span class="p">...);</span>
+ <span class="k">struct</span> <span class="n">Block_descriptor_1</span> <span class="p">{</span>
+ <span class="kt">unsigned</span> <span class="kt">long</span> <span class="kt">int</span> <span class="n">reserved</span><span class="p">;</span> <span class="c1">// NULL</span>
+ <span class="kt">unsigned</span> <span class="kt">long</span> <span class="kt">int</span> <span class="n">size</span><span class="p">;</span> <span class="c1">// sizeof(struct Block_literal_1)</span>
+ <span class="c1">// optional helper functions</span>
+ <span class="kt">void</span> <span class="p">(</span><span class="o">*</span><span class="n">copy_helper</span><span class="p">)(</span><span class="kt">void</span> <span class="o">*</span><span class="n">dst</span><span class="p">,</span> <span class="kt">void</span> <span class="o">*</span><span class="n">src</span><span class="p">);</span> <span class="c1">// IFF (1<<25)</span>
+ <span class="kt">void</span> <span class="p">(</span><span class="o">*</span><span class="n">dispose_helper</span><span class="p">)(</span><span class="kt">void</span> <span class="o">*</span><span class="n">src</span><span class="p">);</span> <span class="c1">// IFF (1<<25)</span>
+ <span class="c1">// required ABI.2010.3.16</span>
+ <span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">signature</span><span class="p">;</span> <span class="c1">// IFF (1<<30)</span>
+ <span class="p">}</span> <span class="o">*</span><span class="n">descriptor</span><span class="p">;</span>
+ <span class="c1">// imported variables</span>
+<span class="p">};</span>
+</pre></div>
+</div>
+<p>The following flags bits are in use thusly for a possible ABI.2010.3.16:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="k">enum</span> <span class="p">{</span>
+ <span class="n">BLOCK_HAS_COPY_DISPOSE</span> <span class="o">=</span> <span class="p">(</span><span class="mi">1</span> <span class="o"><<</span> <span class="mi">25</span><span class="p">),</span>
+ <span class="n">BLOCK_HAS_CTOR</span> <span class="o">=</span> <span class="p">(</span><span class="mi">1</span> <span class="o"><<</span> <span class="mi">26</span><span class="p">),</span> <span class="c1">// helpers have C++ code</span>
+ <span class="n">BLOCK_IS_GLOBAL</span> <span class="o">=</span> <span class="p">(</span><span class="mi">1</span> <span class="o"><<</span> <span class="mi">28</span><span class="p">),</span>
+ <span class="n">BLOCK_HAS_STRET</span> <span class="o">=</span> <span class="p">(</span><span class="mi">1</span> <span class="o"><<</span> <span class="mi">29</span><span class="p">),</span> <span class="c1">// IFF BLOCK_HAS_SIGNATURE</span>
+ <span class="n">BLOCK_HAS_SIGNATURE</span> <span class="o">=</span> <span class="p">(</span><span class="mi">1</span> <span class="o"><<</span> <span class="mi">30</span><span class="p">),</span>
+<span class="p">};</span>
+</pre></div>
+</div>
+<p>In 10.6.ABI the (1<<29) was usually set and was always ignored by the runtime -
+it had been a transitional marker that did not get deleted after the
+transition. This bit is now paired with (1<<30), and represented as the pair
+(3<<30), for the following combinations of valid bit settings, and their
+meanings:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="k">switch</span> <span class="p">(</span><span class="n">flags</span> <span class="o">&</span> <span class="p">(</span><span class="mi">3</span><span class="o"><<</span><span class="mi">29</span><span class="p">))</span> <span class="p">{</span>
+ <span class="k">case</span> <span class="p">(</span><span class="mi">0</span><span class="o"><<</span><span class="mi">29</span><span class="p">)</span>: <span class="mf">10.6</span><span class="p">.</span><span class="n">ABI</span><span class="p">,</span> <span class="n">no</span> <span class="n">signature</span> <span class="n">field</span> <span class="n">available</span>
+ <span class="k">case</span> <span class="p">(</span><span class="mi">1</span><span class="o"><<</span><span class="mi">29</span><span class="p">)</span>: <span class="mf">10.6</span><span class="p">.</span><span class="n">ABI</span><span class="p">,</span> <span class="n">no</span> <span class="n">signature</span> <span class="n">field</span> <span class="n">available</span>
+ <span class="k">case</span> <span class="p">(</span><span class="mi">2</span><span class="o"><<</span><span class="mi">29</span><span class="p">)</span>: <span class="n">ABI</span><span class="mf">.2010.3.16</span><span class="p">,</span> <span class="n">regular</span> <span class="n">calling</span> <span class="n">convention</span><span class="p">,</span> <span class="n">presence</span> <span class="n">of</span> <span class="n">signature</span> <span class="n">field</span>
+ <span class="k">case</span> <span class="p">(</span><span class="mi">3</span><span class="o"><<</span><span class="mi">29</span><span class="p">)</span>: <span class="n">ABI</span><span class="mf">.2010.3.16</span><span class="p">,</span> <span class="n">stret</span> <span class="n">calling</span> <span class="n">convention</span><span class="p">,</span> <span class="n">presence</span> <span class="n">of</span> <span class="n">signature</span> <span class="n">field</span><span class="p">,</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>The signature field is not always populated.</p>
+<p>The following discussions are presented as 10.6.ABI otherwise.</p>
+<p><tt class="docutils literal"><span class="pre">Block</span></tt> literals may occur within functions where the structure is created in
+stack local memory. They may also appear as initialization expressions for
+<tt class="docutils literal"><span class="pre">Block</span></tt> variables of global or <tt class="docutils literal"><span class="pre">static</span></tt> local variables.</p>
+<p>When a <tt class="docutils literal"><span class="pre">Block</span></tt> literal expression is evaluated the stack based structure is
+initialized as follows:</p>
+<ol class="arabic simple">
+<li>A <tt class="docutils literal"><span class="pre">static</span></tt> descriptor structure is declared and initialized as follows:</li>
+</ol>
+<blockquote>
+<div><p>a. The <tt class="docutils literal"><span class="pre">invoke</span></tt> function pointer is set to a function that takes the
+<tt class="docutils literal"><span class="pre">Block</span></tt> structure as its first argument and the rest of the arguments (if
+any) to the <tt class="docutils literal"><span class="pre">Block</span></tt> and executes the <tt class="docutils literal"><span class="pre">Block</span></tt> compound statement.</p>
+<p>b. The <tt class="docutils literal"><span class="pre">size</span></tt> field is set to the size of the following <tt class="docutils literal"><span class="pre">Block</span></tt> literal
+structure.</p>
+<p>c. The <tt class="docutils literal"><span class="pre">copy_helper</span></tt> and <tt class="docutils literal"><span class="pre">dispose_helper</span></tt> function pointers are set to
+respective helper functions if they are required by the <tt class="docutils literal"><span class="pre">Block</span></tt> literal.</p>
+</div></blockquote>
+<ol class="arabic" start="2">
+<li><p class="first">A stack (or global) <tt class="docutils literal"><span class="pre">Block</span></tt> literal data structure is created and
+initialized as follows:</p>
+<p>a. The <tt class="docutils literal"><span class="pre">isa</span></tt> field is set to the address of the external
+<tt class="docutils literal"><span class="pre">_NSConcreteStackBlock</span></tt>, which is a block of uninitialized memory supplied
+in <tt class="docutils literal"><span class="pre">libSystem</span></tt>, or <tt class="docutils literal"><span class="pre">_NSConcreteGlobalBlock</span></tt> if this is a static or file
+level <tt class="docutils literal"><span class="pre">Block</span></tt> literal.</p>
+<p>b. The <tt class="docutils literal"><span class="pre">flags</span></tt> field is set to zero unless there are variables imported
+into the <tt class="docutils literal"><span class="pre">Block</span></tt> that need helper functions for program level
+<tt class="docutils literal"><span class="pre">Block_copy()</span></tt> and <tt class="docutils literal"><span class="pre">Block_release()</span></tt> operations, in which case the
+(1<<25) flags bit is set.</p>
+</li>
+</ol>
+<p>As an example, the <tt class="docutils literal"><span class="pre">Block</span></tt> literal expression:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="o">^</span> <span class="p">{</span> <span class="n">printf</span><span class="p">(</span><span class="s">"hello world</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span> <span class="p">}</span>
+</pre></div>
+</div>
+<p>would cause the following to be created on a 32-bit system:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="k">struct</span> <span class="n">__block_literal_1</span> <span class="p">{</span>
+ <span class="kt">void</span> <span class="o">*</span><span class="n">isa</span><span class="p">;</span>
+ <span class="kt">int</span> <span class="n">flags</span><span class="p">;</span>
+ <span class="kt">int</span> <span class="n">reserved</span><span class="p">;</span>
+ <span class="kt">void</span> <span class="p">(</span><span class="o">*</span><span class="n">invoke</span><span class="p">)(</span><span class="k">struct</span> <span class="n">__block_literal_1</span> <span class="o">*</span><span class="p">);</span>
+ <span class="k">struct</span> <span class="n">__block_descriptor_1</span> <span class="o">*</span><span class="n">descriptor</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="kt">void</span> <span class="nf">__block_invoke_1</span><span class="p">(</span><span class="k">struct</span> <span class="n">__block_literal_1</span> <span class="o">*</span><span class="n">_block</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">printf</span><span class="p">(</span><span class="s">"hello world</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="k">static</span> <span class="k">struct</span> <span class="n">__block_descriptor_1</span> <span class="p">{</span>
+ <span class="kt">unsigned</span> <span class="kt">long</span> <span class="kt">int</span> <span class="n">reserved</span><span class="p">;</span>
+ <span class="kt">unsigned</span> <span class="kt">long</span> <span class="kt">int</span> <span class="n">Block_size</span><span class="p">;</span>
+<span class="p">}</span> <span class="n">__block_descriptor_1</span> <span class="o">=</span> <span class="p">{</span> <span class="mi">0</span><span class="p">,</span> <span class="k">sizeof</span><span class="p">(</span><span class="k">struct</span> <span class="n">__block_literal_1</span><span class="p">),</span> <span class="n">__block_invoke_1</span> <span class="p">};</span>
+</pre></div>
+</div>
+<p>and where the <tt class="docutils literal"><span class="pre">Block</span></tt> literal itself appears:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="k">struct</span> <span class="n">__block_literal_1</span> <span class="n">_block_literal</span> <span class="o">=</span> <span class="p">{</span>
+ <span class="o">&</span><span class="n">_NSConcreteStackBlock</span><span class="p">,</span>
+ <span class="p">(</span><span class="mi">1</span><span class="o"><<</span><span class="mi">29</span><span class="p">),</span> <span class="o"><</span><span class="n">uninitialized</span><span class="o">></span><span class="p">,</span>
+ <span class="n">__block_invoke_1</span><span class="p">,</span>
+ <span class="o">&</span><span class="n">__block_descriptor_1</span>
+<span class="p">};</span>
+</pre></div>
+</div>
+<p>A <tt class="docutils literal"><span class="pre">Block</span></tt> imports other <tt class="docutils literal"><span class="pre">Block</span></tt> references, <tt class="docutils literal"><span class="pre">const</span></tt> copies of other
+variables, and variables marked <tt class="docutils literal"><span class="pre">__block</span></tt>. In Objective-C, variables may
+additionally be objects.</p>
+<p>When a <tt class="docutils literal"><span class="pre">Block</span></tt> literal expression is used as the initial value of a global
+or <tt class="docutils literal"><span class="pre">static</span></tt> local variable, it is initialized as follows:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="k">struct</span> <span class="n">__block_literal_1</span> <span class="n">__block_literal_1</span> <span class="o">=</span> <span class="p">{</span>
+ <span class="o">&</span><span class="n">_NSConcreteGlobalBlock</span><span class="p">,</span>
+ <span class="p">(</span><span class="mi">1</span><span class="o"><<</span><span class="mi">28</span><span class="p">)</span><span class="o">|</span><span class="p">(</span><span class="mi">1</span><span class="o"><<</span><span class="mi">29</span><span class="p">),</span> <span class="o"><</span><span class="n">uninitialized</span><span class="o">></span><span class="p">,</span>
+ <span class="n">__block_invoke_1</span><span class="p">,</span>
+ <span class="o">&</span><span class="n">__block_descriptor_1</span>
+<span class="p">};</span>
+</pre></div>
+</div>
+<p>that is, a different address is provided as the first value and a particular
+(1<<28) bit is set in the <tt class="docutils literal"><span class="pre">flags</span></tt> field, and otherwise it is the same as for
+stack based <tt class="docutils literal"><span class="pre">Block</span></tt> literals. This is an optimization that can be used for
+any <tt class="docutils literal"><span class="pre">Block</span></tt> literal that imports no <tt class="docutils literal"><span class="pre">const</span></tt> or <tt class="docutils literal"><span class="pre">__block</span></tt> storage
+variables.</p>
+</div>
+<div class="section" id="imported-variables">
+<h2><a class="toc-backref" href="#id3">Imported Variables</a><a class="headerlink" href="#imported-variables" title="Permalink to this headline">¶</a></h2>
+<p>Variables of <tt class="docutils literal"><span class="pre">auto</span></tt> storage class are imported as <tt class="docutils literal"><span class="pre">const</span></tt> copies. Variables
+of <tt class="docutils literal"><span class="pre">__block</span></tt> storage class are imported as a pointer to an enclosing data
+structure. Global variables are simply referenced and not considered as
+imported.</p>
+<div class="section" id="imported-const-copy-variables">
+<h3><a class="toc-backref" href="#id4">Imported <tt class="docutils literal"><span class="pre">const</span></tt> copy variables</a><a class="headerlink" href="#imported-const-copy-variables" title="Permalink to this headline">¶</a></h3>
+<p>Automatic storage variables not marked with <tt class="docutils literal"><span class="pre">__block</span></tt> are imported as
+<tt class="docutils literal"><span class="pre">const</span></tt> copies.</p>
+<p>The simplest example is that of importing a variable of type <tt class="docutils literal"><span class="pre">int</span></tt>:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="kt">int</span> <span class="n">x</span> <span class="o">=</span> <span class="mi">10</span><span class="p">;</span>
+<span class="kt">void</span> <span class="p">(</span><span class="o">^</span><span class="n">vv</span><span class="p">)(</span><span class="kt">void</span><span class="p">)</span> <span class="o">=</span> <span class="o">^</span><span class="p">{</span> <span class="n">printf</span><span class="p">(</span><span class="s">"x is %d</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">x</span><span class="p">);</span> <span class="p">}</span>
+<span class="n">x</span> <span class="o">=</span> <span class="mi">11</span><span class="p">;</span>
+<span class="n">vv</span><span class="p">();</span>
+</pre></div>
+</div>
+<p>which would be compiled to:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="k">struct</span> <span class="n">__block_literal_2</span> <span class="p">{</span>
+ <span class="kt">void</span> <span class="o">*</span><span class="n">isa</span><span class="p">;</span>
+ <span class="kt">int</span> <span class="n">flags</span><span class="p">;</span>
+ <span class="kt">int</span> <span class="n">reserved</span><span class="p">;</span>
+ <span class="kt">void</span> <span class="p">(</span><span class="o">*</span><span class="n">invoke</span><span class="p">)(</span><span class="k">struct</span> <span class="n">__block_literal_2</span> <span class="o">*</span><span class="p">);</span>
+ <span class="k">struct</span> <span class="n">__block_descriptor_2</span> <span class="o">*</span><span class="n">descriptor</span><span class="p">;</span>
+ <span class="k">const</span> <span class="kt">int</span> <span class="n">x</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="kt">void</span> <span class="nf">__block_invoke_2</span><span class="p">(</span><span class="k">struct</span> <span class="n">__block_literal_2</span> <span class="o">*</span><span class="n">_block</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">printf</span><span class="p">(</span><span class="s">"x is %d</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">_block</span><span class="o">-></span><span class="n">x</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="k">static</span> <span class="k">struct</span> <span class="n">__block_descriptor_2</span> <span class="p">{</span>
+ <span class="kt">unsigned</span> <span class="kt">long</span> <span class="kt">int</span> <span class="n">reserved</span><span class="p">;</span>
+ <span class="kt">unsigned</span> <span class="kt">long</span> <span class="kt">int</span> <span class="n">Block_size</span><span class="p">;</span>
+<span class="p">}</span> <span class="n">__block_descriptor_2</span> <span class="o">=</span> <span class="p">{</span> <span class="mi">0</span><span class="p">,</span> <span class="k">sizeof</span><span class="p">(</span><span class="k">struct</span> <span class="n">__block_literal_2</span><span class="p">)</span> <span class="p">};</span>
+</pre></div>
+</div>
+<p>and:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="k">struct</span> <span class="n">__block_literal_2</span> <span class="n">__block_literal_2</span> <span class="o">=</span> <span class="p">{</span>
+ <span class="o">&</span><span class="n">_NSConcreteStackBlock</span><span class="p">,</span>
+ <span class="p">(</span><span class="mi">1</span><span class="o"><<</span><span class="mi">29</span><span class="p">),</span> <span class="o"><</span><span class="n">uninitialized</span><span class="o">></span><span class="p">,</span>
+ <span class="n">__block_invoke_2</span><span class="p">,</span>
+ <span class="o">&</span><span class="n">__block_descriptor_2</span><span class="p">,</span>
+ <span class="n">x</span>
+ <span class="p">};</span>
+</pre></div>
+</div>
+<p>In summary, scalars, structures, unions, and function pointers are generally
+imported as <tt class="docutils literal"><span class="pre">const</span></tt> copies with no need for helper functions.</p>
+</div>
+<div class="section" id="imported-const-copy-of-block-reference">
+<h3><a class="toc-backref" href="#id5">Imported <tt class="docutils literal"><span class="pre">const</span></tt> copy of <tt class="docutils literal"><span class="pre">Block</span></tt> reference</a><a class="headerlink" href="#imported-const-copy-of-block-reference" title="Permalink to this headline">¶</a></h3>
+<p>The first case where copy and dispose helper functions are required is for the
+case of when a <tt class="docutils literal"><span class="pre">Block</span></tt> itself is imported. In this case both a
+<tt class="docutils literal"><span class="pre">copy_helper</span></tt> function and a <tt class="docutils literal"><span class="pre">dispose_helper</span></tt> function are needed. The
+<tt class="docutils literal"><span class="pre">copy_helper</span></tt> function is passed both the existing stack based pointer and the
+pointer to the new heap version and should call back into the runtime to
+actually do the copy operation on the imported fields within the <tt class="docutils literal"><span class="pre">Block</span></tt>. The
+runtime functions are all described in <a class="reference internal" href="#runtimehelperfunctions"><em>Runtime Helper Functions</em></a>.</p>
+<p>A quick example:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="kt">void</span> <span class="p">(</span><span class="o">^</span><span class="n">existingBlock</span><span class="p">)(</span><span class="kt">void</span><span class="p">)</span> <span class="o">=</span> <span class="p">...;</span>
+<span class="kt">void</span> <span class="p">(</span><span class="o">^</span><span class="n">vv</span><span class="p">)(</span><span class="kt">void</span><span class="p">)</span> <span class="o">=</span> <span class="o">^</span><span class="p">{</span> <span class="n">existingBlock</span><span class="p">();</span> <span class="p">}</span>
+<span class="n">vv</span><span class="p">();</span>
+
+<span class="k">struct</span> <span class="n">__block_literal_3</span> <span class="p">{</span>
+ <span class="p">...;</span> <span class="c1">// existing block</span>
+<span class="p">};</span>
+
+<span class="k">struct</span> <span class="n">__block_literal_4</span> <span class="p">{</span>
+ <span class="kt">void</span> <span class="o">*</span><span class="n">isa</span><span class="p">;</span>
+ <span class="kt">int</span> <span class="n">flags</span><span class="p">;</span>
+ <span class="kt">int</span> <span class="n">reserved</span><span class="p">;</span>
+ <span class="kt">void</span> <span class="p">(</span><span class="o">*</span><span class="n">invoke</span><span class="p">)(</span><span class="k">struct</span> <span class="n">__block_literal_4</span> <span class="o">*</span><span class="p">);</span>
+ <span class="k">struct</span> <span class="n">__block_literal_3</span> <span class="o">*</span><span class="k">const</span> <span class="n">existingBlock</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="kt">void</span> <span class="nf">__block_invoke_4</span><span class="p">(</span><span class="k">struct</span> <span class="n">__block_literal_2</span> <span class="o">*</span><span class="n">_block</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">__block</span><span class="o">-></span><span class="n">existingBlock</span><span class="o">-></span><span class="n">invoke</span><span class="p">(</span><span class="n">__block</span><span class="o">-></span><span class="n">existingBlock</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="kt">void</span> <span class="nf">__block_copy_4</span><span class="p">(</span><span class="k">struct</span> <span class="n">__block_literal_4</span> <span class="o">*</span><span class="n">dst</span><span class="p">,</span> <span class="k">struct</span> <span class="n">__block_literal_4</span> <span class="o">*</span><span class="n">src</span><span class="p">)</span> <span class="p">{</span>
+ <span class="c1">//_Block_copy_assign(&dst->existingBlock, src->existingBlock, 0);</span>
+ <span class="n">_Block_object_assign</span><span class="p">(</span><span class="o">&</span><span class="n">dst</span><span class="o">-></span><span class="n">existingBlock</span><span class="p">,</span> <span class="n">src</span><span class="o">-></span><span class="n">existingBlock</span><span class="p">,</span> <span class="n">BLOCK_FIELD_IS_BLOCK</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="kt">void</span> <span class="nf">__block_dispose_4</span><span class="p">(</span><span class="k">struct</span> <span class="n">__block_literal_4</span> <span class="o">*</span><span class="n">src</span><span class="p">)</span> <span class="p">{</span>
+ <span class="c1">// was _Block_destroy</span>
+ <span class="n">_Block_object_dispose</span><span class="p">(</span><span class="n">src</span><span class="o">-></span><span class="n">existingBlock</span><span class="p">,</span> <span class="n">BLOCK_FIELD_IS_BLOCK</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="k">static</span> <span class="k">struct</span> <span class="n">__block_descriptor_4</span> <span class="p">{</span>
+ <span class="kt">unsigned</span> <span class="kt">long</span> <span class="kt">int</span> <span class="n">reserved</span><span class="p">;</span>
+ <span class="kt">unsigned</span> <span class="kt">long</span> <span class="kt">int</span> <span class="n">Block_size</span><span class="p">;</span>
+ <span class="kt">void</span> <span class="p">(</span><span class="o">*</span><span class="n">copy_helper</span><span class="p">)(</span><span class="k">struct</span> <span class="n">__block_literal_4</span> <span class="o">*</span><span class="n">dst</span><span class="p">,</span> <span class="k">struct</span> <span class="n">__block_literal_4</span> <span class="o">*</span><span class="n">src</span><span class="p">);</span>
+ <span class="kt">void</span> <span class="p">(</span><span class="o">*</span><span class="n">dispose_helper</span><span class="p">)(</span><span class="k">struct</span> <span class="n">__block_literal_4</span> <span class="o">*</span><span class="p">);</span>
+<span class="p">}</span> <span class="n">__block_descriptor_4</span> <span class="o">=</span> <span class="p">{</span>
+ <span class="mi">0</span><span class="p">,</span>
+ <span class="k">sizeof</span><span class="p">(</span><span class="k">struct</span> <span class="n">__block_literal_4</span><span class="p">),</span>
+ <span class="n">__block_copy_4</span><span class="p">,</span>
+ <span class="n">__block_dispose_4</span><span class="p">,</span>
+<span class="p">};</span>
+</pre></div>
+</div>
+<p>and where said <tt class="docutils literal"><span class="pre">Block</span></tt> is used:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="k">struct</span> <span class="n">__block_literal_4</span> <span class="n">_block_literal</span> <span class="o">=</span> <span class="p">{</span>
+ <span class="o">&</span><span class="n">_NSConcreteStackBlock</span><span class="p">,</span>
+ <span class="p">(</span><span class="mi">1</span><span class="o"><<</span><span class="mi">25</span><span class="p">)</span><span class="o">|</span><span class="p">(</span><span class="mi">1</span><span class="o"><<</span><span class="mi">29</span><span class="p">),</span> <span class="o"><</span><span class="n">uninitialized</span><span class="o">></span>
+ <span class="n">__block_invoke_4</span><span class="p">,</span>
+ <span class="o">&</span> <span class="n">__block_descriptor_4</span>
+ <span class="n">existingBlock</span><span class="p">,</span>
+<span class="p">};</span>
+</pre></div>
+</div>
+<div class="section" id="importing-attribute-nsobject-variables">
+<h4><a class="toc-backref" href="#id6">Importing <tt class="docutils literal"><span class="pre">__attribute__((NSObject))</span></tt> variables</a><a class="headerlink" href="#importing-attribute-nsobject-variables" title="Permalink to this headline">¶</a></h4>
+<p>GCC introduces <tt class="docutils literal"><span class="pre">__attribute__((NSObject))</span></tt> on structure pointers to mean “this
+is an object”. This is useful because many low level data structures are
+declared as opaque structure pointers, e.g. <tt class="docutils literal"><span class="pre">CFStringRef</span></tt>, <tt class="docutils literal"><span class="pre">CFArrayRef</span></tt>,
+etc. When used from C, however, these are still really objects and are the
+second case where that requires copy and dispose helper functions to be
+generated. The copy helper functions generated by the compiler should use the
+<tt class="docutils literal"><span class="pre">_Block_object_assign</span></tt> runtime helper function and in the dispose helper the
+<tt class="docutils literal"><span class="pre">_Block_object_dispose</span></tt> runtime helper function should be called.</p>
+<p>For example, <tt class="docutils literal"><span class="pre">Block</span></tt> foo in the following:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="k">struct</span> <span class="n">Opaque</span> <span class="o">*</span><span class="n">__attribute__</span><span class="p">((</span><span class="n">NSObject</span><span class="p">))</span> <span class="n">objectPointer</span> <span class="o">=</span> <span class="p">...;</span>
+<span class="p">...</span>
+<span class="kt">void</span> <span class="p">(</span><span class="o">^</span><span class="n">foo</span><span class="p">)(</span><span class="kt">void</span><span class="p">)</span> <span class="o">=</span> <span class="o">^</span><span class="p">{</span> <span class="n">CFPrint</span><span class="p">(</span><span class="n">objectPointer</span><span class="p">);</span> <span class="p">};</span>
+</pre></div>
+</div>
+<p>would have the following helper functions generated:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="kt">void</span> <span class="nf">__block_copy_foo</span><span class="p">(</span><span class="k">struct</span> <span class="n">__block_literal_5</span> <span class="o">*</span><span class="n">dst</span><span class="p">,</span> <span class="k">struct</span> <span class="n">__block_literal_5</span> <span class="o">*</span><span class="n">src</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">_Block_object_assign</span><span class="p">(</span><span class="o">&</span><span class="n">dst</span><span class="o">-></span><span class="n">objectPointer</span><span class="p">,</span> <span class="n">src</span><span class="o">-></span> <span class="n">objectPointer</span><span class="p">,</span> <span class="n">BLOCK_FIELD_IS_OBJECT</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="kt">void</span> <span class="nf">__block_dispose_foo</span><span class="p">(</span><span class="k">struct</span> <span class="n">__block_literal_5</span> <span class="o">*</span><span class="n">src</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">_Block_object_dispose</span><span class="p">(</span><span class="n">src</span><span class="o">-></span><span class="n">objectPointer</span><span class="p">,</span> <span class="n">BLOCK_FIELD_IS_OBJECT</span><span class="p">);</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="imported-block-marked-variables">
+<h3><a class="toc-backref" href="#id7">Imported <tt class="docutils literal"><span class="pre">__block</span></tt> marked variables</a><a class="headerlink" href="#imported-block-marked-variables" title="Permalink to this headline">¶</a></h3>
+<div class="section" id="layout-of-block-marked-variables">
+<h4><a class="toc-backref" href="#id8">Layout of <tt class="docutils literal"><span class="pre">__block</span></tt> marked variables</a><a class="headerlink" href="#layout-of-block-marked-variables" title="Permalink to this headline">¶</a></h4>
+<p>The compiler must embed variables that are marked <tt class="docutils literal"><span class="pre">__block</span></tt> in a specialized
+structure of the form:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="k">struct</span> <span class="n">_block_byref_foo</span> <span class="p">{</span>
+ <span class="kt">void</span> <span class="o">*</span><span class="n">isa</span><span class="p">;</span>
+ <span class="k">struct</span> <span class="n">Block_byref</span> <span class="o">*</span><span class="n">forwarding</span><span class="p">;</span>
+ <span class="kt">int</span> <span class="n">flags</span><span class="p">;</span> <span class="c1">//refcount;</span>
+ <span class="kt">int</span> <span class="n">size</span><span class="p">;</span>
+ <span class="n">typeof</span><span class="p">(</span><span class="n">marked_variable</span><span class="p">)</span> <span class="n">marked_variable</span><span class="p">;</span>
+<span class="p">};</span>
+</pre></div>
+</div>
+<p>Variables of certain types require helper functions for when <tt class="docutils literal"><span class="pre">Block_copy()</span></tt>
+and <tt class="docutils literal"><span class="pre">Block_release()</span></tt> are performed upon a referencing <tt class="docutils literal"><span class="pre">Block</span></tt>. At the “C”
+level only variables that are of type <tt class="docutils literal"><span class="pre">Block</span></tt> or ones that have
+<tt class="docutils literal"><span class="pre">__attribute__((NSObject))</span></tt> marked require helper functions. In Objective-C
+objects require helper functions and in C++ stack based objects require helper
+functions. Variables that require helper functions use the form:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="k">struct</span> <span class="n">_block_byref_foo</span> <span class="p">{</span>
+ <span class="kt">void</span> <span class="o">*</span><span class="n">isa</span><span class="p">;</span>
+ <span class="k">struct</span> <span class="n">_block_byref_foo</span> <span class="o">*</span><span class="n">forwarding</span><span class="p">;</span>
+ <span class="kt">int</span> <span class="n">flags</span><span class="p">;</span> <span class="c1">//refcount;</span>
+ <span class="kt">int</span> <span class="n">size</span><span class="p">;</span>
+ <span class="c1">// helper functions called via Block_copy() and Block_release()</span>
+ <span class="kt">void</span> <span class="p">(</span><span class="o">*</span><span class="n">byref_keep</span><span class="p">)(</span><span class="kt">void</span> <span class="o">*</span><span class="n">dst</span><span class="p">,</span> <span class="kt">void</span> <span class="o">*</span><span class="n">src</span><span class="p">);</span>
+ <span class="kt">void</span> <span class="p">(</span><span class="o">*</span><span class="n">byref_dispose</span><span class="p">)(</span><span class="kt">void</span> <span class="o">*</span><span class="p">);</span>
+ <span class="n">typeof</span><span class="p">(</span><span class="n">marked_variable</span><span class="p">)</span> <span class="n">marked_variable</span><span class="p">;</span>
+<span class="p">};</span>
+</pre></div>
+</div>
+<p>The structure is initialized such that:</p>
+<blockquote>
+<div><p>a. The <tt class="docutils literal"><span class="pre">forwarding</span></tt> pointer is set to the beginning of its enclosing
+structure.</p>
+<p>b. The <tt class="docutils literal"><span class="pre">size</span></tt> field is initialized to the total size of the enclosing
+structure.</p>
+<p>c. The <tt class="docutils literal"><span class="pre">flags</span></tt> field is set to either 0 if no helper functions are needed
+or (1<<25) if they are.</p>
+<ol class="loweralpha simple" start="4">
+<li>The helper functions are initialized (if present).</li>
+<li>The variable itself is set to its initial value.</li>
+<li>The <tt class="docutils literal"><span class="pre">isa</span></tt> field is set to <tt class="docutils literal"><span class="pre">NULL</span></tt>.</li>
+</ol>
+</div></blockquote>
+</div>
+<div class="section" id="access-to-block-variables-from-within-its-lexical-scope">
+<h4><a class="toc-backref" href="#id9">Access to <tt class="docutils literal"><span class="pre">__block</span></tt> variables from within its lexical scope</a><a class="headerlink" href="#access-to-block-variables-from-within-its-lexical-scope" title="Permalink to this headline">¶</a></h4>
+<p>In order to “move” the variable to the heap upon a <tt class="docutils literal"><span class="pre">copy_helper</span></tt> operation the
+compiler must rewrite access to such a variable to be indirect through the
+structures <tt class="docutils literal"><span class="pre">forwarding</span></tt> pointer. For example:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="kt">int</span> <span class="n">__block</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">10</span><span class="p">;</span>
+<span class="n">i</span> <span class="o">=</span> <span class="mi">11</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>would be rewritten to be:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="k">struct</span> <span class="n">_block_byref_i</span> <span class="p">{</span>
+ <span class="kt">void</span> <span class="o">*</span><span class="n">isa</span><span class="p">;</span>
+ <span class="k">struct</span> <span class="n">_block_byref_i</span> <span class="o">*</span><span class="n">forwarding</span><span class="p">;</span>
+ <span class="kt">int</span> <span class="n">flags</span><span class="p">;</span> <span class="c1">//refcount;</span>
+ <span class="kt">int</span> <span class="n">size</span><span class="p">;</span>
+ <span class="kt">int</span> <span class="n">captured_i</span><span class="p">;</span>
+<span class="p">}</span> <span class="n">i</span> <span class="o">=</span> <span class="p">{</span> <span class="nb">NULL</span><span class="p">,</span> <span class="o">&</span><span class="n">i</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="k">sizeof</span><span class="p">(</span><span class="k">struct</span> <span class="n">_block_byref_i</span><span class="p">),</span> <span class="mi">10</span> <span class="p">};</span>
+
+<span class="n">i</span><span class="p">.</span><span class="n">forwarding</span><span class="o">-></span><span class="n">captured_i</span> <span class="o">=</span> <span class="mi">11</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>In the case of a <tt class="docutils literal"><span class="pre">Block</span></tt> reference variable being marked <tt class="docutils literal"><span class="pre">__block</span></tt> the
+helper code generated must use the <tt class="docutils literal"><span class="pre">_Block_object_assign</span></tt> and
+<tt class="docutils literal"><span class="pre">_Block_object_dispose</span></tt> routines supplied by the runtime to make the
+copies. For example:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="n">__block</span> <span class="kt">void</span> <span class="p">(</span><span class="n">voidBlock</span><span class="p">)(</span><span class="kt">void</span><span class="p">)</span> <span class="o">=</span> <span class="n">blockA</span><span class="p">;</span>
+<span class="n">voidBlock</span> <span class="o">=</span> <span class="n">blockB</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>would translate into:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="k">struct</span> <span class="n">_block_byref_voidBlock</span> <span class="p">{</span>
+ <span class="kt">void</span> <span class="o">*</span><span class="n">isa</span><span class="p">;</span>
+ <span class="k">struct</span> <span class="n">_block_byref_voidBlock</span> <span class="o">*</span><span class="n">forwarding</span><span class="p">;</span>
+ <span class="kt">int</span> <span class="n">flags</span><span class="p">;</span> <span class="c1">//refcount;</span>
+ <span class="kt">int</span> <span class="n">size</span><span class="p">;</span>
+ <span class="kt">void</span> <span class="p">(</span><span class="o">*</span><span class="n">byref_keep</span><span class="p">)(</span><span class="k">struct</span> <span class="n">_block_byref_voidBlock</span> <span class="o">*</span><span class="n">dst</span><span class="p">,</span> <span class="k">struct</span> <span class="n">_block_byref_voidBlock</span> <span class="o">*</span><span class="n">src</span><span class="p">);</span>
+ <span class="kt">void</span> <span class="p">(</span><span class="o">*</span><span class="n">byref_dispose</span><span class="p">)(</span><span class="k">struct</span> <span class="n">_block_byref_voidBlock</span> <span class="o">*</span><span class="p">);</span>
+ <span class="kt">void</span> <span class="p">(</span><span class="o">^</span><span class="n">captured_voidBlock</span><span class="p">)(</span><span class="kt">void</span><span class="p">);</span>
+<span class="p">};</span>
+
+<span class="kt">void</span> <span class="nf">_block_byref_keep_helper</span><span class="p">(</span><span class="k">struct</span> <span class="n">_block_byref_voidBlock</span> <span class="o">*</span><span class="n">dst</span><span class="p">,</span> <span class="k">struct</span> <span class="n">_block_byref_voidBlock</span> <span class="o">*</span><span class="n">src</span><span class="p">)</span> <span class="p">{</span>
+ <span class="c1">//_Block_copy_assign(&dst->captured_voidBlock, src->captured_voidBlock, 0);</span>
+ <span class="n">_Block_object_assign</span><span class="p">(</span><span class="o">&</span><span class="n">dst</span><span class="o">-></span><span class="n">captured_voidBlock</span><span class="p">,</span> <span class="n">src</span><span class="o">-></span><span class="n">captured_voidBlock</span><span class="p">,</span> <span class="n">BLOCK_FIELD_IS_BLOCK</span> <span class="o">|</span> <span class="n">BLOCK_BYREF_CALLER</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="kt">void</span> <span class="nf">_block_byref_dispose_helper</span><span class="p">(</span><span class="k">struct</span> <span class="n">_block_byref_voidBlock</span> <span class="o">*</span><span class="n">param</span><span class="p">)</span> <span class="p">{</span>
+ <span class="c1">//_Block_destroy(param->captured_voidBlock, 0);</span>
+ <span class="n">_Block_object_dispose</span><span class="p">(</span><span class="n">param</span><span class="o">-></span><span class="n">captured_voidBlock</span><span class="p">,</span> <span class="n">BLOCK_FIELD_IS_BLOCK</span> <span class="o">|</span> <span class="n">BLOCK_BYREF_CALLER</span><span class="p">)}</span>
+</pre></div>
+</div>
+<p>and:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="k">struct</span> <span class="n">_block_byref_voidBlock</span> <span class="n">voidBlock</span> <span class="o">=</span> <span class="p">{(</span> <span class="p">.</span><span class="n">forwarding</span><span class="o">=&</span><span class="n">voidBlock</span><span class="p">,</span> <span class="p">.</span><span class="n">flags</span><span class="o">=</span><span class="p">(</span><span class="mi">1</span><span class="o"><<</span><span class="mi">25</span><span class="p">),</span> <span class="p">.</span><span class="n">size</span><span class="o">=</span><span class="k">sizeof</span><span class="p">(</span><span class="k">struct</span> <span class="n">_block_byref_voidBlock</span> <span class="o">*</span><span class="p">),</span>
+ <span class="p">.</span><span class="n">byref_keep</span><span class="o">=</span><span class="n">_block_byref_keep_helper</span><span class="p">,</span> <span class="p">.</span><span class="n">byref_dispose</span><span class="o">=</span><span class="n">_block_byref_dispose_helper</span><span class="p">,</span>
+ <span class="p">.</span><span class="n">captured_voidBlock</span><span class="o">=</span><span class="n">blockA</span> <span class="p">)};</span>
+
+<span class="n">voidBlock</span><span class="p">.</span><span class="n">forwarding</span><span class="o">-></span><span class="n">captured_voidBlock</span> <span class="o">=</span> <span class="n">blockB</span><span class="p">;</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="importing-block-variables-into-blocks">
+<h4><a class="toc-backref" href="#id10">Importing <tt class="docutils literal"><span class="pre">__block</span></tt> variables into <tt class="docutils literal"><span class="pre">Blocks</span></tt></a><a class="headerlink" href="#importing-block-variables-into-blocks" title="Permalink to this headline">¶</a></h4>
+<p>A <tt class="docutils literal"><span class="pre">Block</span></tt> that uses a <tt class="docutils literal"><span class="pre">__block</span></tt> variable in its compound statement body must
+import the variable and emit <tt class="docutils literal"><span class="pre">copy_helper</span></tt> and <tt class="docutils literal"><span class="pre">dispose_helper</span></tt> helper
+functions that, in turn, call back into the runtime to actually copy or release
+the <tt class="docutils literal"><span class="pre">byref</span></tt> data block using the functions <tt class="docutils literal"><span class="pre">_Block_object_assign</span></tt> and
+<tt class="docutils literal"><span class="pre">_Block_object_dispose</span></tt>.</p>
+<p>For example:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="kt">int</span> <span class="n">__block</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">2</span><span class="p">;</span>
+<span class="n">functioncall</span><span class="p">(</span><span class="o">^</span><span class="p">{</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">10</span><span class="p">;</span> <span class="p">});</span>
+</pre></div>
+</div>
+<p>would translate to:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="k">struct</span> <span class="n">_block_byref_i</span> <span class="p">{</span>
+ <span class="kt">void</span> <span class="o">*</span><span class="n">isa</span><span class="p">;</span> <span class="c1">// set to NULL</span>
+ <span class="k">struct</span> <span class="n">_block_byref_voidBlock</span> <span class="o">*</span><span class="n">forwarding</span><span class="p">;</span>
+ <span class="kt">int</span> <span class="n">flags</span><span class="p">;</span> <span class="c1">//refcount;</span>
+ <span class="kt">int</span> <span class="n">size</span><span class="p">;</span>
+ <span class="kt">void</span> <span class="p">(</span><span class="o">*</span><span class="n">byref_keep</span><span class="p">)(</span><span class="k">struct</span> <span class="n">_block_byref_i</span> <span class="o">*</span><span class="n">dst</span><span class="p">,</span> <span class="k">struct</span> <span class="n">_block_byref_i</span> <span class="o">*</span><span class="n">src</span><span class="p">);</span>
+ <span class="kt">void</span> <span class="p">(</span><span class="o">*</span><span class="n">byref_dispose</span><span class="p">)(</span><span class="k">struct</span> <span class="n">_block_byref_i</span> <span class="o">*</span><span class="p">);</span>
+ <span class="kt">int</span> <span class="n">captured_i</span><span class="p">;</span>
+<span class="p">};</span>
+
+
+<span class="k">struct</span> <span class="n">__block_literal_5</span> <span class="p">{</span>
+ <span class="kt">void</span> <span class="o">*</span><span class="n">isa</span><span class="p">;</span>
+ <span class="kt">int</span> <span class="n">flags</span><span class="p">;</span>
+ <span class="kt">int</span> <span class="n">reserved</span><span class="p">;</span>
+ <span class="kt">void</span> <span class="p">(</span><span class="o">*</span><span class="n">invoke</span><span class="p">)(</span><span class="k">struct</span> <span class="n">__block_literal_5</span> <span class="o">*</span><span class="p">);</span>
+ <span class="k">struct</span> <span class="n">__block_descriptor_5</span> <span class="o">*</span><span class="n">descriptor</span><span class="p">;</span>
+ <span class="k">struct</span> <span class="n">_block_byref_i</span> <span class="o">*</span><span class="n">i_holder</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="kt">void</span> <span class="nf">__block_invoke_5</span><span class="p">(</span><span class="k">struct</span> <span class="n">__block_literal_5</span> <span class="o">*</span><span class="n">_block</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">_block</span><span class="o">-></span><span class="n">forwarding</span><span class="o">-></span><span class="n">captured_i</span> <span class="o">=</span> <span class="mi">10</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="kt">void</span> <span class="nf">__block_copy_5</span><span class="p">(</span><span class="k">struct</span> <span class="n">__block_literal_5</span> <span class="o">*</span><span class="n">dst</span><span class="p">,</span> <span class="k">struct</span> <span class="n">__block_literal_5</span> <span class="o">*</span><span class="n">src</span><span class="p">)</span> <span class="p">{</span>
+ <span class="c1">//_Block_byref_assign_copy(&dst->captured_i, src->captured_i);</span>
+ <span class="n">_Block_object_assign</span><span class="p">(</span><span class="o">&</span><span class="n">dst</span><span class="o">-></span><span class="n">captured_i</span><span class="p">,</span> <span class="n">src</span><span class="o">-></span><span class="n">captured_i</span><span class="p">,</span> <span class="n">BLOCK_FIELD_IS_BYREF</span> <span class="o">|</span> <span class="n">BLOCK_BYREF_CALLER</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="kt">void</span> <span class="nf">__block_dispose_5</span><span class="p">(</span><span class="k">struct</span> <span class="n">__block_literal_5</span> <span class="o">*</span><span class="n">src</span><span class="p">)</span> <span class="p">{</span>
+ <span class="c1">//_Block_byref_release(src->captured_i);</span>
+ <span class="n">_Block_object_dispose</span><span class="p">(</span><span class="n">src</span><span class="o">-></span><span class="n">captured_i</span><span class="p">,</span> <span class="n">BLOCK_FIELD_IS_BYREF</span> <span class="o">|</span> <span class="n">BLOCK_BYREF_CALLER</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="k">static</span> <span class="k">struct</span> <span class="n">__block_descriptor_5</span> <span class="p">{</span>
+ <span class="kt">unsigned</span> <span class="kt">long</span> <span class="kt">int</span> <span class="n">reserved</span><span class="p">;</span>
+ <span class="kt">unsigned</span> <span class="kt">long</span> <span class="kt">int</span> <span class="n">Block_size</span><span class="p">;</span>
+ <span class="kt">void</span> <span class="p">(</span><span class="o">*</span><span class="n">copy_helper</span><span class="p">)(</span><span class="k">struct</span> <span class="n">__block_literal_5</span> <span class="o">*</span><span class="n">dst</span><span class="p">,</span> <span class="k">struct</span> <span class="n">__block_literal_5</span> <span class="o">*</span><span class="n">src</span><span class="p">);</span>
+ <span class="kt">void</span> <span class="p">(</span><span class="o">*</span><span class="n">dispose_helper</span><span class="p">)(</span><span class="k">struct</span> <span class="n">__block_literal_5</span> <span class="o">*</span><span class="p">);</span>
+<span class="p">}</span> <span class="n">__block_descriptor_5</span> <span class="o">=</span> <span class="p">{</span> <span class="mi">0</span><span class="p">,</span> <span class="k">sizeof</span><span class="p">(</span><span class="k">struct</span> <span class="n">__block_literal_5</span><span class="p">)</span> <span class="n">__block_copy_5</span><span class="p">,</span> <span class="n">__block_dispose_5</span> <span class="p">};</span>
+</pre></div>
+</div>
+<p>and:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="k">struct</span> <span class="n">_block_byref_i</span> <span class="n">i</span> <span class="o">=</span> <span class="p">{(</span> <span class="p">.</span><span class="n">isa</span><span class="o">=</span><span class="nb">NULL</span><span class="p">,</span> <span class="p">.</span><span class="n">forwarding</span><span class="o">=&</span><span class="n">i</span><span class="p">,</span> <span class="p">.</span><span class="n">flags</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="p">.</span><span class="n">size</span><span class="o">=</span><span class="k">sizeof</span><span class="p">(</span><span class="k">struct</span> <span class="n">_block_byref_i</span><span class="p">),</span> <span class="p">.</span><span class="n">captured_i</span><span class="o">=</span><span class="mi">2</span> <span class="p">)};</span>
+<span class="k">struct</span> <span class="n">__block_literal_5</span> <span class="n">_block_literal</span> <span class="o">=</span> <span class="p">{</span>
+ <span class="o">&</span><span class="n">_NSConcreteStackBlock</span><span class="p">,</span>
+ <span class="p">(</span><span class="mi">1</span><span class="o"><<</span><span class="mi">25</span><span class="p">)</span><span class="o">|</span><span class="p">(</span><span class="mi">1</span><span class="o"><<</span><span class="mi">29</span><span class="p">),</span> <span class="o"><</span><span class="n">uninitialized</span><span class="o">></span><span class="p">,</span>
+ <span class="n">__block_invoke_5</span><span class="p">,</span>
+ <span class="o">&</span><span class="n">__block_descriptor_5</span><span class="p">,</span>
+ <span class="o">&</span><span class="n">i</span><span class="p">,</span>
+<span class="p">};</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="importing-attribute-nsobject-block-variables">
+<h4><a class="toc-backref" href="#id11">Importing <tt class="docutils literal"><span class="pre">__attribute__((NSObject))</span></tt> <tt class="docutils literal"><span class="pre">__block</span></tt> variables</a><a class="headerlink" href="#importing-attribute-nsobject-block-variables" title="Permalink to this headline">¶</a></h4>
+<p>A <tt class="docutils literal"><span class="pre">__block</span></tt> variable that is also marked <tt class="docutils literal"><span class="pre">__attribute__((NSObject))</span></tt> should
+have <tt class="docutils literal"><span class="pre">byref_keep</span></tt> and <tt class="docutils literal"><span class="pre">byref_dispose</span></tt> helper functions that use
+<tt class="docutils literal"><span class="pre">_Block_object_assign</span></tt> and <tt class="docutils literal"><span class="pre">_Block_object_dispose</span></tt>.</p>
+</div>
+<div class="section" id="block-escapes">
+<h4><a class="toc-backref" href="#id12"><tt class="docutils literal"><span class="pre">__block</span></tt> escapes</a><a class="headerlink" href="#block-escapes" title="Permalink to this headline">¶</a></h4>
+<p>Because <tt class="docutils literal"><span class="pre">Blocks</span></tt> referencing <tt class="docutils literal"><span class="pre">__block</span></tt> variables may have <tt class="docutils literal"><span class="pre">Block_copy()</span></tt>
+performed upon them the underlying storage for the variables may move to the
+heap. In Objective-C Garbage Collection Only compilation environments the heap
+used is the garbage collected one and no further action is required. Otherwise
+the compiler must issue a call to potentially release any heap storage for
+<tt class="docutils literal"><span class="pre">__block</span></tt> variables at all escapes or terminations of their scope. The call
+should be:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="n">_Block_object_dispose</span><span class="p">(</span><span class="o">&</span><span class="n">_block_byref_foo</span><span class="p">,</span> <span class="n">BLOCK_FIELD_IS_BYREF</span><span class="p">);</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="nesting">
+<h4><a class="toc-backref" href="#id13">Nesting</a><a class="headerlink" href="#nesting" title="Permalink to this headline">¶</a></h4>
+<p><tt class="docutils literal"><span class="pre">Blocks</span></tt> may contain <tt class="docutils literal"><span class="pre">Block</span></tt> literal expressions. Any variables used within
+inner blocks are imported into all enclosing <tt class="docutils literal"><span class="pre">Block</span></tt> scopes even if the
+variables are not used. This includes <tt class="docutils literal"><span class="pre">const</span></tt> imports as well as <tt class="docutils literal"><span class="pre">__block</span></tt>
+variables.</p>
+</div>
+</div>
+</div>
+<div class="section" id="objective-c-extensions-to-blocks">
+<h2><a class="toc-backref" href="#id14">Objective C Extensions to <tt class="docutils literal"><span class="pre">Blocks</span></tt></a><a class="headerlink" href="#objective-c-extensions-to-blocks" title="Permalink to this headline">¶</a></h2>
+<div class="section" id="importing-objects">
+<h3><a class="toc-backref" href="#id15">Importing Objects</a><a class="headerlink" href="#importing-objects" title="Permalink to this headline">¶</a></h3>
+<p>Objects should be treated as <tt class="docutils literal"><span class="pre">__attribute__((NSObject))</span></tt> variables; all
+<tt class="docutils literal"><span class="pre">copy_helper</span></tt>, <tt class="docutils literal"><span class="pre">dispose_helper</span></tt>, <tt class="docutils literal"><span class="pre">byref_keep</span></tt>, and <tt class="docutils literal"><span class="pre">byref_dispose</span></tt>
+helper functions should use <tt class="docutils literal"><span class="pre">_Block_object_assign</span></tt> and
+<tt class="docutils literal"><span class="pre">_Block_object_dispose</span></tt>. There should be no code generated that uses
+<tt class="docutils literal"><span class="pre">*-retain</span></tt> or <tt class="docutils literal"><span class="pre">*-release</span></tt> methods.</p>
+</div>
+<div class="section" id="blocks-as-objects">
+<h3><a class="toc-backref" href="#id16"><tt class="docutils literal"><span class="pre">Blocks</span></tt> as Objects</a><a class="headerlink" href="#blocks-as-objects" title="Permalink to this headline">¶</a></h3>
+<p>The compiler will treat <tt class="docutils literal"><span class="pre">Blocks</span></tt> as objects when synthesizing property setters
+and getters, will characterize them as objects when generating garbage
+collection strong and weak layout information in the same manner as objects, and
+will issue strong and weak write-barrier assignments in the same manner as
+objects.</p>
+</div>
+<div class="section" id="weak-block-support">
+<h3><a class="toc-backref" href="#id17"><tt class="docutils literal"><span class="pre">__weak</span> <span class="pre">__block</span></tt> Support</a><a class="headerlink" href="#weak-block-support" title="Permalink to this headline">¶</a></h3>
+<p>Objective-C (and Objective-C++) support the <tt class="docutils literal"><span class="pre">__weak</span></tt> attribute on <tt class="docutils literal"><span class="pre">__block</span></tt>
+variables. Under normal circumstances the compiler uses the Objective-C runtime
+helper support functions <tt class="docutils literal"><span class="pre">objc_assign_weak</span></tt> and <tt class="docutils literal"><span class="pre">objc_read_weak</span></tt>. Both
+should continue to be used for all reads and writes of <tt class="docutils literal"><span class="pre">__weak</span> <span class="pre">__block</span></tt>
+variables:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="n">objc_read_weak</span><span class="p">(</span><span class="o">&</span><span class="n">block</span><span class="o">-></span><span class="n">byref_i</span><span class="o">-></span><span class="n">forwarding</span><span class="o">-></span><span class="n">i</span><span class="p">)</span>
+</pre></div>
+</div>
+<p>The <tt class="docutils literal"><span class="pre">__weak</span></tt> variable is stored in a <tt class="docutils literal"><span class="pre">_block_byref_foo</span></tt> structure and the
+<tt class="docutils literal"><span class="pre">Block</span></tt> has copy and dispose helpers for this structure that call:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="n">_Block_object_assign</span><span class="p">(</span><span class="o">&</span><span class="n">dest</span><span class="o">-></span><span class="n">_block_byref_i</span><span class="p">,</span> <span class="n">src</span><span class="o">-></span> <span class="n">_block_byref_i</span><span class="p">,</span> <span class="n">BLOCK_FIELD_IS_WEAK</span> <span class="o">|</span> <span class="n">BLOCK_FIELD_IS_BYREF</span><span class="p">);</span>
+</pre></div>
+</div>
+<p>and:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="n">_Block_object_dispose</span><span class="p">(</span><span class="n">src</span><span class="o">-></span><span class="n">_block_byref_i</span><span class="p">,</span> <span class="n">BLOCK_FIELD_IS_WEAK</span> <span class="o">|</span> <span class="n">BLOCK_FIELD_IS_BYREF</span><span class="p">);</span>
+</pre></div>
+</div>
+<p>In turn, the <tt class="docutils literal"><span class="pre">block_byref</span></tt> copy support helpers distinguish between whether
+the <tt class="docutils literal"><span class="pre">__block</span></tt> variable is a <tt class="docutils literal"><span class="pre">Block</span></tt> or not and should either call:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="n">_Block_object_assign</span><span class="p">(</span><span class="o">&</span><span class="n">dest</span><span class="o">-></span><span class="n">_block_byref_i</span><span class="p">,</span> <span class="n">src</span><span class="o">-></span><span class="n">_block_byref_i</span><span class="p">,</span> <span class="n">BLOCK_FIELD_IS_WEAK</span> <span class="o">|</span> <span class="n">BLOCK_FIELD_IS_OBJECT</span> <span class="o">|</span> <span class="n">BLOCK_BYREF_CALLER</span><span class="p">);</span>
+</pre></div>
+</div>
+<p>for something declared as an object or:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="n">_Block_object_assign</span><span class="p">(</span><span class="o">&</span><span class="n">dest</span><span class="o">-></span><span class="n">_block_byref_i</span><span class="p">,</span> <span class="n">src</span><span class="o">-></span><span class="n">_block_byref_i</span><span class="p">,</span> <span class="n">BLOCK_FIELD_IS_WEAK</span> <span class="o">|</span> <span class="n">BLOCK_FIELD_IS_BLOCK</span> <span class="o">|</span> <span class="n">BLOCK_BYREF_CALLER</span><span class="p">);</span>
+</pre></div>
+</div>
+<p>for something declared as a <tt class="docutils literal"><span class="pre">Block</span></tt>.</p>
+<p>A full example follows:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="n">__block</span> <span class="n">__weak</span> <span class="n">id</span> <span class="n">obj</span> <span class="o">=</span> <span class="o"><</span><span class="n">initialization</span> <span class="n">expression</span><span class="o">></span><span class="p">;</span>
+<span class="n">functioncall</span><span class="p">(</span><span class="o">^</span><span class="p">{</span> <span class="p">[</span><span class="n">obj</span> <span class="n">somemessage</span><span class="p">];</span> <span class="p">});</span>
+</pre></div>
+</div>
+<p>would translate to:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="k">struct</span> <span class="n">_block_byref_obj</span> <span class="p">{</span>
+ <span class="kt">void</span> <span class="o">*</span><span class="n">isa</span><span class="p">;</span> <span class="c1">// uninitialized</span>
+ <span class="k">struct</span> <span class="n">_block_byref_obj</span> <span class="o">*</span><span class="n">forwarding</span><span class="p">;</span>
+ <span class="kt">int</span> <span class="n">flags</span><span class="p">;</span> <span class="c1">//refcount;</span>
+ <span class="kt">int</span> <span class="n">size</span><span class="p">;</span>
+ <span class="kt">void</span> <span class="p">(</span><span class="o">*</span><span class="n">byref_keep</span><span class="p">)(</span><span class="k">struct</span> <span class="n">_block_byref_i</span> <span class="o">*</span><span class="n">dst</span><span class="p">,</span> <span class="k">struct</span> <span class="n">_block_byref_i</span> <span class="o">*</span><span class="n">src</span><span class="p">);</span>
+ <span class="kt">void</span> <span class="p">(</span><span class="o">*</span><span class="n">byref_dispose</span><span class="p">)(</span><span class="k">struct</span> <span class="n">_block_byref_i</span> <span class="o">*</span><span class="p">);</span>
+ <span class="n">id</span> <span class="n">captured_obj</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="kt">void</span> <span class="nf">_block_byref_obj_keep</span><span class="p">(</span><span class="k">struct</span> <span class="n">_block_byref_voidBlock</span> <span class="o">*</span><span class="n">dst</span><span class="p">,</span> <span class="k">struct</span> <span class="n">_block_byref_voidBlock</span> <span class="o">*</span><span class="n">src</span><span class="p">)</span> <span class="p">{</span>
+ <span class="c1">//_Block_copy_assign(&dst->captured_obj, src->captured_obj, 0);</span>
+ <span class="n">_Block_object_assign</span><span class="p">(</span><span class="o">&</span><span class="n">dst</span><span class="o">-></span><span class="n">captured_obj</span><span class="p">,</span> <span class="n">src</span><span class="o">-></span><span class="n">captured_obj</span><span class="p">,</span> <span class="n">BLOCK_FIELD_IS_OBJECT</span> <span class="o">|</span> <span class="n">BLOCK_FIELD_IS_WEAK</span> <span class="o">|</span> <span class="n">BLOCK_BYREF_CALLER</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="kt">void</span> <span class="nf">_block_byref_obj_dispose</span><span class="p">(</span><span class="k">struct</span> <span class="n">_block_byref_voidBlock</span> <span class="o">*</span><span class="n">param</span><span class="p">)</span> <span class="p">{</span>
+ <span class="c1">//_Block_destroy(param->captured_obj, 0);</span>
+ <span class="n">_Block_object_dispose</span><span class="p">(</span><span class="n">param</span><span class="o">-></span><span class="n">captured_obj</span><span class="p">,</span> <span class="n">BLOCK_FIELD_IS_OBJECT</span> <span class="o">|</span> <span class="n">BLOCK_FIELD_IS_WEAK</span> <span class="o">|</span> <span class="n">BLOCK_BYREF_CALLER</span><span class="p">);</span>
+<span class="p">};</span>
+</pre></div>
+</div>
+<p>for the block <tt class="docutils literal"><span class="pre">byref</span></tt> part and:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="k">struct</span> <span class="n">__block_literal_5</span> <span class="p">{</span>
+ <span class="kt">void</span> <span class="o">*</span><span class="n">isa</span><span class="p">;</span>
+ <span class="kt">int</span> <span class="n">flags</span><span class="p">;</span>
+ <span class="kt">int</span> <span class="n">reserved</span><span class="p">;</span>
+ <span class="kt">void</span> <span class="p">(</span><span class="o">*</span><span class="n">invoke</span><span class="p">)(</span><span class="k">struct</span> <span class="n">__block_literal_5</span> <span class="o">*</span><span class="p">);</span>
+ <span class="k">struct</span> <span class="n">__block_descriptor_5</span> <span class="o">*</span><span class="n">descriptor</span><span class="p">;</span>
+ <span class="k">struct</span> <span class="n">_block_byref_obj</span> <span class="o">*</span><span class="n">byref_obj</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="kt">void</span> <span class="nf">__block_invoke_5</span><span class="p">(</span><span class="k">struct</span> <span class="n">__block_literal_5</span> <span class="o">*</span><span class="n">_block</span><span class="p">)</span> <span class="p">{</span>
+ <span class="p">[</span><span class="n">objc_read_weak</span><span class="p">(</span><span class="o">&</span><span class="n">_block</span><span class="o">-></span><span class="n">byref_obj</span><span class="o">-></span><span class="n">forwarding</span><span class="o">-></span><span class="n">captured_obj</span><span class="p">)</span> <span class="n">somemessage</span><span class="p">];</span>
+<span class="p">}</span>
+
+<span class="kt">void</span> <span class="nf">__block_copy_5</span><span class="p">(</span><span class="k">struct</span> <span class="n">__block_literal_5</span> <span class="o">*</span><span class="n">dst</span><span class="p">,</span> <span class="k">struct</span> <span class="n">__block_literal_5</span> <span class="o">*</span><span class="n">src</span><span class="p">)</span> <span class="p">{</span>
+ <span class="c1">//_Block_byref_assign_copy(&dst->byref_obj, src->byref_obj);</span>
+ <span class="n">_Block_object_assign</span><span class="p">(</span><span class="o">&</span><span class="n">dst</span><span class="o">-></span><span class="n">byref_obj</span><span class="p">,</span> <span class="n">src</span><span class="o">-></span><span class="n">byref_obj</span><span class="p">,</span> <span class="n">BLOCK_FIELD_IS_BYREF</span> <span class="o">|</span> <span class="n">BLOCK_FIELD_IS_WEAK</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="kt">void</span> <span class="nf">__block_dispose_5</span><span class="p">(</span><span class="k">struct</span> <span class="n">__block_literal_5</span> <span class="o">*</span><span class="n">src</span><span class="p">)</span> <span class="p">{</span>
+ <span class="c1">//_Block_byref_release(src->byref_obj);</span>
+ <span class="n">_Block_object_dispose</span><span class="p">(</span><span class="n">src</span><span class="o">-></span><span class="n">byref_obj</span><span class="p">,</span> <span class="n">BLOCK_FIELD_IS_BYREF</span> <span class="o">|</span> <span class="n">BLOCK_FIELD_IS_WEAK</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="k">static</span> <span class="k">struct</span> <span class="n">__block_descriptor_5</span> <span class="p">{</span>
+ <span class="kt">unsigned</span> <span class="kt">long</span> <span class="kt">int</span> <span class="n">reserved</span><span class="p">;</span>
+ <span class="kt">unsigned</span> <span class="kt">long</span> <span class="kt">int</span> <span class="n">Block_size</span><span class="p">;</span>
+ <span class="kt">void</span> <span class="p">(</span><span class="o">*</span><span class="n">copy_helper</span><span class="p">)(</span><span class="k">struct</span> <span class="n">__block_literal_5</span> <span class="o">*</span><span class="n">dst</span><span class="p">,</span> <span class="k">struct</span> <span class="n">__block_literal_5</span> <span class="o">*</span><span class="n">src</span><span class="p">);</span>
+ <span class="kt">void</span> <span class="p">(</span><span class="o">*</span><span class="n">dispose_helper</span><span class="p">)(</span><span class="k">struct</span> <span class="n">__block_literal_5</span> <span class="o">*</span><span class="p">);</span>
+<span class="p">}</span> <span class="n">__block_descriptor_5</span> <span class="o">=</span> <span class="p">{</span> <span class="mi">0</span><span class="p">,</span> <span class="k">sizeof</span><span class="p">(</span><span class="k">struct</span> <span class="n">__block_literal_5</span><span class="p">),</span> <span class="n">__block_copy_5</span><span class="p">,</span> <span class="n">__block_dispose_5</span> <span class="p">};</span>
+</pre></div>
+</div>
+<p>and within the compound statement:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="n">truct</span> <span class="n">_block_byref_obj</span> <span class="n">obj</span> <span class="o">=</span> <span class="p">{(</span> <span class="p">.</span><span class="n">forwarding</span><span class="o">=&</span><span class="n">obj</span><span class="p">,</span> <span class="p">.</span><span class="n">flags</span><span class="o">=</span><span class="p">(</span><span class="mi">1</span><span class="o"><<</span><span class="mi">25</span><span class="p">),</span> <span class="p">.</span><span class="n">size</span><span class="o">=</span><span class="k">sizeof</span><span class="p">(</span><span class="k">struct</span> <span class="n">_block_byref_obj</span><span class="p">),</span>
+ <span class="p">.</span><span class="n">byref_keep</span><span class="o">=</span><span class="n">_block_byref_obj_keep</span><span class="p">,</span> <span class="p">.</span><span class="n">byref_dispose</span><span class="o">=</span><span class="n">_block_byref_obj_dispose</span><span class="p">,</span>
+ <span class="p">.</span><span class="n">captured_obj</span> <span class="o">=</span> <span class="o"><</span><span class="n">initialization</span> <span class="n">expression</span><span class="o">></span> <span class="p">)};</span>
+
+<span class="n">truct</span> <span class="n">__block_literal_5</span> <span class="n">_block_literal</span> <span class="o">=</span> <span class="p">{</span>
+ <span class="o">&</span><span class="n">_NSConcreteStackBlock</span><span class="p">,</span>
+ <span class="p">(</span><span class="mi">1</span><span class="o"><<</span><span class="mi">25</span><span class="p">)</span><span class="o">|</span><span class="p">(</span><span class="mi">1</span><span class="o"><<</span><span class="mi">29</span><span class="p">),</span> <span class="o"><</span><span class="n">uninitialized</span><span class="o">></span><span class="p">,</span>
+ <span class="n">__block_invoke_5</span><span class="p">,</span>
+ <span class="o">&</span><span class="n">__block_descriptor_5</span><span class="p">,</span>
+ <span class="o">&</span><span class="n">obj</span><span class="p">,</span> <span class="c1">// a reference to the on-stack structure containing "captured_obj"</span>
+<span class="p">};</span>
+
+
+<span class="n">functioncall</span><span class="p">(</span><span class="n">_block_literal</span><span class="o">-></span><span class="n">invoke</span><span class="p">(</span><span class="o">&</span><span class="n">_block_literal</span><span class="p">));</span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="c-support">
+<h2><a class="toc-backref" href="#id18">C++ Support</a><a class="headerlink" href="#c-support" title="Permalink to this headline">¶</a></h2>
+<p>Within a block stack based C++ objects are copied into <tt class="docutils literal"><span class="pre">const</span></tt> copies using
+the copy constructor. It is an error if a stack based C++ object is used within
+a block if it does not have a copy constructor. In addition both copy and
+destroy helper routines must be synthesized for the block to support the
+<tt class="docutils literal"><span class="pre">Block_copy()</span></tt> operation, and the flags work marked with the (1<<26) bit in
+addition to the (1<<25) bit. The copy helper should call the constructor using
+appropriate offsets of the variable within the supplied stack based block source
+and heap based destination for all <tt class="docutils literal"><span class="pre">const</span></tt> constructed copies, and similarly
+should call the destructor in the destroy routine.</p>
+<p>As an example, suppose a C++ class <tt class="docutils literal"><span class="pre">FOO</span></tt> existed with a copy constructor.
+Within a code block a stack version of a <tt class="docutils literal"><span class="pre">FOO</span></tt> object is declared and used
+within a <tt class="docutils literal"><span class="pre">Block</span></tt> literal expression:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="p">{</span>
+ <span class="n">FOO</span> <span class="n">foo</span><span class="p">;</span>
+ <span class="kt">void</span> <span class="p">(</span><span class="o">^</span><span class="n">block</span><span class="p">)(</span><span class="kt">void</span><span class="p">)</span> <span class="o">=</span> <span class="o">^</span><span class="p">{</span> <span class="n">printf</span><span class="p">(</span><span class="s">"%d</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">foo</span><span class="p">.</span><span class="n">value</span><span class="p">());</span> <span class="p">};</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>The compiler would synthesize:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">struct</span> <span class="n">__block_literal_10</span> <span class="p">{</span>
+ <span class="kt">void</span> <span class="o">*</span><span class="n">isa</span><span class="p">;</span>
+ <span class="kt">int</span> <span class="n">flags</span><span class="p">;</span>
+ <span class="kt">int</span> <span class="n">reserved</span><span class="p">;</span>
+ <span class="kt">void</span> <span class="p">(</span><span class="o">*</span><span class="n">invoke</span><span class="p">)(</span><span class="k">struct</span> <span class="n">__block_literal_10</span> <span class="o">*</span><span class="p">);</span>
+ <span class="k">struct</span> <span class="n">__block_descriptor_10</span> <span class="o">*</span><span class="n">descriptor</span><span class="p">;</span>
+ <span class="k">const</span> <span class="n">FOO</span> <span class="n">foo</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="kt">void</span> <span class="n">__block_invoke_10</span><span class="p">(</span><span class="k">struct</span> <span class="n">__block_literal_10</span> <span class="o">*</span><span class="n">_block</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">printf</span><span class="p">(</span><span class="s">"%d</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">_block</span><span class="o">-></span><span class="n">foo</span><span class="p">.</span><span class="n">value</span><span class="p">());</span>
+<span class="p">}</span>
+
+<span class="kt">void</span> <span class="n">__block_literal_10</span><span class="p">(</span><span class="k">struct</span> <span class="n">__block_literal_10</span> <span class="o">*</span><span class="n">dst</span><span class="p">,</span> <span class="k">struct</span> <span class="n">__block_literal_10</span> <span class="o">*</span><span class="n">src</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">FOO_ctor</span><span class="p">(</span><span class="o">&</span><span class="n">dst</span><span class="o">-></span><span class="n">foo</span><span class="p">,</span> <span class="o">&</span><span class="n">src</span><span class="o">-></span><span class="n">foo</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="kt">void</span> <span class="n">__block_dispose_10</span><span class="p">(</span><span class="k">struct</span> <span class="n">__block_literal_10</span> <span class="o">*</span><span class="n">src</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">FOO_dtor</span><span class="p">(</span><span class="o">&</span><span class="n">src</span><span class="o">-></span><span class="n">foo</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="k">static</span> <span class="k">struct</span> <span class="n">__block_descriptor_10</span> <span class="p">{</span>
+ <span class="kt">unsigned</span> <span class="kt">long</span> <span class="kt">int</span> <span class="n">reserved</span><span class="p">;</span>
+ <span class="kt">unsigned</span> <span class="kt">long</span> <span class="kt">int</span> <span class="n">Block_size</span><span class="p">;</span>
+ <span class="kt">void</span> <span class="p">(</span><span class="o">*</span><span class="n">copy_helper</span><span class="p">)(</span><span class="k">struct</span> <span class="n">__block_literal_10</span> <span class="o">*</span><span class="n">dst</span><span class="p">,</span> <span class="k">struct</span> <span class="n">__block_literal_10</span> <span class="o">*</span><span class="n">src</span><span class="p">);</span>
+ <span class="kt">void</span> <span class="p">(</span><span class="o">*</span><span class="n">dispose_helper</span><span class="p">)(</span><span class="k">struct</span> <span class="n">__block_literal_10</span> <span class="o">*</span><span class="p">);</span>
+<span class="p">}</span> <span class="n">__block_descriptor_10</span> <span class="o">=</span> <span class="p">{</span> <span class="mi">0</span><span class="p">,</span> <span class="k">sizeof</span><span class="p">(</span><span class="k">struct</span> <span class="n">__block_literal_10</span><span class="p">),</span> <span class="n">__block_copy_10</span><span class="p">,</span> <span class="n">__block_dispose_10</span> <span class="p">};</span>
+</pre></div>
+</div>
+<p>and the code would be:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="p">{</span>
+ <span class="n">FOO</span> <span class="n">foo</span><span class="p">;</span>
+ <span class="n">comp_ctor</span><span class="p">(</span><span class="o">&</span><span class="n">foo</span><span class="p">);</span> <span class="c1">// default constructor</span>
+ <span class="k">struct</span> <span class="n">__block_literal_10</span> <span class="n">_block_literal</span> <span class="o">=</span> <span class="p">{</span>
+ <span class="o">&</span><span class="n">_NSConcreteStackBlock</span><span class="p">,</span>
+ <span class="p">(</span><span class="mi">1</span><span class="o"><<</span><span class="mi">25</span><span class="p">)</span><span class="o">|</span><span class="p">(</span><span class="mi">1</span><span class="o"><<</span><span class="mi">26</span><span class="p">)</span><span class="o">|</span><span class="p">(</span><span class="mi">1</span><span class="o"><<</span><span class="mi">29</span><span class="p">),</span> <span class="o"><</span><span class="n">uninitialized</span><span class="o">></span><span class="p">,</span>
+ <span class="n">__block_invoke_10</span><span class="p">,</span>
+ <span class="o">&</span><span class="n">__block_descriptor_10</span><span class="p">,</span>
+ <span class="p">};</span>
+ <span class="n">comp_ctor</span><span class="p">(</span><span class="o">&</span><span class="n">_block_literal</span><span class="o">-></span><span class="n">foo</span><span class="p">,</span> <span class="o">&</span><span class="n">foo</span><span class="p">);</span> <span class="c1">// const copy into stack version</span>
+ <span class="k">struct</span> <span class="n">__block_literal_10</span> <span class="o">&</span><span class="n">block</span> <span class="o">=</span> <span class="o">&</span><span class="n">_block_literal</span><span class="p">;</span> <span class="c1">// assign literal to block variable</span>
+ <span class="n">block</span><span class="o">-></span><span class="n">invoke</span><span class="p">(</span><span class="n">block</span><span class="p">);</span> <span class="c1">// invoke block</span>
+ <span class="n">comp_dtor</span><span class="p">(</span><span class="o">&</span><span class="n">_block_literal</span><span class="o">-></span><span class="n">foo</span><span class="p">);</span> <span class="c1">// destroy stack version of const block copy</span>
+ <span class="n">comp_dtor</span><span class="p">(</span><span class="o">&</span><span class="n">foo</span><span class="p">);</span> <span class="c1">// destroy original version</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>C++ objects stored in <tt class="docutils literal"><span class="pre">__block</span></tt> storage start out on the stack in a
+<tt class="docutils literal"><span class="pre">block_byref</span></tt> data structure as do other variables. Such objects (if not
+<tt class="docutils literal"><span class="pre">const</span></tt> objects) must support a regular copy constructor. The <tt class="docutils literal"><span class="pre">block_byref</span></tt>
+data structure will have copy and destroy helper routines synthesized by the
+compiler. The copy helper will have code created to perform the copy
+constructor based on the initial stack <tt class="docutils literal"><span class="pre">block_byref</span></tt> data structure, and will
+also set the (1<<26) bit in addition to the (1<<25) bit. The destroy helper
+will have code to do the destructor on the object stored within the supplied
+<tt class="docutils literal"><span class="pre">block_byref</span></tt> heap data structure. For example,</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="n">__block</span> <span class="n">FOO</span> <span class="n">blockStorageFoo</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>requires the normal constructor for the embedded <tt class="docutils literal"><span class="pre">blockStorageFoo</span></tt> object:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="n">FOO_ctor</span><span class="p">(</span><span class="o">&</span> <span class="n">_block_byref_blockStorageFoo</span><span class="o">-></span><span class="n">blockStorageFoo</span><span class="p">);</span>
+</pre></div>
+</div>
+<p>and at scope termination the destructor:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="n">FOO_dtor</span><span class="p">(</span><span class="o">&</span> <span class="n">_block_byref_blockStorageFoo</span><span class="o">-></span><span class="n">blockStorageFoo</span><span class="p">);</span>
+</pre></div>
+</div>
+<p>Note that the forwarding indirection is <em>NOT</em> used.</p>
+<p>The compiler would need to generate (if used from a block literal) the following
+copy/dispose helpers:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="kt">void</span> <span class="n">_block_byref_obj_keep</span><span class="p">(</span><span class="k">struct</span> <span class="n">_block_byref_blockStorageFoo</span> <span class="o">*</span><span class="n">dst</span><span class="p">,</span> <span class="k">struct</span> <span class="n">_block_byref_blockStorageFoo</span> <span class="o">*</span><span class="n">src</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">FOO_ctor</span><span class="p">(</span><span class="o">&</span><span class="n">dst</span><span class="o">-></span><span class="n">blockStorageFoo</span><span class="p">,</span> <span class="o">&</span><span class="n">src</span><span class="o">-></span><span class="n">blockStorageFoo</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="kt">void</span> <span class="n">_block_byref_obj_dispose</span><span class="p">(</span><span class="k">struct</span> <span class="n">_block_byref_blockStorageFoo</span> <span class="o">*</span><span class="n">src</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">FOO_dtor</span><span class="p">(</span><span class="o">&</span><span class="n">src</span><span class="o">-></span><span class="n">blockStorageFoo</span><span class="p">);</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>for the appropriately named constructor and destructor for the class/struct
+<tt class="docutils literal"><span class="pre">FOO</span></tt>.</p>
+<p>To support member variable and function access the compiler will synthesize a
+<tt class="docutils literal"><span class="pre">const</span></tt> pointer to a block version of the <tt class="docutils literal"><span class="pre">this</span></tt> pointer.</p>
+</div>
+<div class="section" id="runtime-helper-functions">
+<span id="runtimehelperfunctions"></span><h2><a class="toc-backref" href="#id19">Runtime Helper Functions</a><a class="headerlink" href="#runtime-helper-functions" title="Permalink to this headline">¶</a></h2>
+<p>The runtime helper functions are described in
+<tt class="docutils literal"><span class="pre">/usr/local/include/Block_private.h</span></tt>. To summarize their use, a <tt class="docutils literal"><span class="pre">Block</span></tt>
+requires copy/dispose helpers if it imports any block variables, <tt class="docutils literal"><span class="pre">__block</span></tt>
+storage variables, <tt class="docutils literal"><span class="pre">__attribute__((NSObject))</span></tt> variables, or C++ <tt class="docutils literal"><span class="pre">const</span></tt>
+copied objects with constructor/destructors. The (1<<26) bit is set and
+functions are generated.</p>
+<p>The block copy helper function should, for each of the variables of the type
+mentioned above, call:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="n">_Block_object_assign</span><span class="p">(</span><span class="o">&</span><span class="n">dst</span><span class="o">-></span><span class="n">target</span><span class="p">,</span> <span class="n">src</span><span class="o">-></span><span class="n">target</span><span class="p">,</span> <span class="n">BLOCK_FIELD_</span><span class="o"><</span><span class="n">apropos</span><span class="o">></span><span class="p">);</span>
+</pre></div>
+</div>
+<p>in the copy helper and:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="n">_Block_object_dispose</span><span class="p">(</span><span class="o">-></span><span class="n">target</span><span class="p">,</span> <span class="n">BLOCK_FIELD_</span><span class="o"><</span><span class="n">apropos</span><span class="o">></span><span class="p">);</span>
+</pre></div>
+</div>
+<p>in the dispose helper where <tt class="docutils literal"><span class="pre"><apropos></span></tt> is:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="k">enum</span> <span class="p">{</span>
+ <span class="n">BLOCK_FIELD_IS_OBJECT</span> <span class="o">=</span> <span class="mi">3</span><span class="p">,</span> <span class="c1">// id, NSObject, __attribute__((NSObject)), block, ...</span>
+ <span class="n">BLOCK_FIELD_IS_BLOCK</span> <span class="o">=</span> <span class="mi">7</span><span class="p">,</span> <span class="c1">// a block variable</span>
+ <span class="n">BLOCK_FIELD_IS_BYREF</span> <span class="o">=</span> <span class="mi">8</span><span class="p">,</span> <span class="c1">// the on stack structure holding the __block variable</span>
+
+ <span class="n">BLOCK_FIELD_IS_WEAK</span> <span class="o">=</span> <span class="mi">16</span><span class="p">,</span> <span class="c1">// declared __weak</span>
+
+ <span class="n">BLOCK_BYREF_CALLER</span> <span class="o">=</span> <span class="mi">128</span><span class="p">,</span> <span class="c1">// called from byref copy/dispose helpers</span>
+<span class="p">};</span>
+</pre></div>
+</div>
+<p>and of course the constructors/destructors for <tt class="docutils literal"><span class="pre">const</span></tt> copied C++ objects.</p>
+<p>The <tt class="docutils literal"><span class="pre">block_byref</span></tt> data structure similarly requires copy/dispose helpers for
+block variables, <tt class="docutils literal"><span class="pre">__attribute__((NSObject))</span></tt> variables, or C++ <tt class="docutils literal"><span class="pre">const</span></tt>
+copied objects with constructor/destructors, and again the (1<<26) bit is set
+and functions are generated in the same manner.</p>
+<p>Under ObjC we allow <tt class="docutils literal"><span class="pre">__weak</span></tt> as an attribute on <tt class="docutils literal"><span class="pre">__block</span></tt> variables, and
+this causes the addition of <tt class="docutils literal"><span class="pre">BLOCK_FIELD_IS_WEAK</span></tt> orred onto the
+<tt class="docutils literal"><span class="pre">BLOCK_FIELD_IS_BYREF</span></tt> flag when copying the <tt class="docutils literal"><span class="pre">block_byref</span></tt> structure in the
+<tt class="docutils literal"><span class="pre">Block</span></tt> copy helper, and onto the <tt class="docutils literal"><span class="pre">BLOCK_FIELD_<apropos></span></tt> field within the
+<tt class="docutils literal"><span class="pre">block_byref</span></tt> copy/dispose helper calls.</p>
+<p>The prototypes, and summary, of the helper functions are:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="cm">/* Certain field types require runtime assistance when being copied to the</span>
+<span class="cm"> heap. The following function is used to copy fields of types: blocks,</span>
+<span class="cm"> pointers to byref structures, and objects (including</span>
+<span class="cm"> __attribute__((NSObject)) pointers. BLOCK_FIELD_IS_WEAK is orthogonal to</span>
+<span class="cm"> the other choices which are mutually exclusive. Only in a Block copy</span>
+<span class="cm"> helper will one see BLOCK_FIELD_IS_BYREF.</span>
+<span class="cm">*/</span>
+<span class="kt">void</span> <span class="n">_Block_object_assign</span><span class="p">(</span><span class="kt">void</span> <span class="o">*</span><span class="n">destAddr</span><span class="p">,</span> <span class="k">const</span> <span class="kt">void</span> <span class="o">*</span><span class="n">object</span><span class="p">,</span> <span class="k">const</span> <span class="kt">int</span> <span class="n">flags</span><span class="p">);</span>
+
+<span class="cm">/* Similarly a compiler generated dispose helper needs to call back for each</span>
+<span class="cm"> field of the byref data structure. (Currently the implementation only</span>
+<span class="cm"> packs one field into the byref structure but in principle there could be</span>
+<span class="cm"> more). The same flags used in the copy helper should be used for each</span>
+<span class="cm"> call generated to this function:</span>
+<span class="cm">*/</span>
+<span class="kt">void</span> <span class="n">_Block_object_dispose</span><span class="p">(</span><span class="k">const</span> <span class="kt">void</span> <span class="o">*</span><span class="n">object</span><span class="p">,</span> <span class="k">const</span> <span class="kt">int</span> <span class="n">flags</span><span class="p">);</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="copyright">
+<h2><a class="toc-backref" href="#id20">Copyright</a><a class="headerlink" href="#copyright" title="Permalink to this headline">¶</a></h2>
+<p>Copyright 2008-2010 Apple, Inc.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:</p>
+<p>The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.</p>
+<p>THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.</p>
+</div>
+</div>
+
+
+ </div>
+ <div class="bottomnav">
+
+ <p>
+ « <a href="BlockLanguageSpec.html">Language Specification for Blocks</a>
+ ::
+ <a class="uplink" href="index.html">Contents</a>
+ ::
+ <a href="AutomaticReferenceCounting.html">Objective-C Automatic Reference Counting (ARC)</a> »
+ </p>
+
+ </div>
+
+ <div class="footer">
+ © Copyright 2007-2018, The Clang Team.
+ Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/6.0.1/tools/clang/docs/BlockLanguageSpec.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/6.0.1/tools/clang/docs/BlockLanguageSpec.html?rev=336152&view=auto
==============================================================================
--- www-releases/trunk/6.0.1/tools/clang/docs/BlockLanguageSpec.html (added)
+++ www-releases/trunk/6.0.1/tools/clang/docs/BlockLanguageSpec.html Mon Jul 2 16:21:43 2018
@@ -0,0 +1,376 @@
+
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+ <title>Language Specification for Blocks — Clang 6 documentation</title>
+
+ <link rel="stylesheet" href="_static/haiku.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+ <link rel="stylesheet" href="_static/print.css" type="text/css" />
+
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: '',
+ VERSION: '6',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true
+ };
+ </script>
+ <script type="text/javascript" src="_static/jquery.js"></script>
+ <script type="text/javascript" src="_static/underscore.js"></script>
+ <script type="text/javascript" src="_static/doctools.js"></script>
+ <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+ <script type="text/javascript" src="_static/theme_extras.js"></script>
+ <link rel="top" title="Clang 6 documentation" href="index.html" />
+ <link rel="up" title="Clang Language Extensions" href="LanguageExtensions.html" />
+ <link rel="next" title="Block Implementation Specification" href="Block-ABI-Apple.html" />
+ <link rel="prev" title="Objective-C Literals" href="ObjectiveCLiterals.html" />
+ </head>
+ <body>
+ <div class="header"><h1 class="heading"><a href="index.html">
+ <span>Clang 6 documentation</span></a></h1>
+ <h2 class="heading"><span>Language Specification for Blocks</span></h2>
+ </div>
+ <div class="topnav">
+
+ <p>
+ « <a href="ObjectiveCLiterals.html">Objective-C Literals</a>
+ ::
+ <a class="uplink" href="index.html">Contents</a>
+ ::
+ <a href="Block-ABI-Apple.html">Block Implementation Specification</a> »
+ </p>
+
+ </div>
+ <div class="content">
+
+
+ <div class="section" id="language-specification-for-blocks">
+<h1>Language Specification for Blocks<a class="headerlink" href="#language-specification-for-blocks" title="Permalink to this headline">¶</a></h1>
+<div class="contents local topic" id="contents">
+<ul class="simple">
+<li><a class="reference internal" href="#revisions" id="id1">Revisions</a></li>
+<li><a class="reference internal" href="#overview" id="id2">Overview</a></li>
+<li><a class="reference internal" href="#the-block-type" id="id3">The Block Type</a></li>
+<li><a class="reference internal" href="#block-variable-declarations" id="id4">Block Variable Declarations</a></li>
+<li><a class="reference internal" href="#block-literal-expressions" id="id5">Block Literal Expressions</a></li>
+<li><a class="reference internal" href="#the-invoke-operator" id="id6">The Invoke Operator</a></li>
+<li><a class="reference internal" href="#the-copy-and-release-operations" id="id7">The Copy and Release Operations</a></li>
+<li><a class="reference internal" href="#the-block-storage-qualifier" id="id8">The <tt class="docutils literal"><span class="pre">__block</span></tt> Storage Qualifier</a></li>
+<li><a class="reference internal" href="#control-flow" id="id9">Control Flow</a></li>
+<li><a class="reference internal" href="#objective-c-extensions" id="id10">Objective-C Extensions</a></li>
+<li><a class="reference internal" href="#c-extensions" id="id11">C++ Extensions</a></li>
+</ul>
+</div>
+<div class="section" id="revisions">
+<h2><a class="toc-backref" href="#id1">Revisions</a><a class="headerlink" href="#revisions" title="Permalink to this headline">¶</a></h2>
+<ul class="simple">
+<li>2008/2/25 — created</li>
+<li>2008/7/28 — revised, <tt class="docutils literal"><span class="pre">__block</span></tt> syntax</li>
+<li>2008/8/13 — revised, Block globals</li>
+<li>2008/8/21 — revised, C++ elaboration</li>
+<li>2008/11/1 — revised, <tt class="docutils literal"><span class="pre">__weak</span></tt> support</li>
+<li>2009/1/12 — revised, explicit return types</li>
+<li>2009/2/10 — revised, <tt class="docutils literal"><span class="pre">__block</span></tt> objects need retain</li>
+</ul>
+</div>
+<div class="section" id="overview">
+<h2><a class="toc-backref" href="#id2">Overview</a><a class="headerlink" href="#overview" title="Permalink to this headline">¶</a></h2>
+<p>A new derived type is introduced to C and, by extension, Objective-C,
+C++, and Objective-C++</p>
+</div>
+<div class="section" id="the-block-type">
+<h2><a class="toc-backref" href="#id3">The Block Type</a><a class="headerlink" href="#the-block-type" title="Permalink to this headline">¶</a></h2>
+<p>Like function types, the <span class="block-term">Block type</span> is a pair consisting
+of a result value type and a list of parameter types very similar to a
+function type. Blocks are intended to be used much like functions with
+the key distinction being that in addition to executable code they
+also contain various variable bindings to automatic (stack) or managed
+(heap) memory.</p>
+<p>The abstract declarator,</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="kt">int</span> <span class="p">(</span><span class="o">^</span><span class="p">)(</span><span class="kt">char</span><span class="p">,</span> <span class="kt">float</span><span class="p">)</span>
+</pre></div>
+</div>
+<p>describes a reference to a Block that, when invoked, takes two
+parameters, the first of type char and the second of type float, and
+returns a value of type int. The Block referenced is of opaque data
+that may reside in automatic (stack) memory, global memory, or heap
+memory.</p>
+</div>
+<div class="section" id="block-variable-declarations">
+<h2><a class="toc-backref" href="#id4">Block Variable Declarations</a><a class="headerlink" href="#block-variable-declarations" title="Permalink to this headline">¶</a></h2>
+<p>A <span class="block-term">variable with Block type</span> is declared using function
+pointer style notation substituting <tt class="docutils literal"><span class="pre">^</span></tt> for <tt class="docutils literal"><span class="pre">*</span></tt>. The following are
+valid Block variable declarations:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="kt">void</span> <span class="p">(</span><span class="o">^</span><span class="n">blockReturningVoidWithVoidArgument</span><span class="p">)(</span><span class="kt">void</span><span class="p">);</span>
+<span class="kt">int</span> <span class="p">(</span><span class="o">^</span><span class="n">blockReturningIntWithIntAndCharArguments</span><span class="p">)(</span><span class="kt">int</span><span class="p">,</span> <span class="kt">char</span><span class="p">);</span>
+<span class="kt">void</span> <span class="p">(</span><span class="o">^</span><span class="n">arrayOfTenBlocksReturningVoidWithIntArgument</span><span class="p">[</span><span class="mi">10</span><span class="p">])(</span><span class="kt">int</span><span class="p">);</span>
+</pre></div>
+</div>
+<p>Variadic <tt class="docutils literal"><span class="pre">...</span></tt> arguments are supported. [variadic.c] A Block that
+takes no arguments must specify void in the argument list [voidarg.c].
+An empty parameter list does not represent, as K&R provide, an
+unspecified argument list. Note: both gcc and clang support K&R style
+as a convenience.</p>
+<p>A Block reference may be cast to a pointer of arbitrary type and vice
+versa. [cast.c] A Block reference may not be dereferenced via the
+pointer dereference operator <tt class="docutils literal"><span class="pre">*</span></tt>, and thus a Block’s size may not be
+computed at compile time. [sizeof.c]</p>
+</div>
+<div class="section" id="block-literal-expressions">
+<h2><a class="toc-backref" href="#id5">Block Literal Expressions</a><a class="headerlink" href="#block-literal-expressions" title="Permalink to this headline">¶</a></h2>
+<p>A <span class="block-term">Block literal expression</span> produces a reference to a
+Block. It is introduced by the use of the <tt class="docutils literal"><span class="pre">^</span></tt> token as a unary
+operator.</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="n">Block_literal_expression</span> <span class="o">::=</span> <span class="o">^</span> <span class="n">block_decl</span> <span class="n">compound_statement_body</span>
+<span class="n">block_decl</span> <span class="o">::=</span>
+<span class="n">block_decl</span> <span class="o">::=</span> <span class="n">parameter_list</span>
+<span class="n">block_decl</span> <span class="o">::=</span> <span class="n">type_expression</span>
+</pre></div>
+</div>
+<p>where type expression is extended to allow <tt class="docutils literal"><span class="pre">^</span></tt> as a Block reference
+(pointer) where <tt class="docutils literal"><span class="pre">*</span></tt> is allowed as a function reference (pointer).</p>
+<p>The following Block literal:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="o">^</span> <span class="kt">void</span> <span class="p">(</span><span class="kt">void</span><span class="p">)</span> <span class="p">{</span> <span class="n">printf</span><span class="p">(</span><span class="s">"hello world</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span> <span class="p">}</span>
+</pre></div>
+</div>
+<p>produces a reference to a Block with no arguments with no return value.</p>
+<p>The return type is optional and is inferred from the return
+statements. If the return statements return a value, they all must
+return a value of the same type. If there is no value returned the
+inferred type of the Block is void; otherwise it is the type of the
+return statement value.</p>
+<p>If the return type is omitted and the argument list is <tt class="docutils literal"><span class="pre">(</span> <span class="pre">void</span> <span class="pre">)</span></tt>,
+the <tt class="docutils literal"><span class="pre">(</span> <span class="pre">void</span> <span class="pre">)</span></tt> argument list may also be omitted.</p>
+<p>So:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="o">^</span> <span class="p">(</span> <span class="kt">void</span> <span class="p">)</span> <span class="p">{</span> <span class="n">printf</span><span class="p">(</span><span class="s">"hello world</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span> <span class="p">}</span>
+</pre></div>
+</div>
+<p>and:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="o">^</span> <span class="p">{</span> <span class="n">printf</span><span class="p">(</span><span class="s">"hello world</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span> <span class="p">}</span>
+</pre></div>
+</div>
+<p>are exactly equivalent constructs for the same expression.</p>
+<p>The type_expression extends C expression parsing to accommodate Block
+reference declarations as it accommodates function pointer
+declarations.</p>
+<p>Given:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="k">typedef</span> <span class="kt">int</span> <span class="p">(</span><span class="o">*</span><span class="n">pointerToFunctionThatReturnsIntWithCharArg</span><span class="p">)(</span><span class="kt">char</span><span class="p">);</span>
+<span class="n">pointerToFunctionThatReturnsIntWithCharArg</span> <span class="n">functionPointer</span><span class="p">;</span>
+<span class="o">^</span> <span class="n">pointerToFunctionThatReturnsIntWithCharArg</span> <span class="p">(</span><span class="kt">float</span> <span class="n">x</span><span class="p">)</span> <span class="p">{</span> <span class="k">return</span> <span class="n">functionPointer</span><span class="p">;</span> <span class="p">}</span>
+</pre></div>
+</div>
+<p>and:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="o">^</span> <span class="kt">int</span> <span class="p">((</span><span class="o">*</span><span class="p">)(</span><span class="kt">float</span> <span class="n">x</span><span class="p">))(</span><span class="kt">char</span><span class="p">)</span> <span class="p">{</span> <span class="k">return</span> <span class="n">functionPointer</span><span class="p">;</span> <span class="p">}</span>
+</pre></div>
+</div>
+<p>are equivalent expressions, as is:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="o">^</span><span class="p">(</span><span class="kt">float</span> <span class="n">x</span><span class="p">)</span> <span class="p">{</span> <span class="k">return</span> <span class="n">functionPointer</span><span class="p">;</span> <span class="p">}</span>
+</pre></div>
+</div>
+<p>[returnfunctionptr.c]</p>
+<p>The compound statement body establishes a new lexical scope within
+that of its parent. Variables used within the scope of the compound
+statement are bound to the Block in the normal manner with the
+exception of those in automatic (stack) storage. Thus one may access
+functions and global variables as one would expect, as well as static
+local variables. [testme]</p>
+<p>Local automatic (stack) variables referenced within the compound
+statement of a Block are imported and captured by the Block as const
+copies. The capture (binding) is performed at the time of the Block
+literal expression evaluation.</p>
+<p>The compiler is not required to capture a variable if it can prove
+that no references to the variable will actually be evaluated.
+Programmers can force a variable to be captured by referencing it in a
+statement at the beginning of the Block, like so:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="p">(</span><span class="kt">void</span><span class="p">)</span> <span class="n">foo</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>This matters when capturing the variable has side-effects, as it can
+in Objective-C or C++.</p>
+<p>The lifetime of variables declared in a Block is that of a function;
+each activation frame contains a new copy of variables declared within
+the local scope of the Block. Such variable declarations should be
+allowed anywhere [testme] rather than only when C99 parsing is
+requested, including for statements. [testme]</p>
+<p>Block literal expressions may occur within Block literal expressions
+(nest) and all variables captured by any nested blocks are implicitly
+also captured in the scopes of their enclosing Blocks.</p>
+<p>A Block literal expression may be used as the initialization value for
+Block variables at global or local static scope.</p>
+</div>
+<div class="section" id="the-invoke-operator">
+<h2><a class="toc-backref" href="#id6">The Invoke Operator</a><a class="headerlink" href="#the-invoke-operator" title="Permalink to this headline">¶</a></h2>
+<p>Blocks are <span class="block-term">invoked</span> using function call syntax with a
+list of expression parameters of types corresponding to the
+declaration and returning a result type also according to the
+declaration. Given:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="kt">int</span> <span class="p">(</span><span class="o">^</span><span class="n">x</span><span class="p">)(</span><span class="kt">char</span><span class="p">);</span>
+<span class="kt">void</span> <span class="p">(</span><span class="o">^</span><span class="n">z</span><span class="p">)(</span><span class="kt">void</span><span class="p">);</span>
+<span class="kt">int</span> <span class="p">(</span><span class="o">^</span><span class="p">(</span><span class="o">*</span><span class="n">y</span><span class="p">))(</span><span class="kt">char</span><span class="p">)</span> <span class="o">=</span> <span class="o">&</span><span class="n">x</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>the following are all legal Block invocations:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="n">x</span><span class="p">(</span><span class="sc">'a'</span><span class="p">);</span>
+<span class="p">(</span><span class="o">*</span><span class="n">y</span><span class="p">)(</span><span class="sc">'a'</span><span class="p">);</span>
+<span class="p">(</span><span class="nb">true</span> <span class="o">?</span> <span class="n">x</span> <span class="o">:</span> <span class="o">*</span><span class="n">y</span><span class="p">)(</span><span class="sc">'a'</span><span class="p">)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="the-copy-and-release-operations">
+<h2><a class="toc-backref" href="#id7">The Copy and Release Operations</a><a class="headerlink" href="#the-copy-and-release-operations" title="Permalink to this headline">¶</a></h2>
+<p>The compiler and runtime provide <span class="block-term">copy</span> and
+<span class="block-term">release</span> operations for Block references that create and,
+in matched use, release allocated storage for referenced Blocks.</p>
+<p>The copy operation <tt class="docutils literal"><span class="pre">Block_copy()</span></tt> is styled as a function that takes
+an arbitrary Block reference and returns a Block reference of the same
+type. The release operation, <tt class="docutils literal"><span class="pre">Block_release()</span></tt>, is styled as a
+function that takes an arbitrary Block reference and, if dynamically
+matched to a Block copy operation, allows recovery of the referenced
+allocated memory.</p>
+</div>
+<div class="section" id="the-block-storage-qualifier">
+<h2><a class="toc-backref" href="#id8">The <tt class="docutils literal"><span class="pre">__block</span></tt> Storage Qualifier</a><a class="headerlink" href="#the-block-storage-qualifier" title="Permalink to this headline">¶</a></h2>
+<p>In addition to the new Block type we also introduce a new storage
+qualifier, <span class="block-term">__block</span>, for local variables. [testme: a
+__block declaration within a block literal] The <tt class="docutils literal"><span class="pre">__block</span></tt> storage
+qualifier is mutually exclusive to the existing local storage
+qualifiers auto, register, and static. [testme] Variables qualified by
+<tt class="docutils literal"><span class="pre">__block</span></tt> act as if they were in allocated storage and this storage
+is automatically recovered after last use of said variable. An
+implementation may choose an optimization where the storage is
+initially automatic and only “moved” to allocated (heap) storage upon
+a Block_copy of a referencing Block. Such variables may be mutated as
+normal variables are.</p>
+<p>In the case where a <tt class="docutils literal"><span class="pre">__block</span></tt> variable is a Block one must assume
+that the <tt class="docutils literal"><span class="pre">__block</span></tt> variable resides in allocated storage and as such
+is assumed to reference a Block that is also in allocated storage
+(that it is the result of a <tt class="docutils literal"><span class="pre">Block_copy</span></tt> operation). Despite this
+there is no provision to do a <tt class="docutils literal"><span class="pre">Block_copy</span></tt> or a <tt class="docutils literal"><span class="pre">Block_release</span></tt> if
+an implementation provides initial automatic storage for Blocks. This
+is due to the inherent race condition of potentially several threads
+trying to update the shared variable and the need for synchronization
+around disposing of older values and copying new ones. Such
+synchronization is beyond the scope of this language specification.</p>
+</div>
+<div class="section" id="control-flow">
+<h2><a class="toc-backref" href="#id9">Control Flow</a><a class="headerlink" href="#control-flow" title="Permalink to this headline">¶</a></h2>
+<p>The compound statement of a Block is treated much like a function body
+with respect to control flow in that goto, break, and continue do not
+escape the Block. Exceptions are treated <em>normally</em> in that when
+thrown they pop stack frames until a catch clause is found.</p>
+</div>
+<div class="section" id="objective-c-extensions">
+<h2><a class="toc-backref" href="#id10">Objective-C Extensions</a><a class="headerlink" href="#objective-c-extensions" title="Permalink to this headline">¶</a></h2>
+<p>Objective-C extends the definition of a Block reference type to be
+that also of id. A variable or expression of Block type may be
+messaged or used as a parameter wherever an id may be. The converse is
+also true. Block references may thus appear as properties and are
+subject to the assign, retain, and copy attribute logic that is
+reserved for objects.</p>
+<p>All Blocks are constructed to be Objective-C objects regardless of
+whether the Objective-C runtime is operational in the program or
+not. Blocks using automatic (stack) memory are objects and may be
+messaged, although they may not be assigned into <tt class="docutils literal"><span class="pre">__weak</span></tt> locations
+if garbage collection is enabled.</p>
+<p>Within a Block literal expression within a method definition
+references to instance variables are also imported into the lexical
+scope of the compound statement. These variables are implicitly
+qualified as references from self, and so self is imported as a const
+copy. The net effect is that instance variables can be mutated.</p>
+<p>The <span class="block-term">Block_copy</span> operator retains all objects held in
+variables of automatic storage referenced within the Block expression
+(or form strong references if running under garbage collection).
+Object variables of <tt class="docutils literal"><span class="pre">__block</span></tt> storage type are assumed to hold
+normal pointers with no provision for retain and release messages.</p>
+<p>Foundation defines (and supplies) <tt class="docutils literal"><span class="pre">-copy</span></tt> and <tt class="docutils literal"><span class="pre">-release</span></tt> methods for
+Blocks.</p>
+<p>In the Objective-C and Objective-C++ languages, we allow the
+<tt class="docutils literal"><span class="pre">__weak</span></tt> specifier for <tt class="docutils literal"><span class="pre">__block</span></tt> variables of object type. If
+garbage collection is not enabled, this qualifier causes these
+variables to be kept without retain messages being sent. This
+knowingly leads to dangling pointers if the Block (or a copy) outlives
+the lifetime of this object.</p>
+<p>In garbage collected environments, the <tt class="docutils literal"><span class="pre">__weak</span></tt> variable is set to
+nil when the object it references is collected, as long as the
+<tt class="docutils literal"><span class="pre">__block</span></tt> variable resides in the heap (either by default or via
+<tt class="docutils literal"><span class="pre">Block_copy()</span></tt>). The initial Apple implementation does in fact
+start <tt class="docutils literal"><span class="pre">__block</span></tt> variables on the stack and migrate them to the heap
+only as a result of a <tt class="docutils literal"><span class="pre">Block_copy()</span></tt> operation.</p>
+<p>It is a runtime error to attempt to assign a reference to a
+stack-based Block into any storage marked <tt class="docutils literal"><span class="pre">__weak</span></tt>, including
+<tt class="docutils literal"><span class="pre">__weak</span></tt> <tt class="docutils literal"><span class="pre">__block</span></tt> variables.</p>
+</div>
+<div class="section" id="c-extensions">
+<h2><a class="toc-backref" href="#id11">C++ Extensions</a><a class="headerlink" href="#c-extensions" title="Permalink to this headline">¶</a></h2>
+<p>Block literal expressions within functions are extended to allow const
+use of C++ objects, pointers, or references held in automatic storage.</p>
+<p>As usual, within the block, references to captured variables become
+const-qualified, as if they were references to members of a const
+object. Note that this does not change the type of a variable of
+reference type.</p>
+<p>For example, given a class Foo:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="n">Foo</span> <span class="n">foo</span><span class="p">;</span>
+<span class="n">Foo</span> <span class="o">&</span><span class="n">fooRef</span> <span class="o">=</span> <span class="n">foo</span><span class="p">;</span>
+<span class="n">Foo</span> <span class="o">*</span><span class="n">fooPtr</span> <span class="o">=</span> <span class="o">&</span><span class="n">foo</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>A Block that referenced these variables would import the variables as
+const variations:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="k">const</span> <span class="n">Foo</span> <span class="n">block_foo</span> <span class="o">=</span> <span class="n">foo</span><span class="p">;</span>
+<span class="n">Foo</span> <span class="o">&</span><span class="n">block_fooRef</span> <span class="o">=</span> <span class="n">fooRef</span><span class="p">;</span>
+<span class="n">Foo</span> <span class="o">*</span><span class="k">const</span> <span class="n">block_fooPtr</span> <span class="o">=</span> <span class="n">fooPtr</span><span class="p">;</span>
+</pre></div>
+</div>
+<p>Captured variables are copied into the Block at the instant of
+evaluating the Block literal expression. They are also copied when
+calling <tt class="docutils literal"><span class="pre">Block_copy()</span></tt> on a Block allocated on the stack. In both
+cases, they are copied as if the variable were const-qualified, and
+it’s an error if there’s no such constructor.</p>
+<p>Captured variables in Blocks on the stack are destroyed when control
+leaves the compound statement that contains the Block literal
+expression. Captured variables in Blocks on the heap are destroyed
+when the reference count of the Block drops to zero.</p>
+<p>Variables declared as residing in <tt class="docutils literal"><span class="pre">__block</span></tt> storage may be initially
+allocated in the heap or may first appear on the stack and be copied
+to the heap as a result of a <tt class="docutils literal"><span class="pre">Block_copy()</span></tt> operation. When copied
+from the stack, <tt class="docutils literal"><span class="pre">__block</span></tt> variables are copied using their normal
+qualification (i.e. without adding const). In C++11, <tt class="docutils literal"><span class="pre">__block</span></tt>
+variables are copied as x-values if that is possible, then as l-values
+if not; if both fail, it’s an error. The destructor for any initial
+stack-based version is called at the variable’s normal end of scope.</p>
+<p>References to <tt class="docutils literal"><span class="pre">this</span></tt>, as well as references to non-static members of
+any enclosing class, are evaluated by capturing <tt class="docutils literal"><span class="pre">this</span></tt> just like a
+normal variable of C pointer type.</p>
+<p>Member variables that are Blocks may not be overloaded by the types of
+their arguments.</p>
+</div>
+</div>
+
+
+ </div>
+ <div class="bottomnav">
+
+ <p>
+ « <a href="ObjectiveCLiterals.html">Objective-C Literals</a>
+ ::
+ <a class="uplink" href="index.html">Contents</a>
+ ::
+ <a href="Block-ABI-Apple.html">Block Implementation Specification</a> »
+ </p>
+
+ </div>
+
+ <div class="footer">
+ © Copyright 2007-2018, The Clang Team.
+ Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/6.0.1/tools/clang/docs/ClangCheck.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/6.0.1/tools/clang/docs/ClangCheck.html?rev=336152&view=auto
==============================================================================
--- www-releases/trunk/6.0.1/tools/clang/docs/ClangCheck.html (added)
+++ www-releases/trunk/6.0.1/tools/clang/docs/ClangCheck.html Mon Jul 2 16:21:43 2018
@@ -0,0 +1,107 @@
+
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+ <title>ClangCheck — Clang 6 documentation</title>
+
+ <link rel="stylesheet" href="_static/haiku.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+ <link rel="stylesheet" href="_static/print.css" type="text/css" />
+
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: '',
+ VERSION: '6',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true
+ };
+ </script>
+ <script type="text/javascript" src="_static/jquery.js"></script>
+ <script type="text/javascript" src="_static/underscore.js"></script>
+ <script type="text/javascript" src="_static/doctools.js"></script>
+ <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+ <script type="text/javascript" src="_static/theme_extras.js"></script>
+ <link rel="top" title="Clang 6 documentation" href="index.html" />
+ <link rel="next" title="ClangFormat" href="ClangFormat.html" />
+ <link rel="prev" title="Overview" href="ClangTools.html" />
+ </head>
+ <body>
+ <div class="header"><h1 class="heading"><a href="index.html">
+ <span>Clang 6 documentation</span></a></h1>
+ <h2 class="heading"><span>ClangCheck</span></h2>
+ </div>
+ <div class="topnav">
+
+ <p>
+ « <a href="ClangTools.html">Overview</a>
+ ::
+ <a class="uplink" href="index.html">Contents</a>
+ ::
+ <a href="ClangFormat.html">ClangFormat</a> »
+ </p>
+
+ </div>
+ <div class="content">
+
+
+ <div class="section" id="clangcheck">
+<h1>ClangCheck<a class="headerlink" href="#clangcheck" title="Permalink to this headline">¶</a></h1>
+<p><cite>ClangCheck</cite> is a small wrapper around <a class="reference internal" href="LibTooling.html"><em>LibTooling</em></a> which can be used to
+do basic error checking and AST dumping.</p>
+<div class="highlight-console"><div class="highlight"><pre><span class="gp">$</span> cat <span class="s"><<EOF > snippet.cc</span>
+<span class="gp">></span><span class="s"> void f() {</span>
+<span class="gp">></span><span class="s"> int a = 0</span>
+<span class="gp">></span><span class="s"> }</span>
+<span class="gp">></span><span class="s"> EOF</span>
+<span class="gp">$</span> ~/clang/build/bin/clang-check snippet.cc -ast-dump --
+<span class="go">Processing: /Users/danieljasper/clang/llvm/tools/clang/docs/snippet.cc.</span>
+<span class="go">/Users/danieljasper/clang/llvm/tools/clang/docs/snippet.cc:2:12: error: expected ';' at end of</span>
+<span class="go"> declaration</span>
+<span class="go"> int a = 0</span>
+<span class="go"> ^</span>
+<span class="go"> ;</span>
+<span class="go">(TranslationUnitDecl 0x7ff3a3029ed0 <<invalid sloc>></span>
+<span class="go"> (TypedefDecl 0x7ff3a302a410 <<invalid sloc>> __int128_t '__int128')</span>
+<span class="go"> (TypedefDecl 0x7ff3a302a470 <<invalid sloc>> __uint128_t 'unsigned __int128')</span>
+<span class="go"> (TypedefDecl 0x7ff3a302a830 <<invalid sloc>> __builtin_va_list '__va_list_tag [1]')</span>
+<span class="go"> (FunctionDecl 0x7ff3a302a8d0 </Users/danieljasper/clang/llvm/tools/clang/docs/snippet.cc:1:1, line:3:1> f 'void (void)'</span>
+<span class="go"> (CompoundStmt 0x7ff3a302aa10 <line:1:10, line:3:1></span>
+<span class="go"> (DeclStmt 0x7ff3a302a9f8 <line:2:3, line:3:1></span>
+<span class="go"> (VarDecl 0x7ff3a302a980 <line:2:3, col:11> a 'int'</span>
+<span class="go"> (IntegerLiteral 0x7ff3a302a9d8 <col:11> 'int' 0))))))</span>
+<span class="go">1 error generated.</span>
+<span class="go">Error while processing snippet.cc.</span>
+</pre></div>
+</div>
+<p>The ‘–’ at the end is important as it prevents <strong class="program">clang-check</strong> from
+searching for a compilation database. For more information on how to setup and
+use <strong class="program">clang-check</strong> in a project, see <a class="reference internal" href="HowToSetupToolingForLLVM.html"><em>How To Setup Clang Tooling For LLVM</em></a>.</p>
+</div>
+
+
+ </div>
+ <div class="bottomnav">
+
+ <p>
+ « <a href="ClangTools.html">Overview</a>
+ ::
+ <a class="uplink" href="index.html">Contents</a>
+ ::
+ <a href="ClangFormat.html">ClangFormat</a> »
+ </p>
+
+ </div>
+
+ <div class="footer">
+ © Copyright 2007-2018, The Clang Team.
+ Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/6.0.1/tools/clang/docs/ClangCommandLineReference.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/6.0.1/tools/clang/docs/ClangCommandLineReference.html?rev=336152&view=auto
==============================================================================
--- www-releases/trunk/6.0.1/tools/clang/docs/ClangCommandLineReference.html (added)
+++ www-releases/trunk/6.0.1/tools/clang/docs/ClangCommandLineReference.html Mon Jul 2 16:21:43 2018
@@ -0,0 +1,5128 @@
+
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+ <title>Clang command line argument reference — Clang 6 documentation</title>
+
+ <link rel="stylesheet" href="_static/haiku.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+ <link rel="stylesheet" href="_static/print.css" type="text/css" />
+
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: '',
+ VERSION: '6',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true
+ };
+ </script>
+ <script type="text/javascript" src="_static/jquery.js"></script>
+ <script type="text/javascript" src="_static/underscore.js"></script>
+ <script type="text/javascript" src="_static/doctools.js"></script>
+ <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+ <script type="text/javascript" src="_static/theme_extras.js"></script>
+ <link rel="top" title="Clang 6 documentation" href="index.html" />
+ <link rel="next" title="Attributes in Clang" href="AttributeReference.html" />
+ <link rel="prev" title="Objective-C Automatic Reference Counting (ARC)" href="AutomaticReferenceCounting.html" />
+ </head>
+ <body>
+ <div class="header"><h1 class="heading"><a href="index.html">
+ <span>Clang 6 documentation</span></a></h1>
+ <h2 class="heading"><span>Clang command line argument reference</span></h2>
+ </div>
+ <div class="topnav">
+
+ <p>
+ « <a href="AutomaticReferenceCounting.html">Objective-C Automatic Reference Counting (ARC)</a>
+ ::
+ <a class="uplink" href="index.html">Contents</a>
+ ::
+ <a href="AttributeReference.html">Attributes in Clang</a> »
+ </p>
+
+ </div>
+ <div class="content">
+
+
+ <div class="section" id="clang-command-line-argument-reference">
+<h1>Clang command line argument reference<a class="headerlink" href="#clang-command-line-argument-reference" title="Permalink to this headline">¶</a></h1>
+<div class="contents local topic" id="contents">
+<ul class="simple">
+<li><a class="reference internal" href="#introduction" id="id2">Introduction</a></li>
+<li><a class="reference internal" href="#actions" id="id3">Actions</a></li>
+<li><a class="reference internal" href="#compilation-flags" id="id4">Compilation flags</a><ul>
+<li><a class="reference internal" href="#preprocessor-flags" id="id5">Preprocessor flags</a><ul>
+<li><a class="reference internal" href="#include-path-management" id="id6">Include path management</a></li>
+<li><a class="reference internal" href="#dependency-file-generation" id="id7">Dependency file generation</a></li>
+<li><a class="reference internal" href="#dumping-preprocessor-state" id="id8">Dumping preprocessor state</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#diagnostic-flags" id="id9">Diagnostic flags</a></li>
+<li><a class="reference internal" href="#target-independent-compilation-options" id="id10">Target-independent compilation options</a><ul>
+<li><a class="reference internal" href="#opencl-flags" id="id11">OpenCL flags</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#target-dependent-compilation-options" id="id12">Target-dependent compilation options</a><ul>
+<li><a class="reference internal" href="#aarch64" id="id13">AARCH64</a></li>
+<li><a class="reference internal" href="#amdgpu" id="id14">AMDGPU</a></li>
+<li><a class="reference internal" href="#arm" id="id15">ARM</a></li>
+<li><a class="reference internal" href="#hexagon" id="id16">Hexagon</a></li>
+<li><a class="reference internal" href="#id1" id="id17">Hexagon</a></li>
+<li><a class="reference internal" href="#powerpc" id="id18">PowerPC</a></li>
+<li><a class="reference internal" href="#webassembly" id="id19">WebAssembly</a></li>
+<li><a class="reference internal" href="#x86" id="id20">X86</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#optimization-level" id="id21">Optimization level</a></li>
+<li><a class="reference internal" href="#debug-information-generation" id="id22">Debug information generation</a><ul>
+<li><a class="reference internal" href="#kind-and-level-of-debug-information" id="id23">Kind and level of debug information</a><ul>
+<li><a class="reference internal" href="#debug-level" id="id24">Debug level</a></li>
+<li><a class="reference internal" href="#debugger-to-tune-debug-information-for" id="id25">Debugger to tune debug information for</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#debug-information-flags" id="id26">Debug information flags</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#static-analyzer-flags" id="id27">Static analyzer flags</a></li>
+<li><a class="reference internal" href="#fortran-compilation-flags" id="id28">Fortran compilation flags</a></li>
+<li><a class="reference internal" href="#linker-flags" id="id29">Linker flags</a></li>
+</ul>
+</div>
+<div class="section" id="introduction">
+<h2><a class="toc-backref" href="#id2">Introduction</a><a class="headerlink" href="#introduction" title="Permalink to this headline">¶</a></h2>
+<p>This page lists the command line arguments currently supported by the
+GCC-compatible <tt class="docutils literal"><span class="pre">clang</span></tt> and <tt class="docutils literal"><span class="pre">clang++</span></tt> drivers.</p>
+<dl class="option">
+<dt id="cmdoption-clang-B">
+<tt class="descname">-B</tt><tt class="descclassname"><dir></tt><tt class="descclassname">, </tt><tt class="descname">--prefix</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--prefix</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-B" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Add <dir> to search path for binaries and object files used implicitly</p>
+<dl class="option">
+<dt id="cmdoption-clang-F">
+<tt class="descname">-F</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-F" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Add directory to framework include search path</p>
+<dl class="option">
+<dt id="cmdoption-clang-ObjC">
+<tt class="descname">-ObjC</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ObjC" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Treat source input files as Objective-C inputs</p>
+<dl class="option">
+<dt id="cmdoption-clang1-ObjC">
+<tt class="descname">-ObjC</tt><tt class="descclassname">++</tt><a class="headerlink" href="#cmdoption-clang1-ObjC" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Treat source input files as Objective-C++ inputs</p>
+<dl class="option">
+<dt id="cmdoption-clang-Qunused-arguments">
+<tt class="descname">-Qunused-arguments</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-Qunused-arguments" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Don’t emit warning for unused driver arguments</p>
+<dl class="option">
+<dt id="cmdoption-clang-Wa">
+<tt class="descname">-Wa</tt><tt class="descclassname">,<arg>,<arg2>...</tt><a class="headerlink" href="#cmdoption-clang-Wa" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Pass the comma separated arguments in <arg> to the assembler</p>
+<dl class="option">
+<dt id="cmdoption-clang-Wlarge-by-value-copy">
+<tt class="descname">-Wlarge-by-value-copy</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-Wlarge-by-value-copy" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-Xarch_">
+<tt class="descname">-Xarch_</tt><tt class="descclassname"><arg1> <arg2></tt><a class="headerlink" href="#cmdoption-clang-Xarch_" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-Xcuda-fatbinary">
+<tt class="descname">-Xcuda-fatbinary</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-Xcuda-fatbinary" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Pass <arg> to fatbinary invocation</p>
+<dl class="option">
+<dt id="cmdoption-clang-Xcuda-ptxas">
+<tt class="descname">-Xcuda-ptxas</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-Xcuda-ptxas" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Pass <arg> to the ptxas assembler</p>
+<dl class="option">
+<dt id="cmdoption-clang-Xopenmp-target">
+<tt class="descname">-Xopenmp-target</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-Xopenmp-target" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Pass <arg> to the target offloading toolchain.</p>
+<dl class="option">
+<dt id="cmdoption-clang1-Xopenmp-target">
+<tt class="descname">-Xopenmp-target</tt><tt class="descclassname">=<arg> <arg2></tt><a class="headerlink" href="#cmdoption-clang1-Xopenmp-target" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Pass <arg> to the specified target offloading toolchain. The triple that identifies the toolchain must be provided after the equals sign.</p>
+<dl class="option">
+<dt id="cmdoption-clang-Z">
+<tt class="descname">-Z</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-Z" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-a">
+<tt class="descname">-a</tt><tt class="descclassname"><arg></tt><tt class="descclassname">, </tt><tt class="descname">--profile-blocks</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-a" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-all_load">
+<tt class="descname">-all_load</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-all_load" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-allowable_client">
+<tt class="descname">-allowable_client</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-allowable_client" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang--analyze">
+<tt class="descname">--analyze</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--analyze" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Run the static analyzer</p>
+<dl class="option">
+<dt id="cmdoption-clang--analyze-auto">
+<tt class="descname">--analyze-auto</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--analyze-auto" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang--analyzer-no-default-checks">
+<tt class="descname">--analyzer-no-default-checks</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--analyzer-no-default-checks" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang--analyzer-output">
+<tt class="descname">--analyzer-output</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang--analyzer-output" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Static analyzer report output format (html|plist|plist-multi-file|plist-html|text).</p>
+<dl class="option">
+<dt id="cmdoption-clang-ansi">
+<tt class="descname">-ansi</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--ansi</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ansi" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-arch">
+<tt class="descname">-arch</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-arch" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-arch_errors_fatal">
+<tt class="descname">-arch_errors_fatal</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang1-arch_errors_fatal" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang2-arch_only">
+<tt class="descname">-arch_only</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang2-arch_only" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-arcmt-migrate-emit-errors">
+<tt class="descname">-arcmt-migrate-emit-errors</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-arcmt-migrate-emit-errors" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Emit ARC errors even if the migrator can fix them</p>
+<dl class="option">
+<dt id="cmdoption-clang-arcmt-migrate-report-output">
+<tt class="descname">-arcmt-migrate-report-output</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-arcmt-migrate-report-output" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Output path for the plist report</p>
+<dl class="option">
+<dt id="cmdoption-clang--autocomplete">
+<tt class="descname">--autocomplete</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang--autocomplete" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-bind_at_load">
+<tt class="descname">-bind_at_load</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-bind_at_load" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-bundle">
+<tt class="descname">-bundle</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-bundle" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-bundle_loader">
+<tt class="descname">-bundle_loader</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang1-bundle_loader" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-client_name">
+<tt class="descname">-client_name</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-client_name" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-compatibility_version">
+<tt class="descname">-compatibility_version</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-compatibility_version" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang--config">
+<tt class="descname">--config</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang--config" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Specifies configuration file</p>
+<dl class="option">
+<dt id="cmdoption-clang--constant-cfstrings">
+<tt class="descname">--constant-cfstrings</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--constant-cfstrings" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-coverage">
+<tt class="descname">-coverage</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--coverage</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-coverage" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang--cuda-compile-host-device">
+<tt class="descname">--cuda-compile-host-device</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--cuda-compile-host-device" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Compile CUDA code for both host and device (default). Has no effect on non-CUDA compilations.</p>
+<dl class="option">
+<dt id="cmdoption-clang--cuda-device-only">
+<tt class="descname">--cuda-device-only</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--cuda-device-only" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Compile CUDA code for device only</p>
+<dl class="option">
+<dt id="cmdoption-clang--cuda-gpu-arch">
+<tt class="descname">--cuda-gpu-arch</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--no-cuda-gpu-arch</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang--cuda-gpu-arch" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>CUDA GPU architecture (e.g. sm_35). May be specified more than once.</p>
+<dl class="option">
+<dt id="cmdoption-clang--cuda-host-only">
+<tt class="descname">--cuda-host-only</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--cuda-host-only" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Compile CUDA code for host only. Has no effect on non-CUDA compilations.</p>
+<dl class="option">
+<dt id="cmdoption-clang--cuda-noopt-device-debug">
+<tt class="descname">--cuda-noopt-device-debug</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--no-cuda-noopt-device-debug</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--cuda-noopt-device-debug" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable device-side debug info generation. Disables ptxas optimizations.</p>
+<dl class="option">
+<dt id="cmdoption-clang-current_version">
+<tt class="descname">-current_version</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-current_version" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-dead_strip">
+<tt class="descname">-dead_strip</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-dead_strip" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-dependency-dot">
+<tt class="descname">-dependency-dot</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-dependency-dot" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Filename to write DOT-formatted header dependencies to</p>
+<dl class="option">
+<dt id="cmdoption-clang-dependency-file">
+<tt class="descname">-dependency-file</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-dependency-file" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Filename (or -) to write dependency output to</p>
+<dl class="option">
+<dt id="cmdoption-clang-dumpmachine">
+<tt class="descname">-dumpmachine</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-dumpmachine" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-dumpversion">
+<tt class="descname">-dumpversion</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-dumpversion" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang--dyld-prefix">
+<tt class="descname">--dyld-prefix</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--dyld-prefix</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang--dyld-prefix" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-dylib_file">
+<tt class="descname">-dylib_file</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-dylib_file" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-dylinker">
+<tt class="descname">-dylinker</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-dylinker" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-dylinker_install_name">
+<tt class="descname">-dylinker_install_name</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang1-dylinker_install_name" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-dynamic">
+<tt class="descname">-dynamic</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-dynamic" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-dynamiclib">
+<tt class="descname">-dynamiclib</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-dynamiclib" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-emit-ast">
+<tt class="descname">-emit-ast</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-emit-ast" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Emit Clang AST files for source inputs</p>
+<dl class="option">
+<dt id="cmdoption-clang-exported_symbols_list">
+<tt class="descname">-exported_symbols_list</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-exported_symbols_list" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-faligned-new">
+<tt class="descname">-faligned-new</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-faligned-new" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fcuda-approx-transcendentals">
+<tt class="descname">-fcuda-approx-transcendentals</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-cuda-approx-transcendentals</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fcuda-approx-transcendentals" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use approximate transcendental functions</p>
+<dl class="option">
+<dt id="cmdoption-clang-fcuda-flush-denormals-to-zero">
+<tt class="descname">-fcuda-flush-denormals-to-zero</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-cuda-flush-denormals-to-zero</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fcuda-flush-denormals-to-zero" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Flush denormal floating point values to zero in CUDA device mode.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fheinous-gnu-extensions">
+<tt class="descname">-fheinous-gnu-extensions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fheinous-gnu-extensions" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-flat_namespace">
+<tt class="descname">-flat_namespace</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-flat_namespace" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fopenmp-targets">
+<tt class="descname">-fopenmp-targets</tt><tt class="descclassname">=<arg1>,<arg2>...</tt><a class="headerlink" href="#cmdoption-clang-fopenmp-targets" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify comma-separated list of triples OpenMP offloading targets to be supported</p>
+<dl class="option">
+<dt id="cmdoption-clang-force_cpusubtype_ALL">
+<tt class="descname">-force_cpusubtype_ALL</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-force_cpusubtype_ALL" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-force_flat_namespace">
+<tt class="descname">-force_flat_namespace</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang1-force_flat_namespace" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang2-force_load">
+<tt class="descname">-force_load</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang2-force_load" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-framework">
+<tt class="descname">-framework</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-framework" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-frtlib-add-rpath">
+<tt class="descname">-frtlib-add-rpath</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-rtlib-add-rpath</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-frtlib-add-rpath" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Add -rpath with architecture-specific resource directory to the linker flags</p>
+<dl class="option">
+<dt id="cmdoption-clang--gcc-toolchain">
+<tt class="descname">--gcc-toolchain</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">-gcc-toolchain</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang--gcc-toolchain" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use the gcc toolchain at the given directory</p>
+<dl class="option">
+<dt id="cmdoption-clang-gcodeview">
+<tt class="descname">-gcodeview</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gcodeview" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate CodeView debug information</p>
+<dl class="option">
+<dt id="cmdoption-clang-headerpad_max_install_names">
+<tt class="descname">-headerpad_max_install_names</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-headerpad_max_install_names" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-help">
+<tt class="descname">-help</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--help</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-help" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Display available options</p>
+<dl class="option">
+<dt id="cmdoption-clang--help-hidden">
+<tt class="descname">--help-hidden</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--help-hidden" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-image_base">
+<tt class="descname">-image_base</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-image_base" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-index-header-map">
+<tt class="descname">-index-header-map</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-index-header-map" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Make the next included directory (-I or -F) an indexer header map</p>
+<dl class="option">
+<dt id="cmdoption-clang-init">
+<tt class="descname">-init</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-init" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-install_name">
+<tt class="descname">-install_name</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-install_name" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-keep_private_externs">
+<tt class="descname">-keep_private_externs</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-keep_private_externs" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-lazy_framework">
+<tt class="descname">-lazy_framework</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-lazy_framework" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-lazy_library">
+<tt class="descname">-lazy_library</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang1-lazy_library" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mbig-endian">
+<tt class="descname">-mbig-endian</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-EB</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mbig-endian" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang--migrate">
+<tt class="descname">--migrate</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--migrate" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Run the migrator</p>
+<dl class="option">
+<dt id="cmdoption-clang-mios-simulator-version-min">
+<tt class="descname">-mios-simulator-version-min</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">-miphonesimulator-version-min</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mios-simulator-version-min" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mlinker-version">
+<tt class="descname">-mlinker-version</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mlinker-version" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mlittle-endian">
+<tt class="descname">-mlittle-endian</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-EL</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mlittle-endian" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mllvm">
+<tt class="descname">-mllvm</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-mllvm" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Additional arguments to forward to LLVM’s option processing</p>
+<dl class="option">
+<dt id="cmdoption-clang-module-dependency-dir">
+<tt class="descname">-module-dependency-dir</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-module-dependency-dir" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Directory to dump module dependencies to</p>
+<dl class="option">
+<dt id="cmdoption-clang-mtvos-simulator-version-min">
+<tt class="descname">-mtvos-simulator-version-min</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">-mappletvsimulator-version-min</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mtvos-simulator-version-min" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-multi_module">
+<tt class="descname">-multi_module</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-multi_module" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-multiply_defined">
+<tt class="descname">-multiply_defined</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-multiply_defined" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-multiply_defined_unused">
+<tt class="descname">-multiply_defined_unused</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang1-multiply_defined_unused" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mwatchos-simulator-version-min">
+<tt class="descname">-mwatchos-simulator-version-min</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">-mwatchsimulator-version-min</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mwatchos-simulator-version-min" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang--no-cuda-version-check">
+<tt class="descname">--no-cuda-version-check</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--no-cuda-version-check" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Don’t error out if the detected version of the CUDA install is too low for the requested CUDA gpu architecture.</p>
+<dl class="option">
+<dt id="cmdoption-clang-no-integrated-cpp">
+<tt class="descname">-no-integrated-cpp</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--no-integrated-cpp</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-no-integrated-cpp" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-no_dead_strip_inits_and_terms">
+<tt class="descname">-no_dead_strip_inits_and_terms</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-no_dead_strip_inits_and_terms" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-nobuiltininc">
+<tt class="descname">-nobuiltininc</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-nobuiltininc" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Disable builtin #include directories</p>
+<dl class="option">
+<dt id="cmdoption-clang-nocudainc">
+<tt class="descname">-nocudainc</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-nocudainc" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-nocudalib">
+<tt class="descname">-nocudalib</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-nocudalib" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-nodefaultlibs">
+<tt class="descname">-nodefaultlibs</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-nodefaultlibs" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-nofixprebinding">
+<tt class="descname">-nofixprebinding</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-nofixprebinding" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-nolibc">
+<tt class="descname">-nolibc</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-nolibc" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-nomultidefs">
+<tt class="descname">-nomultidefs</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-nomultidefs" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-nopie">
+<tt class="descname">-nopie</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-no-pie</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-nopie" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-noprebind">
+<tt class="descname">-noprebind</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-noprebind" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-noseglinkedit">
+<tt class="descname">-noseglinkedit</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-noseglinkedit" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-nostartfiles">
+<tt class="descname">-nostartfiles</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-nostartfiles" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-nostdinc">
+<tt class="descname">-nostdinc</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--no-standard-includes</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-nostdinc" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-nostdinc">
+<tt class="descname">-nostdinc</tt><tt class="descclassname">++</tt><a class="headerlink" href="#cmdoption-clang1-nostdinc" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Disable standard #include directories for the C++ standard library</p>
+<dl class="option">
+<dt id="cmdoption-clang-nostdlib">
+<tt class="descname">-nostdlib</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--no-standard-libraries</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-nostdlib" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-nostdlib">
+<tt class="descname">-nostdlib</tt><tt class="descclassname">++</tt><a class="headerlink" href="#cmdoption-clang1-nostdlib" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-nostdlibinc">
+<tt class="descname">-nostdlibinc</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-nostdlibinc" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-o">
+<tt class="descname">-o</tt><tt class="descclassname"><file></tt><tt class="descclassname">, </tt><tt class="descname">--output</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--output</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-o" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Write output to <file></p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-atomic-property">
+<tt class="descname">-objcmt-atomic-property</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-atomic-property" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Make migration to ‘atomic’ properties</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-migrate-all">
+<tt class="descname">-objcmt-migrate-all</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-migrate-all" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable migration to modern ObjC</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-migrate-annotation">
+<tt class="descname">-objcmt-migrate-annotation</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-migrate-annotation" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable migration to property and method annotations</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-migrate-designated-init">
+<tt class="descname">-objcmt-migrate-designated-init</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-migrate-designated-init" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable migration to infer NS_DESIGNATED_INITIALIZER for initializer methods</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-migrate-instancetype">
+<tt class="descname">-objcmt-migrate-instancetype</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-migrate-instancetype" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable migration to infer instancetype for method result type</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-migrate-literals">
+<tt class="descname">-objcmt-migrate-literals</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-migrate-literals" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable migration to modern ObjC literals</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-migrate-ns-macros">
+<tt class="descname">-objcmt-migrate-ns-macros</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-migrate-ns-macros" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable migration to NS_ENUM/NS_OPTIONS macros</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-migrate-property">
+<tt class="descname">-objcmt-migrate-property</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-migrate-property" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable migration to modern ObjC property</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-migrate-property-dot-syntax">
+<tt class="descname">-objcmt-migrate-property-dot-syntax</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-migrate-property-dot-syntax" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable migration of setter/getter messages to property-dot syntax</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-migrate-protocol-conformance">
+<tt class="descname">-objcmt-migrate-protocol-conformance</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-migrate-protocol-conformance" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable migration to add protocol conformance on classes</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-migrate-readonly-property">
+<tt class="descname">-objcmt-migrate-readonly-property</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-migrate-readonly-property" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable migration to modern ObjC readonly property</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-migrate-readwrite-property">
+<tt class="descname">-objcmt-migrate-readwrite-property</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-migrate-readwrite-property" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable migration to modern ObjC readwrite property</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-migrate-subscripting">
+<tt class="descname">-objcmt-migrate-subscripting</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-migrate-subscripting" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable migration to modern ObjC subscripting</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-ns-nonatomic-iosonly">
+<tt class="descname">-objcmt-ns-nonatomic-iosonly</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-ns-nonatomic-iosonly" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable migration to use NS_NONATOMIC_IOSONLY macro for setting property’s ‘atomic’ attribute</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-returns-innerpointer-property">
+<tt class="descname">-objcmt-returns-innerpointer-property</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-returns-innerpointer-property" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable migration to annotate property with NS_RETURNS_INNER_POINTER</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-whitelist-dir-path">
+<tt class="descname">-objcmt-whitelist-dir-path</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">-objcmt-white-list-dir-path</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-objcmt-whitelist-dir-path" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Only modify files with a filename contained in the provided directory path</p>
+<dl class="option">
+<dt id="cmdoption-clang-object">
+<tt class="descname">-object</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-object" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-p">
+<tt class="descname">-p</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--profile</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-p" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-pagezero_size">
+<tt class="descname">-pagezero_size</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-pagezero_size" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-pg">
+<tt class="descname">-pg</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-pg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable mcount instrumentation</p>
+<dl class="option">
+<dt id="cmdoption-clang-pie">
+<tt class="descname">-pie</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-pie" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-pipe">
+<tt class="descname">-pipe</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--pipe</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-pipe" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use pipes between commands, when possible</p>
+<dl class="option">
+<dt id="cmdoption-clang-prebind">
+<tt class="descname">-prebind</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-prebind" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-prebind_all_twolevel_modules">
+<tt class="descname">-prebind_all_twolevel_modules</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang1-prebind_all_twolevel_modules" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-preload">
+<tt class="descname">-preload</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-preload" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang--print-diagnostic-categories">
+<tt class="descname">--print-diagnostic-categories</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--print-diagnostic-categories" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-print-file-name">
+<tt class="descname">-print-file-name</tt><tt class="descclassname">=<file></tt><tt class="descclassname">, </tt><tt class="descname">--print-file-name</tt><tt class="descclassname">=<file></tt><tt class="descclassname">, </tt><tt class="descname">--print-file-name</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-print-file-name" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Print the full library path of <file></p>
+<dl class="option">
+<dt id="cmdoption-clang-print-ivar-layout">
+<tt class="descname">-print-ivar-layout</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-print-ivar-layout" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable Objective-C Ivar layout bitmap print trace</p>
+<dl class="option">
+<dt id="cmdoption-clang-print-libgcc-file-name">
+<tt class="descname">-print-libgcc-file-name</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--print-libgcc-file-name</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-print-libgcc-file-name" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Print the library path for the currently used compiler runtime library (“libgcc.a” or “libclang_rt.builtins.*.a”)</p>
+<dl class="option">
+<dt id="cmdoption-clang-print-multi-directory">
+<tt class="descname">-print-multi-directory</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--print-multi-directory</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-print-multi-directory" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-print-multi-lib">
+<tt class="descname">-print-multi-lib</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--print-multi-lib</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-print-multi-lib" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-print-prog-name">
+<tt class="descname">-print-prog-name</tt><tt class="descclassname">=<name></tt><tt class="descclassname">, </tt><tt class="descname">--print-prog-name</tt><tt class="descclassname">=<name></tt><tt class="descclassname">, </tt><tt class="descname">--print-prog-name</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-print-prog-name" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Print the full program path of <name></p>
+<dl class="option">
+<dt id="cmdoption-clang-print-resource-dir">
+<tt class="descname">-print-resource-dir</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--print-resource-dir</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-print-resource-dir" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Print the resource directory pathname</p>
+<dl class="option">
+<dt id="cmdoption-clang-print-search-dirs">
+<tt class="descname">-print-search-dirs</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--print-search-dirs</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-print-search-dirs" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Print the paths used for finding libraries and programs</p>
+<dl class="option">
+<dt id="cmdoption-clang-private_bundle">
+<tt class="descname">-private_bundle</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-private_bundle" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-pthread">
+<tt class="descname">-pthread</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-no-pthread</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-pthread" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Support POSIX threads in generated code</p>
+<dl class="option">
+<dt id="cmdoption-clang-pthreads">
+<tt class="descname">-pthreads</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-pthreads" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-rdynamic">
+<tt class="descname">-rdynamic</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-rdynamic" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-read_only_relocs">
+<tt class="descname">-read_only_relocs</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-read_only_relocs" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-relocatable-pch">
+<tt class="descname">-relocatable-pch</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--relocatable-pch</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-relocatable-pch" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Whether to build a relocatable precompiled header</p>
+<dl class="option">
+<dt id="cmdoption-clang-remap">
+<tt class="descname">-remap</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-remap" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-rewrite-legacy-objc">
+<tt class="descname">-rewrite-legacy-objc</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-rewrite-legacy-objc" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Rewrite Legacy Objective-C source to C++</p>
+<dl class="option">
+<dt id="cmdoption-clang-rtlib">
+<tt class="descname">-rtlib</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--rtlib</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--rtlib</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-rtlib" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Compiler runtime library to use</p>
+<dl class="option">
+<dt id="cmdoption-clang-save-stats">
+<tt class="descname">-save-stats</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--save-stats</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">-save-stats</tt><tt class="descclassname"> (equivalent to -save-stats=cwd)</tt><tt class="descclassname">, </tt><tt class="descname">--save-stats</tt><tt class="descclassname"> (equivalent to -save-stats=cwd)</tt><a class="headerlink" href="#cmdoption-clang-save-stats" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Save llvm statistics.</p>
+<dl class="option">
+<dt id="cmdoption-clang-save-temps">
+<tt class="descname">-save-temps</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--save-temps</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">-save-temps</tt><tt class="descclassname"> (equivalent to -save-temps=cwd)</tt><tt class="descclassname">, </tt><tt class="descname">--save-temps</tt><tt class="descclassname"> (equivalent to -save-temps=cwd)</tt><a class="headerlink" href="#cmdoption-clang-save-temps" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Save intermediate compilation results.</p>
+<dl class="option">
+<dt id="cmdoption-clang-sectalign">
+<tt class="descname">-sectalign</tt><tt class="descclassname"> <arg1> <arg2> <arg3></tt><a class="headerlink" href="#cmdoption-clang-sectalign" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-sectcreate">
+<tt class="descname">-sectcreate</tt><tt class="descclassname"> <arg1> <arg2> <arg3></tt><a class="headerlink" href="#cmdoption-clang-sectcreate" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-sectobjectsymbols">
+<tt class="descname">-sectobjectsymbols</tt><tt class="descclassname"> <arg1> <arg2></tt><a class="headerlink" href="#cmdoption-clang-sectobjectsymbols" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-sectorder">
+<tt class="descname">-sectorder</tt><tt class="descclassname"> <arg1> <arg2> <arg3></tt><a class="headerlink" href="#cmdoption-clang-sectorder" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-seg1addr">
+<tt class="descname">-seg1addr</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-seg1addr" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-seg_addr_table">
+<tt class="descname">-seg_addr_table</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-seg_addr_table" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-seg_addr_table_filename">
+<tt class="descname">-seg_addr_table_filename</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang1-seg_addr_table_filename" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-segaddr">
+<tt class="descname">-segaddr</tt><tt class="descclassname"> <arg1> <arg2></tt><a class="headerlink" href="#cmdoption-clang-segaddr" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-segcreate">
+<tt class="descname">-segcreate</tt><tt class="descclassname"> <arg1> <arg2> <arg3></tt><a class="headerlink" href="#cmdoption-clang-segcreate" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-seglinkedit">
+<tt class="descname">-seglinkedit</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-seglinkedit" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-segprot">
+<tt class="descname">-segprot</tt><tt class="descclassname"> <arg1> <arg2> <arg3></tt><a class="headerlink" href="#cmdoption-clang-segprot" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-segs_read_">
+<tt class="descname">-segs_read_</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-segs_read_" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-segs_read_only_addr">
+<tt class="descname">-segs_read_only_addr</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang1-segs_read_only_addr" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang2-segs_read_write_addr">
+<tt class="descname">-segs_read_write_addr</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang2-segs_read_write_addr" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-serialize-diagnostics">
+<tt class="descname">-serialize-diagnostics</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--serialize-diagnostics</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-serialize-diagnostics" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Serialize compiler diagnostics to a file</p>
+<dl class="option">
+<dt id="cmdoption-clang-shared">
+<tt class="descname">-shared</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--shared</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-shared" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-shared-libgcc">
+<tt class="descname">-shared-libgcc</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-shared-libgcc" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-shared-libsan">
+<tt class="descname">-shared-libsan</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-shared-libasan</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-shared-libsan" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-single_module">
+<tt class="descname">-single_module</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-single_module" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-specs">
+<tt class="descname">-specs</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--specs</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-specs" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-static">
+<tt class="descname">-static</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--static</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-static" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-static-libgcc">
+<tt class="descname">-static-libgcc</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-static-libgcc" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-static-libsan">
+<tt class="descname">-static-libsan</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-static-libsan" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-static-libstdc">
+<tt class="descname">-static-libstdc</tt><tt class="descclassname">++</tt><a class="headerlink" href="#cmdoption-clang-static-libstdc" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-std-default">
+<tt class="descname">-std-default</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-std-default" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-stdlib">
+<tt class="descname">-stdlib</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--stdlib</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--stdlib</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-stdlib" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>C++ standard library to use</p>
+<dl class="option">
+<dt id="cmdoption-clang-sub_library">
+<tt class="descname">-sub_library</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-sub_library" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-sub_umbrella">
+<tt class="descname">-sub_umbrella</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang1-sub_umbrella" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang--sysroot">
+<tt class="descname">--sysroot</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--sysroot</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang--sysroot" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang--target-help">
+<tt class="descname">--target-help</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--target-help" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang--target">
+<tt class="descname">--target</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">-target</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang--target" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate code for the given target</p>
+<dl class="option">
+<dt id="cmdoption-clang-time">
+<tt class="descname">-time</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-time" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Time individual commands</p>
+<dl class="option">
+<dt id="cmdoption-clang-traditional">
+<tt class="descname">-traditional</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--traditional</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-traditional" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-traditional-cpp">
+<tt class="descname">-traditional-cpp</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--traditional-cpp</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-traditional-cpp" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable some traditional CPP emulation</p>
+<dl class="option">
+<dt id="cmdoption-clang-twolevel_namespace">
+<tt class="descname">-twolevel_namespace</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-twolevel_namespace" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-twolevel_namespace_hints">
+<tt class="descname">-twolevel_namespace_hints</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang1-twolevel_namespace_hints" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-umbrella">
+<tt class="descname">-umbrella</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-umbrella" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-unexported_symbols_list">
+<tt class="descname">-unexported_symbols_list</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-unexported_symbols_list" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-v">
+<tt class="descname">-v</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--verbose</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-v" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Show commands to run and use verbose output</p>
+<dl class="option">
+<dt id="cmdoption-clang--verify-debug-info">
+<tt class="descname">--verify-debug-info</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--verify-debug-info" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Verify the binary representation of debug output</p>
+<dl class="option">
+<dt id="cmdoption-clang--version">
+<tt class="descname">--version</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--version" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Print version information</p>
+<dl class="option">
+<dt id="cmdoption-clang-w">
+<tt class="descname">-w</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--no-warnings</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-w" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Suppress all warnings</p>
+<dl class="option">
+<dt id="cmdoption-clang-weak-l">
+<tt class="descname">-weak-l</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-weak-l" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-weak_framework">
+<tt class="descname">-weak_framework</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-weak_framework" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-weak_library">
+<tt class="descname">-weak_library</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang1-weak_library" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang2-weak_reference_mismatches">
+<tt class="descname">-weak_reference_mismatches</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang2-weak_reference_mismatches" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-whatsloaded">
+<tt class="descname">-whatsloaded</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-whatsloaded" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-whyload">
+<tt class="descname">-whyload</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-whyload" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-working-directory">
+<tt class="descname">-working-directory</tt><tt class="descclassname"><arg></tt><tt class="descclassname">, </tt><tt class="descname">-working-directory</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-working-directory" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Resolve file paths relative to the specified directory</p>
+<dl class="option">
+<dt id="cmdoption-clang-x">
+<tt class="descname">-x</tt><tt class="descclassname"><language></tt><tt class="descclassname">, </tt><tt class="descname">--language</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--language</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-x" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Treat subsequent input files as having type <language></p>
+<dl class="option">
+<dt id="cmdoption-clang-y">
+<tt class="descname">-y</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-y" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+</div>
+<div class="section" id="actions">
+<h2><a class="toc-backref" href="#id3">Actions</a><a class="headerlink" href="#actions" title="Permalink to this headline">¶</a></h2>
+<p>The action to perform on the input.</p>
+<dl class="option">
+<dt id="cmdoption-clang-E">
+<tt class="descname">-E</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--preprocess</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-E" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Only run the preprocessor</p>
+<dl class="option">
+<dt id="cmdoption-clang-S">
+<tt class="descname">-S</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--assemble</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-S" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Only run preprocess and compilation steps</p>
+<dl class="option">
+<dt id="cmdoption-clang-c">
+<tt class="descname">-c</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--compile</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-c" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Only run preprocess, compile, and assemble steps</p>
+<dl class="option">
+<dt id="cmdoption-clang-emit-llvm">
+<tt class="descname">-emit-llvm</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-emit-llvm" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use the LLVM representation for assembler and object files</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsyntax-only">
+<tt class="descname">-fsyntax-only</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsyntax-only" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-module-file-info">
+<tt class="descname">-module-file-info</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-module-file-info" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Provide information about a particular module file</p>
+<dl class="option">
+<dt id="cmdoption-clang--precompile">
+<tt class="descname">--precompile</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--precompile" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Only precompile the input</p>
+<dl class="option">
+<dt id="cmdoption-clang-rewrite-objc">
+<tt class="descname">-rewrite-objc</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-rewrite-objc" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Rewrite Objective-C source to C++</p>
+<dl class="option">
+<dt id="cmdoption-clang-verify-pch">
+<tt class="descname">-verify-pch</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-verify-pch" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Load and verify that a pre-compiled header file is not stale</p>
+</div>
+<div class="section" id="compilation-flags">
+<h2><a class="toc-backref" href="#id4">Compilation flags</a><a class="headerlink" href="#compilation-flags" title="Permalink to this headline">¶</a></h2>
+<p>Flags controlling the behavior of Clang during compilation. These flags have
+no effect during actions that do not perform compilation.</p>
+<dl class="option">
+<dt id="cmdoption-clang-Xassembler">
+<tt class="descname">-Xassembler</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-Xassembler" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Pass <arg> to the assembler</p>
+<dl class="option">
+<dt id="cmdoption-clang-Xclang">
+<tt class="descname">-Xclang</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-Xclang" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Pass <arg> to the clang compiler</p>
+<dl class="option">
+<dt id="cmdoption-clang-fclang-abi-compat">
+<tt class="descname">-fclang-abi-compat</tt><tt class="descclassname">=<version></tt><a class="headerlink" href="#cmdoption-clang-fclang-abi-compat" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Attempt to match the ABI of Clang <version></p>
+<dl class="option">
+<dt id="cmdoption-clang-fcomment-block-commands">
+<tt class="descname">-fcomment-block-commands</tt><tt class="descclassname">=<arg>,<arg2>...</tt><a class="headerlink" href="#cmdoption-clang-fcomment-block-commands" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Treat each comma separated argument in <arg> as a documentation comment block command</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdeclspec">
+<tt class="descname">-fdeclspec</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-declspec</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdeclspec" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Allow __declspec as a keyword</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdepfile-entry">
+<tt class="descname">-fdepfile-entry</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fdepfile-entry" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdiagnostics-fixit-info">
+<tt class="descname">-fdiagnostics-fixit-info</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-diagnostics-fixit-info</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdiagnostics-fixit-info" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdiagnostics-format">
+<tt class="descname">-fdiagnostics-format</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fdiagnostics-format" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdiagnostics-parseable-fixits">
+<tt class="descname">-fdiagnostics-parseable-fixits</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdiagnostics-parseable-fixits" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Print fix-its in machine parseable form</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdiagnostics-print-source-range-info">
+<tt class="descname">-fdiagnostics-print-source-range-info</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdiagnostics-print-source-range-info" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Print source range spans in numeric form</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdiagnostics-show-category">
+<tt class="descname">-fdiagnostics-show-category</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fdiagnostics-show-category" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fexperimental-isel">
+<tt class="descname">-fexperimental-isel</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-experimental-isel</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fexperimental-isel" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enables the experimental global instruction selector</p>
+<dl class="option">
+<dt id="cmdoption-clang-fexperimental-new-pass-manager">
+<tt class="descname">-fexperimental-new-pass-manager</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-experimental-new-pass-manager</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fexperimental-new-pass-manager" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enables an experimental new pass manager in LLVM.</p>
+<dl class="option">
+<dt id="cmdoption-clang-ffine-grained-bitfield-accesses">
+<tt class="descname">-ffine-grained-bitfield-accesses</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-fine-grained-bitfield-accesses</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ffine-grained-bitfield-accesses" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use separate accesses for bitfields with legal widths and alignments.</p>
+<dl class="option">
+<dt id="cmdoption-clang-finline-functions">
+<tt class="descname">-finline-functions</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-inline-functions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-finline-functions" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Inline suitable functions</p>
+<dl class="option">
+<dt id="cmdoption-clang-finline-hint-functions">
+<tt class="descname">-finline-hint-functions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-finline-hint-functions" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Inline functions which are (explicitly or implicitly) marked inline</p>
+<dl class="option">
+<dt id="cmdoption-clang-fno-crash-diagnostics">
+<tt class="descname">-fno-crash-diagnostics</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fno-crash-diagnostics" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Disable auto-generation of preprocessed source files and a script for reproduction during a clang crash</p>
+<dl class="option">
+<dt id="cmdoption-clang-fno-sanitize-blacklist">
+<tt class="descname">-fno-sanitize-blacklist</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fno-sanitize-blacklist" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Don’t use blacklist file for sanitizers</p>
+<dl class="option">
+<dt id="cmdoption-clang-fparse-all-comments">
+<tt class="descname">-fparse-all-comments</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fparse-all-comments" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-address-field-padding">
+<tt class="descname">-fsanitize-address-field-padding</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-address-field-padding" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Level of field padding for AddressSanitizer</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-address-globals-dead-stripping">
+<tt class="descname">-fsanitize-address-globals-dead-stripping</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-address-globals-dead-stripping" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable linker dead stripping of globals in AddressSanitizer</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-address-use-after-scope">
+<tt class="descname">-fsanitize-address-use-after-scope</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-sanitize-address-use-after-scope</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-address-use-after-scope" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable use-after-scope detection in AddressSanitizer</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-blacklist">
+<tt class="descname">-fsanitize-blacklist</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-blacklist" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Path to blacklist file for sanitizers</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-cfi-cross-dso">
+<tt class="descname">-fsanitize-cfi-cross-dso</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-sanitize-cfi-cross-dso</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-cfi-cross-dso" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable control flow integrity (CFI) checks for cross-DSO calls.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-cfi-icall-generalize-pointers">
+<tt class="descname">-fsanitize-cfi-icall-generalize-pointers</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-cfi-icall-generalize-pointers" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Generalize pointers in CFI indirect call type signature checks</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-coverage">
+<tt class="descname">-fsanitize-coverage</tt><tt class="descclassname">=<arg1>,<arg2>...</tt><tt class="descclassname">, </tt><tt class="descname">-fno-sanitize-coverage</tt><tt class="descclassname">=<arg1>,<arg2>...</tt><a class="headerlink" href="#cmdoption-clang-fsanitize-coverage" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify the type of coverage instrumentation for Sanitizers</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-link-c">
+<tt class="descname">-fsanitize-link-c</tt><tt class="descclassname">++-runtime</tt><a class="headerlink" href="#cmdoption-clang-fsanitize-link-c" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-memory-track-origins">
+<tt class="descname">-fsanitize-memory-track-origins</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-sanitize-memory-track-origins</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-memory-track-origins" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable origins tracking in MemorySanitizer</p>
+<dl class="option">
+<dt id="cmdoption-clang1-fsanitize-memory-track-origins">
+<tt class="descname">-fsanitize-memory-track-origins</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang1-fsanitize-memory-track-origins" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable origins tracking in MemorySanitizer</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-memory-use-after-dtor">
+<tt class="descname">-fsanitize-memory-use-after-dtor</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-sanitize-memory-use-after-dtor</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-memory-use-after-dtor" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable use-after-destroy detection in MemorySanitizer</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-minimal-runtime">
+<tt class="descname">-fsanitize-minimal-runtime</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-sanitize-minimal-runtime</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-minimal-runtime" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-recover">
+<tt class="descname">-fsanitize-recover</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-sanitize-recover</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-recover" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-fsanitize-recover">
+<tt class="descname">-fsanitize-recover</tt><tt class="descclassname">=<arg1>,<arg2>...</tt><tt class="descclassname">, </tt><tt class="descname">-fno-sanitize-recover</tt><tt class="descclassname">=<arg1>,<arg2>...</tt><a class="headerlink" href="#cmdoption-clang1-fsanitize-recover" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable recovery for specified sanitizers</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-stats">
+<tt class="descname">-fsanitize-stats</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-sanitize-stats</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-stats" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable sanitizer statistics gathering.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-thread-atomics">
+<tt class="descname">-fsanitize-thread-atomics</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-sanitize-thread-atomics</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-thread-atomics" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable atomic operations instrumentation in ThreadSanitizer (default)</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-thread-func-entry-exit">
+<tt class="descname">-fsanitize-thread-func-entry-exit</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-sanitize-thread-func-entry-exit</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-thread-func-entry-exit" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable function entry/exit instrumentation in ThreadSanitizer (default)</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-thread-memory-access">
+<tt class="descname">-fsanitize-thread-memory-access</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-sanitize-thread-memory-access</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-thread-memory-access" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable memory access instrumentation in ThreadSanitizer (default)</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-trap">
+<tt class="descname">-fsanitize-trap</tt><tt class="descclassname">=<arg1>,<arg2>...</tt><tt class="descclassname">, </tt><tt class="descname">-fno-sanitize-trap</tt><tt class="descclassname">=<arg1>,<arg2>...</tt><a class="headerlink" href="#cmdoption-clang-fsanitize-trap" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable trapping for specified sanitizers</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-undefined-strip-path-components">
+<tt class="descname">-fsanitize-undefined-strip-path-components</tt><tt class="descclassname">=<number></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-undefined-strip-path-components" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Strip (or keep only, if negative) a given number of path components when emitting check metadata.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-undefined-trap-on-error">
+<tt class="descname">-fsanitize-undefined-trap-on-error</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-sanitize-undefined-trap-on-error</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-undefined-trap-on-error" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize">
+<tt class="descname">-fsanitize</tt><tt class="descclassname">=<check>,<arg2>...</tt><tt class="descclassname">, </tt><tt class="descname">-fno-sanitize</tt><tt class="descclassname">=<arg1>,<arg2>...</tt><a class="headerlink" href="#cmdoption-clang-fsanitize" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Turn on runtime checks for various forms of undefined or suspicious behavior. See user manual for available checks</p>
+<dl class="option">
+<dt id="cmdoption-clang--param">
+<tt class="descname">--param</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--param</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang--param" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-std">
+<tt class="descname">-std</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--std</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--std</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-std" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Language standard to compile for</p>
+<div class="section" id="preprocessor-flags">
+<h3><a class="toc-backref" href="#id5">Preprocessor flags</a><a class="headerlink" href="#preprocessor-flags" title="Permalink to this headline">¶</a></h3>
+<p>Flags controlling the behavior of the Clang preprocessor.</p>
+<dl class="option">
+<dt id="cmdoption-clang-C">
+<tt class="descname">-C</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--comments</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-C" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Include comments in preprocessed output</p>
+<dl class="option">
+<dt id="cmdoption-clang-CC">
+<tt class="descname">-CC</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--comments-in-macros</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-CC" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Include comments from within macros in preprocessed output</p>
+<dl class="option">
+<dt id="cmdoption-clang-D">
+<tt class="descname">-D</tt><tt class="descclassname"><macro>=<value></tt><tt class="descclassname">, </tt><tt class="descname">--define-macro</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--define-macro</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-D" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Define <macro> to <value> (or 1 if <value> omitted)</p>
+<dl class="option">
+<dt id="cmdoption-clang-H">
+<tt class="descname">-H</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--trace-includes</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-H" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Show header includes and nesting depth</p>
+<dl class="option">
+<dt id="cmdoption-clang-P">
+<tt class="descname">-P</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--no-line-commands</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-P" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Disable linemarker output in -E mode</p>
+<dl class="option">
+<dt id="cmdoption-clang-U">
+<tt class="descname">-U</tt><tt class="descclassname"><macro></tt><tt class="descclassname">, </tt><tt class="descname">--undefine-macro</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--undefine-macro</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-U" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Undefine macro <macro></p>
+<dl class="option">
+<dt id="cmdoption-clang-Wp">
+<tt class="descname">-Wp</tt><tt class="descclassname">,<arg>,<arg2>...</tt><a class="headerlink" href="#cmdoption-clang-Wp" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Pass the comma separated arguments in <arg> to the preprocessor</p>
+<dl class="option">
+<dt id="cmdoption-clang-Xpreprocessor">
+<tt class="descname">-Xpreprocessor</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-Xpreprocessor" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Pass <arg> to the preprocessor</p>
+<div class="section" id="include-path-management">
+<h4><a class="toc-backref" href="#id6">Include path management</a><a class="headerlink" href="#include-path-management" title="Permalink to this headline">¶</a></h4>
+<p>Flags controlling how <tt class="docutils literal"><span class="pre">#include</span></tt>s are resolved to files.</p>
+<dl class="option">
+<dt id="cmdoption-clang-I">
+<tt class="descname">-I</tt><tt class="descclassname"><dir></tt><tt class="descclassname">, </tt><tt class="descname">--include-directory</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--include-directory</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-I" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Add directory to include search path</p>
+<dl class="option">
+<dt id="cmdoption-clang-I-">
+<tt class="descname">-I-</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--include-barrier</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-I-" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Restrict all prior -I flags to double-quoted inclusion and remove current directory from include path</p>
+<dl class="option">
+<dt id="cmdoption-clang--cuda-path">
+<tt class="descname">--cuda-path</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang--cuda-path" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>CUDA installation path</p>
+<dl class="option">
+<dt id="cmdoption-clang-cxx-isystem">
+<tt class="descname">-cxx-isystem</tt><tt class="descclassname"><directory></tt><a class="headerlink" href="#cmdoption-clang-cxx-isystem" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Add directory to the C++ SYSTEM include search path</p>
+<dl class="option">
+<dt id="cmdoption-clang-fbuild-session-file">
+<tt class="descname">-fbuild-session-file</tt><tt class="descclassname">=<file></tt><a class="headerlink" href="#cmdoption-clang-fbuild-session-file" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use the last modification time of <file> as the build session timestamp</p>
+<dl class="option">
+<dt id="cmdoption-clang-fbuild-session-timestamp">
+<tt class="descname">-fbuild-session-timestamp</tt><tt class="descclassname">=<time since Epoch in seconds></tt><a class="headerlink" href="#cmdoption-clang-fbuild-session-timestamp" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Time when the current build session started</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodule-file">
+<tt class="descname">-fmodule-file</tt><tt class="descclassname">=[<name>=]<file></tt><a class="headerlink" href="#cmdoption-clang-fmodule-file" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify the mapping of module name to precompiled module file, or load a module file if name is omitted.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodules-cache-path">
+<tt class="descname">-fmodules-cache-path</tt><tt class="descclassname">=<directory></tt><a class="headerlink" href="#cmdoption-clang-fmodules-cache-path" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify the module cache path</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodules-disable-diagnostic-validation">
+<tt class="descname">-fmodules-disable-diagnostic-validation</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmodules-disable-diagnostic-validation" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Disable validation of the diagnostic options when loading the module</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodules-prune-after">
+<tt class="descname">-fmodules-prune-after</tt><tt class="descclassname">=<seconds></tt><a class="headerlink" href="#cmdoption-clang-fmodules-prune-after" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify the interval (in seconds) after which a module file will be considered unused</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodules-prune-interval">
+<tt class="descname">-fmodules-prune-interval</tt><tt class="descclassname">=<seconds></tt><a class="headerlink" href="#cmdoption-clang-fmodules-prune-interval" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify the interval (in seconds) between attempts to prune the module cache</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodules-user-build-path">
+<tt class="descname">-fmodules-user-build-path</tt><tt class="descclassname"> <directory></tt><a class="headerlink" href="#cmdoption-clang-fmodules-user-build-path" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify the module user build path</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodules-validate-once-per-build-session">
+<tt class="descname">-fmodules-validate-once-per-build-session</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmodules-validate-once-per-build-session" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Don’t verify input files for the modules if the module has been successfully validated or loaded during this build session</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodules-validate-system-headers">
+<tt class="descname">-fmodules-validate-system-headers</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmodules-validate-system-headers" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Validate the system headers that a module depends on when loading the module</p>
+<dl class="option">
+<dt id="cmdoption-clang-fprebuilt-module-path">
+<tt class="descname">-fprebuilt-module-path</tt><tt class="descclassname">=<directory></tt><a class="headerlink" href="#cmdoption-clang-fprebuilt-module-path" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify the prebuilt module path</p>
+<dl class="option">
+<dt id="cmdoption-clang-i">
+<tt class="descname">-i</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-i" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-idirafter">
+<tt class="descname">-idirafter</tt><tt class="descclassname"><arg></tt><tt class="descclassname">, </tt><tt class="descname">--include-directory-after</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--include-directory-after</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-idirafter" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Add directory to AFTER include search path</p>
+<dl class="option">
+<dt id="cmdoption-clang-iframework">
+<tt class="descname">-iframework</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-iframework" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Add directory to SYSTEM framework search path</p>
+<dl class="option">
+<dt id="cmdoption-clang-iframeworkwithsysroot">
+<tt class="descname">-iframeworkwithsysroot</tt><tt class="descclassname"><directory></tt><a class="headerlink" href="#cmdoption-clang-iframeworkwithsysroot" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Add directory to SYSTEM framework search path, absolute paths are relative to -isysroot</p>
+<dl class="option">
+<dt id="cmdoption-clang-imacros">
+<tt class="descname">-imacros</tt><tt class="descclassname"><file></tt><tt class="descclassname">, </tt><tt class="descname">--imacros</tt><tt class="descclassname"><file></tt><tt class="descclassname">, </tt><tt class="descname">--imacros</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-imacros" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Include macros from file before parsing</p>
+<dl class="option">
+<dt id="cmdoption-clang-include">
+<tt class="descname">-include</tt><tt class="descclassname"><file></tt><tt class="descclassname">, </tt><tt class="descname">--include</tt><tt class="descclassname"><file></tt><tt class="descclassname">, </tt><tt class="descname">--include</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-include" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Include file before parsing</p>
+<dl class="option">
+<dt id="cmdoption-clang-include-pch">
+<tt class="descname">-include-pch</tt><tt class="descclassname"> <file></tt><a class="headerlink" href="#cmdoption-clang-include-pch" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Include precompiled header file</p>
+<dl class="option">
+<dt id="cmdoption-clang-iprefix">
+<tt class="descname">-iprefix</tt><tt class="descclassname"><dir></tt><tt class="descclassname">, </tt><tt class="descname">--include-prefix</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--include-prefix</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-iprefix" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Set the -iwithprefix/-iwithprefixbefore prefix</p>
+<dl class="option">
+<dt id="cmdoption-clang-iquote">
+<tt class="descname">-iquote</tt><tt class="descclassname"><directory></tt><a class="headerlink" href="#cmdoption-clang-iquote" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Add directory to QUOTE include search path</p>
+<dl class="option">
+<dt id="cmdoption-clang-isysroot">
+<tt class="descname">-isysroot</tt><tt class="descclassname"><dir></tt><a class="headerlink" href="#cmdoption-clang-isysroot" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Set the system root directory (usually /)</p>
+<dl class="option">
+<dt id="cmdoption-clang-isystem">
+<tt class="descname">-isystem</tt><tt class="descclassname"><directory></tt><a class="headerlink" href="#cmdoption-clang-isystem" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Add directory to SYSTEM include search path</p>
+<dl class="option">
+<dt id="cmdoption-clang-isystem-after">
+<tt class="descname">-isystem-after</tt><tt class="descclassname"><directory></tt><a class="headerlink" href="#cmdoption-clang-isystem-after" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Add directory to end of the SYSTEM include search path</p>
+<dl class="option">
+<dt id="cmdoption-clang-ivfsoverlay">
+<tt class="descname">-ivfsoverlay</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-ivfsoverlay" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Overlay the virtual filesystem described by file over the real file system</p>
+<dl class="option">
+<dt id="cmdoption-clang-iwithprefix">
+<tt class="descname">-iwithprefix</tt><tt class="descclassname"><dir></tt><tt class="descclassname">, </tt><tt class="descname">--include-with-prefix</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--include-with-prefix-after</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--include-with-prefix-after</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--include-with-prefix</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-iwithprefix" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Set directory to SYSTEM include search path with prefix</p>
+<dl class="option">
+<dt id="cmdoption-clang-iwithprefixbefore">
+<tt class="descname">-iwithprefixbefore</tt><tt class="descclassname"><dir></tt><tt class="descclassname">, </tt><tt class="descname">--include-with-prefix-before</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--include-with-prefix-before</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-iwithprefixbefore" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Set directory to include search path with prefix</p>
+<dl class="option">
+<dt id="cmdoption-clang-iwithsysroot">
+<tt class="descname">-iwithsysroot</tt><tt class="descclassname"><directory></tt><a class="headerlink" href="#cmdoption-clang-iwithsysroot" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Add directory to SYSTEM include search path, absolute paths are relative to -isysroot</p>
+<dl class="option">
+<dt id="cmdoption-clang--ptxas-path">
+<tt class="descname">--ptxas-path</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang--ptxas-path" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Path to ptxas (used for compiling CUDA code)</p>
+<dl class="option">
+<dt id="cmdoption-clang--system-header-prefix">
+<tt class="descname">--system-header-prefix</tt><tt class="descclassname">=<prefix></tt><tt class="descclassname">, </tt><tt class="descname">--no-system-header-prefix</tt><tt class="descclassname">=<prefix></tt><tt class="descclassname">, </tt><tt class="descname">--system-header-prefix</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang--system-header-prefix" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Treat all #include paths starting with <prefix> as including a system header.</p>
+</div>
+<div class="section" id="dependency-file-generation">
+<h4><a class="toc-backref" href="#id7">Dependency file generation</a><a class="headerlink" href="#dependency-file-generation" title="Permalink to this headline">¶</a></h4>
+<p>Flags controlling generation of a dependency file for <tt class="docutils literal"><span class="pre">make</span></tt>-like build
+systems.</p>
+<dl class="option">
+<dt id="cmdoption-clang-M">
+<tt class="descname">-M</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--dependencies</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-M" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Like -MD, but also implies -E and writes to stdout by default</p>
+<dl class="option">
+<dt id="cmdoption-clang-MD">
+<tt class="descname">-MD</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--write-dependencies</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-MD" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Write a depfile containing user and system headers</p>
+<dl class="option">
+<dt id="cmdoption-clang-MF">
+<tt class="descname">-MF</tt><tt class="descclassname"><file></tt><a class="headerlink" href="#cmdoption-clang-MF" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Write depfile output from -MMD, -MD, -MM, or -M to <file></p>
+<dl class="option">
+<dt id="cmdoption-clang-MG">
+<tt class="descname">-MG</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--print-missing-file-dependencies</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-MG" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Add missing headers to depfile</p>
+<dl class="option">
+<dt id="cmdoption-clang-MJ">
+<tt class="descname">-MJ</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-MJ" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Write a compilation database entry per input</p>
+<dl class="option">
+<dt id="cmdoption-clang-MM">
+<tt class="descname">-MM</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--user-dependencies</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-MM" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Like -MMD, but also implies -E and writes to stdout by default</p>
+<dl class="option">
+<dt id="cmdoption-clang-MMD">
+<tt class="descname">-MMD</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--write-user-dependencies</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-MMD" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Write a depfile containing user headers</p>
+<dl class="option">
+<dt id="cmdoption-clang-MP">
+<tt class="descname">-MP</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-MP" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Create phony target for each dependency (other than main file)</p>
+<dl class="option">
+<dt id="cmdoption-clang-MQ">
+<tt class="descname">-MQ</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-MQ" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify name of main file output to quote in depfile</p>
+<dl class="option">
+<dt id="cmdoption-clang-MT">
+<tt class="descname">-MT</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-MT" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify name of main file output in depfile</p>
+<dl class="option">
+<dt id="cmdoption-clang-MV">
+<tt class="descname">-MV</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-MV" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use NMake/Jom format for the depfile</p>
+</div>
+<div class="section" id="dumping-preprocessor-state">
+<h4><a class="toc-backref" href="#id8">Dumping preprocessor state</a><a class="headerlink" href="#dumping-preprocessor-state" title="Permalink to this headline">¶</a></h4>
+<p>Flags allowing the state of the preprocessor to be dumped in various ways.</p>
+<dl class="option">
+<dt id="cmdoption-clang-d">
+<tt class="descname">-d</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-d" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-d">
+<tt class="descname">-d</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang1-d" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-dA">
+<tt class="descname">-dA</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-dA" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-dD">
+<tt class="descname">-dD</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-dD" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Print macro definitions in -E mode in addition to normal output</p>
+<dl class="option">
+<dt id="cmdoption-clang-dI">
+<tt class="descname">-dI</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-dI" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Print include directives in -E mode in addition to normal output</p>
+<dl class="option">
+<dt id="cmdoption-clang-dM">
+<tt class="descname">-dM</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-dM" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Print macro definitions in -E mode instead of normal output</p>
+</div>
+</div>
+<div class="section" id="diagnostic-flags">
+<h3><a class="toc-backref" href="#id9">Diagnostic flags</a><a class="headerlink" href="#diagnostic-flags" title="Permalink to this headline">¶</a></h3>
+<p>Flags controlling which warnings, errors, and remarks Clang will generate.
+See the <a class="reference internal" href="DiagnosticsReference.html"><em>full list of warning and remark flags</em></a>.</p>
+<dl class="option">
+<dt id="cmdoption-clang-R">
+<tt class="descname">-R</tt><tt class="descclassname"><remark></tt><a class="headerlink" href="#cmdoption-clang-R" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable the specified remark</p>
+<dl class="option">
+<dt id="cmdoption-clang-Rpass-analysis">
+<tt class="descname">-Rpass-analysis</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-Rpass-analysis" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Report transformation analysis from optimization passes whose name matches the given POSIX regular expression</p>
+<dl class="option">
+<dt id="cmdoption-clang-Rpass-missed">
+<tt class="descname">-Rpass-missed</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-Rpass-missed" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Report missed transformations by optimization passes whose name matches the given POSIX regular expression</p>
+<dl class="option">
+<dt id="cmdoption-clang-Rpass">
+<tt class="descname">-Rpass</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-Rpass" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Report transformations performed by optimization passes whose name matches the given POSIX regular expression</p>
+<dl class="option">
+<dt id="cmdoption-clang-W">
+<tt class="descname">-W</tt><tt class="descclassname"><warning></tt><tt class="descclassname">, </tt><tt class="descname">--extra-warnings</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--warn-</tt><tt class="descclassname"><arg></tt><tt class="descclassname">, </tt><tt class="descname">--warn-</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-W" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable the specified warning</p>
+<dl class="option">
+<dt id="cmdoption-clang-Wdeprecated">
+<tt class="descname">-Wdeprecated</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-Wno-deprecated</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-Wdeprecated" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable warnings for deprecated constructs and define __DEPRECATED</p>
+<dl class="option">
+<dt id="cmdoption-clang-Wnonportable-cfstrings">
+<tt class="descname">-Wnonportable-cfstrings</tt><tt class="descclassname"><arg></tt><tt class="descclassname">, </tt><tt class="descname">-Wno-nonportable-cfstrings</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-Wnonportable-cfstrings" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+</div>
+<div class="section" id="target-independent-compilation-options">
+<h3><a class="toc-backref" href="#id10">Target-independent compilation options</a><a class="headerlink" href="#target-independent-compilation-options" title="Permalink to this headline">¶</a></h3>
+<dl class="option">
+<dt id="cmdoption-clang-Wframe-larger-than">
+<tt class="descname">-Wframe-larger-than</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-Wframe-larger-than" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fPIC">
+<tt class="descname">-fPIC</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-PIC</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fPIC" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fPIE">
+<tt class="descname">-fPIE</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-PIE</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fPIE" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-faccess-control">
+<tt class="descname">-faccess-control</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-access-control</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-faccess-control" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-faligned-allocation">
+<tt class="descname">-faligned-allocation</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-faligned-new</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-aligned-allocation</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang1-faligned-allocation" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable C++17 aligned allocation functions</p>
+<dl class="option">
+<dt id="cmdoption-clang-fallow-editor-placeholders">
+<tt class="descname">-fallow-editor-placeholders</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-allow-editor-placeholders</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fallow-editor-placeholders" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Treat editor placeholders as valid source code</p>
+<dl class="option">
+<dt id="cmdoption-clang-fallow-unsupported">
+<tt class="descname">-fallow-unsupported</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fallow-unsupported" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-faltivec">
+<tt class="descname">-faltivec</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-altivec</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-faltivec" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fansi-escape-codes">
+<tt class="descname">-fansi-escape-codes</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fansi-escape-codes" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use ANSI escape codes for diagnostics</p>
+<dl class="option">
+<dt id="cmdoption-clang-fapple-kext">
+<tt class="descname">-fapple-kext</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-findirect-virtual-calls</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fterminated-vtables</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fapple-kext" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use Apple’s kernel extensions ABI</p>
+<dl class="option">
+<dt id="cmdoption-clang-fapple-pragma-pack">
+<tt class="descname">-fapple-pragma-pack</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-apple-pragma-pack</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fapple-pragma-pack" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable Apple gcc-compatible #pragma pack handling</p>
+<dl class="option">
+<dt id="cmdoption-clang-fapplication-extension">
+<tt class="descname">-fapplication-extension</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-application-extension</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fapplication-extension" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Restrict code to those available for App Extensions</p>
+<dl class="option">
+<dt id="cmdoption-clang-fasm">
+<tt class="descname">-fasm</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-asm</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fasm" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fasm-blocks">
+<tt class="descname">-fasm-blocks</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-asm-blocks</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fasm-blocks" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fassociative-math">
+<tt class="descname">-fassociative-math</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-associative-math</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fassociative-math" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fassume-sane-operator-new">
+<tt class="descname">-fassume-sane-operator-new</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-assume-sane-operator-new</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fassume-sane-operator-new" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fast">
+<tt class="descname">-fast</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fast" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fastcp">
+<tt class="descname">-fastcp</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fastcp" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fastf">
+<tt class="descname">-fastf</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fastf" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fasynchronous-unwind-tables">
+<tt class="descname">-fasynchronous-unwind-tables</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-asynchronous-unwind-tables</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fasynchronous-unwind-tables" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fautolink">
+<tt class="descname">-fautolink</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-autolink</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fautolink" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fblocks">
+<tt class="descname">-fblocks</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-blocks</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fblocks" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable the ‘blocks’ language feature</p>
+<dl class="option">
+<dt id="cmdoption-clang-fbootclasspath">
+<tt class="descname">-fbootclasspath</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--bootclasspath</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--bootclasspath</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fbootclasspath" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fborland-extensions">
+<tt class="descname">-fborland-extensions</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-borland-extensions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fborland-extensions" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Accept non-standard constructs supported by the Borland compiler</p>
+<dl class="option">
+<dt id="cmdoption-clang-fbracket-depth">
+<tt class="descname">-fbracket-depth</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fbracket-depth" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fbuiltin">
+<tt class="descname">-fbuiltin</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-builtin</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fbuiltin" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fbuiltin-module-map">
+<tt class="descname">-fbuiltin-module-map</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fbuiltin-module-map" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Load the clang builtins module map file.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fcaret-diagnostics">
+<tt class="descname">-fcaret-diagnostics</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-caret-diagnostics</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fcaret-diagnostics" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fclasspath">
+<tt class="descname">-fclasspath</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--CLASSPATH</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--CLASSPATH</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--classpath</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--classpath</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fclasspath" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fcolor-diagnostics">
+<tt class="descname">-fcolor-diagnostics</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-color-diagnostics</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fcolor-diagnostics" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use colors in diagnostics</p>
+<dl class="option">
+<dt id="cmdoption-clang-fcommon">
+<tt class="descname">-fcommon</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-common</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fcommon" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fcompile-resource">
+<tt class="descname">-fcompile-resource</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--resource</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--resource</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fcompile-resource" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fconstant-cfstrings">
+<tt class="descname">-fconstant-cfstrings</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-constant-cfstrings</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fconstant-cfstrings" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fconstant-string-class">
+<tt class="descname">-fconstant-string-class</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fconstant-string-class" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fconstexpr-backtrace-limit">
+<tt class="descname">-fconstexpr-backtrace-limit</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fconstexpr-backtrace-limit" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fconstexpr-depth">
+<tt class="descname">-fconstexpr-depth</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fconstexpr-depth" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fconstexpr-steps">
+<tt class="descname">-fconstexpr-steps</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fconstexpr-steps" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fcoroutines-ts">
+<tt class="descname">-fcoroutines-ts</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-coroutines-ts</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fcoroutines-ts" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable support for the C++ Coroutines TS</p>
+<dl class="option">
+<dt id="cmdoption-clang-fcoverage-mapping">
+<tt class="descname">-fcoverage-mapping</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-coverage-mapping</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fcoverage-mapping" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate coverage mapping to enable code coverage analysis</p>
+<dl class="option">
+<dt id="cmdoption-clang-fcreate-profile">
+<tt class="descname">-fcreate-profile</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fcreate-profile" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fcxx-exceptions">
+<tt class="descname">-fcxx-exceptions</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-cxx-exceptions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fcxx-exceptions" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable C++ exceptions</p>
+<dl class="option">
+<dt id="cmdoption-clang-fcxx-modules">
+<tt class="descname">-fcxx-modules</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-cxx-modules</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fcxx-modules" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdata-sections">
+<tt class="descname">-fdata-sections</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-data-sections</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdata-sections" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Place each data in its own section (ELF Only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdebug-info-for-profiling">
+<tt class="descname">-fdebug-info-for-profiling</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-debug-info-for-profiling</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdebug-info-for-profiling" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Emit extra debug info to make sample profile more accurate.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdebug-macro">
+<tt class="descname">-fdebug-macro</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-debug-macro</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdebug-macro" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Emit macro debug information</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdebug-pass-arguments">
+<tt class="descname">-fdebug-pass-arguments</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdebug-pass-arguments" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdebug-pass-structure">
+<tt class="descname">-fdebug-pass-structure</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdebug-pass-structure" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdebug-prefix-map">
+<tt class="descname">-fdebug-prefix-map</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fdebug-prefix-map" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>remap file source paths in debug info</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdebug-types-section">
+<tt class="descname">-fdebug-types-section</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-debug-types-section</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdebug-types-section" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Place debug types in their own section (ELF Only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdelayed-template-parsing">
+<tt class="descname">-fdelayed-template-parsing</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-delayed-template-parsing</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdelayed-template-parsing" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Parse templated function definitions at the end of the translation unit</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdenormal-fp-math">
+<tt class="descname">-fdenormal-fp-math</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fdenormal-fp-math" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdiagnostics-absolute-paths">
+<tt class="descname">-fdiagnostics-absolute-paths</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdiagnostics-absolute-paths" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Print absolute paths in diagnostics</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdiagnostics-color">
+<tt class="descname">-fdiagnostics-color</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-diagnostics-color</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdiagnostics-color" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-fdiagnostics-color">
+<tt class="descname">-fdiagnostics-color</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang1-fdiagnostics-color" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdiagnostics-hotness-threshold">
+<tt class="descname">-fdiagnostics-hotness-threshold</tt><tt class="descclassname">=<number></tt><a class="headerlink" href="#cmdoption-clang-fdiagnostics-hotness-threshold" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Prevent optimization remarks from being output if they do not have at least this profile count</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdiagnostics-show-hotness">
+<tt class="descname">-fdiagnostics-show-hotness</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-diagnostics-show-hotness</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdiagnostics-show-hotness" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable profile hotness information in diagnostic line</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdiagnostics-show-note-include-stack">
+<tt class="descname">-fdiagnostics-show-note-include-stack</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-diagnostics-show-note-include-stack</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdiagnostics-show-note-include-stack" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Display include stacks for diagnostic notes</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdiagnostics-show-option">
+<tt class="descname">-fdiagnostics-show-option</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-diagnostics-show-option</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdiagnostics-show-option" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Print option name with mappable diagnostics</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdiagnostics-show-template-tree">
+<tt class="descname">-fdiagnostics-show-template-tree</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdiagnostics-show-template-tree" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Print a template comparison tree for differing templates</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdollars-in-identifiers">
+<tt class="descname">-fdollars-in-identifiers</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-dollars-in-identifiers</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdollars-in-identifiers" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Allow ‘$’ in identifiers</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdouble-square-bracket-attributes">
+<tt class="descname">-fdouble-square-bracket-attributes</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-double-square-bracket-attributes</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdouble-square-bracket-attributes" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable ‘[[]]’ attributes in all C and C++ language modes</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdwarf-directory-asm">
+<tt class="descname">-fdwarf-directory-asm</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-dwarf-directory-asm</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdwarf-directory-asm" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdwarf-exceptions">
+<tt class="descname">-fdwarf-exceptions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdwarf-exceptions" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use DWARF style exceptions</p>
+<dl class="option">
+<dt id="cmdoption-clang-felide-constructors">
+<tt class="descname">-felide-constructors</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-elide-constructors</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-felide-constructors" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-feliminate-unused-debug-symbols">
+<tt class="descname">-feliminate-unused-debug-symbols</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-eliminate-unused-debug-symbols</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-feliminate-unused-debug-symbols" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fembed-bitcode">
+<tt class="descname">-fembed-bitcode</tt><tt class="descclassname">=<option></tt><tt class="descclassname">, </tt><tt class="descname">-fembed-bitcode</tt><tt class="descclassname"> (equivalent to -fembed-bitcode=all)</tt><tt class="descclassname">, </tt><tt class="descname">-fembed-bitcode-marker</tt><tt class="descclassname"> (equivalent to -fembed-bitcode=marker)</tt><a class="headerlink" href="#cmdoption-clang-fembed-bitcode" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Embed LLVM bitcode (option: off, all, bitcode, marker)</p>
+<dl class="option">
+<dt id="cmdoption-clang-femit-all-decls">
+<tt class="descname">-femit-all-decls</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-femit-all-decls" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Emit all declarations, even if unused</p>
+<dl class="option">
+<dt id="cmdoption-clang-femulated-tls">
+<tt class="descname">-femulated-tls</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-emulated-tls</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-femulated-tls" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use emutls functions to access thread_local variables</p>
+<dl class="option">
+<dt id="cmdoption-clang-fencoding">
+<tt class="descname">-fencoding</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--encoding</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--encoding</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fencoding" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ferror-limit">
+<tt class="descname">-ferror-limit</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-ferror-limit" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fexceptions">
+<tt class="descname">-fexceptions</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-exceptions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fexceptions" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable support for exception handling</p>
+<dl class="option">
+<dt id="cmdoption-clang-fexec-charset">
+<tt class="descname">-fexec-charset</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fexec-charset" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fextdirs">
+<tt class="descname">-fextdirs</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--extdirs</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--extdirs</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fextdirs" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ffast-math">
+<tt class="descname">-ffast-math</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-fast-math</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ffast-math" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Allow aggressive, lossy floating-point optimizations</p>
+<dl class="option">
+<dt id="cmdoption-clang-ffinite-math-only">
+<tt class="descname">-ffinite-math-only</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-finite-math-only</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ffinite-math-only" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ffor-scope">
+<tt class="descname">-ffor-scope</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-for-scope</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ffor-scope" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ffp-contract">
+<tt class="descname">-ffp-contract</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-ffp-contract" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Form fused FP ops (e.g. FMAs): fast (everywhere) | on (according to FP_CONTRACT pragma, default) | off (never fuse)</p>
+<dl class="option">
+<dt id="cmdoption-clang-ffreestanding">
+<tt class="descname">-ffreestanding</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ffreestanding" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Assert that the compilation takes place in a freestanding environment</p>
+<dl class="option">
+<dt id="cmdoption-clang-ffunction-sections">
+<tt class="descname">-ffunction-sections</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-function-sections</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ffunction-sections" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Place each function in its own section (ELF Only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-fgnu-inline-asm">
+<tt class="descname">-fgnu-inline-asm</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-gnu-inline-asm</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fgnu-inline-asm" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fgnu-keywords">
+<tt class="descname">-fgnu-keywords</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-gnu-keywords</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fgnu-keywords" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Allow GNU-extension keywords regardless of language standard</p>
+<dl class="option">
+<dt id="cmdoption-clang-fgnu-runtime">
+<tt class="descname">-fgnu-runtime</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fgnu-runtime" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate output compatible with the standard GNU Objective-C runtime</p>
+<dl class="option">
+<dt id="cmdoption-clang-fgnu89-inline">
+<tt class="descname">-fgnu89-inline</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-gnu89-inline</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fgnu89-inline" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use the gnu89 inline semantics</p>
+<dl class="option">
+<dt id="cmdoption-clang-fhonor-infinities">
+<tt class="descname">-fhonor-infinities</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fhonor-infinites</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-honor-infinities</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fhonor-infinities" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fhonor-nans">
+<tt class="descname">-fhonor-nans</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-honor-nans</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fhonor-nans" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fhosted">
+<tt class="descname">-fhosted</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fhosted" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fimplicit-module-maps">
+<tt class="descname">-fimplicit-module-maps</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fmodule-maps</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-implicit-module-maps</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fimplicit-module-maps" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Implicitly search the file system for module map files.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fimplicit-modules">
+<tt class="descname">-fimplicit-modules</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-implicit-modules</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fimplicit-modules" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-finput-charset">
+<tt class="descname">-finput-charset</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-finput-charset" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-finstrument-function-entry-bare">
+<tt class="descname">-finstrument-function-entry-bare</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-finstrument-function-entry-bare" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Instrument function entry only, after inlining, without arguments to the instrumentation call</p>
+<dl class="option">
+<dt id="cmdoption-clang-finstrument-functions">
+<tt class="descname">-finstrument-functions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-finstrument-functions" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate calls to instrument function entry and exit</p>
+<dl class="option">
+<dt id="cmdoption-clang-finstrument-functions-after-inlining">
+<tt class="descname">-finstrument-functions-after-inlining</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-finstrument-functions-after-inlining" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Like -finstrument-functions, but insert the calls after inlining</p>
+<dl class="option">
+<dt id="cmdoption-clang-fintegrated-as">
+<tt class="descname">-fintegrated-as</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-integrated-as</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-integrated-as</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fintegrated-as" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable the integrated assembler</p>
+<dl class="option">
+<dt id="cmdoption-clang-fjump-tables">
+<tt class="descname">-fjump-tables</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-jump-tables</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fjump-tables" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-flax-vector-conversions">
+<tt class="descname">-flax-vector-conversions</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-lax-vector-conversions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-flax-vector-conversions" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-flimited-precision">
+<tt class="descname">-flimited-precision</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-flimited-precision" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-flto">
+<tt class="descname">-flto</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-lto</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-flto" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable LTO in ‘full’ mode</p>
+<dl class="option">
+<dt id="cmdoption-clang-flto-jobs">
+<tt class="descname">-flto-jobs</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-flto-jobs" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Controls the backend parallelism of -flto=thin (default of 0 means the number of threads will be derived from the number of CPUs detected)</p>
+<dl class="option">
+<dt id="cmdoption-clang1-flto">
+<tt class="descname">-flto</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang1-flto" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Set LTO mode to either ‘full’ or ‘thin’</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmacro-backtrace-limit">
+<tt class="descname">-fmacro-backtrace-limit</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fmacro-backtrace-limit" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fmath-errno">
+<tt class="descname">-fmath-errno</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-math-errno</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmath-errno" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Require math functions to indicate errors by setting errno</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmax-type-align">
+<tt class="descname">-fmax-type-align</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fmax-type-align" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify the maximum alignment to enforce on pointers lacking an explicit alignment</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmerge-all-constants">
+<tt class="descname">-fmerge-all-constants</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-merge-all-constants</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmerge-all-constants" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fmessage-length">
+<tt class="descname">-fmessage-length</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fmessage-length" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fmodule-file-deps">
+<tt class="descname">-fmodule-file-deps</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-module-file-deps</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmodule-file-deps" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fmodule-map-file">
+<tt class="descname">-fmodule-map-file</tt><tt class="descclassname">=<file></tt><a class="headerlink" href="#cmdoption-clang-fmodule-map-file" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Load this module map file</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodule-name">
+<tt class="descname">-fmodule-name</tt><tt class="descclassname">=<name></tt><tt class="descclassname">, </tt><tt class="descname">-fmodule-implementation-of</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">-fmodule-name</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-fmodule-name" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify the name of the module to build</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodules">
+<tt class="descname">-fmodules</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-modules</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmodules" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable the ‘modules’ language feature</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodules-decluse">
+<tt class="descname">-fmodules-decluse</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-modules-decluse</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmodules-decluse" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Require declaration of modules used within a module</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodules-ignore-macro">
+<tt class="descname">-fmodules-ignore-macro</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fmodules-ignore-macro" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Ignore the definition of the given macro when building and loading modules</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodules-search-all">
+<tt class="descname">-fmodules-search-all</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-modules-search-all</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmodules-search-all" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Search even non-imported modules to resolve references</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodules-strict-decluse">
+<tt class="descname">-fmodules-strict-decluse</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmodules-strict-decluse" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Like -fmodules-decluse but requires all headers to be in modules</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodules-ts">
+<tt class="descname">-fmodules-ts</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmodules-ts" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable support for the C++ Modules TS</p>
+<dl class="option">
+<dt id="cmdoption-clang-fms-compatibility">
+<tt class="descname">-fms-compatibility</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-ms-compatibility</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fms-compatibility" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable full Microsoft Visual C++ compatibility</p>
+<dl class="option">
+<dt id="cmdoption-clang-fms-compatibility-version">
+<tt class="descname">-fms-compatibility-version</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fms-compatibility-version" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Dot-separated value representing the Microsoft compiler version number to report in _MSC_VER (0 = don’t define it (default))</p>
+<dl class="option">
+<dt id="cmdoption-clang-fms-extensions">
+<tt class="descname">-fms-extensions</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-ms-extensions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fms-extensions" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Accept some non-standard constructs supported by the Microsoft compiler</p>
+<dl class="option">
+<dt id="cmdoption-clang-fms-memptr-rep">
+<tt class="descname">-fms-memptr-rep</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fms-memptr-rep" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fms-volatile">
+<tt class="descname">-fms-volatile</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-fms-volatile" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fmsc-version">
+<tt class="descname">-fmsc-version</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fmsc-version" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Microsoft compiler version number to report in _MSC_VER (0 = don’t define it (default))</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmudflap">
+<tt class="descname">-fmudflap</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmudflap" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fmudflapth">
+<tt class="descname">-fmudflapth</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmudflapth" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fnested-functions">
+<tt class="descname">-fnested-functions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fnested-functions" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fnew-alignment">
+<tt class="descname">-fnew-alignment</tt><tt class="descclassname">=<align></tt><tt class="descclassname">, </tt><tt class="descname">-fnew-alignment</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-fnew-alignment" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Specifies the largest alignment guaranteed by ‘::operator new(size_t)’</p>
+<dl class="option">
+<dt id="cmdoption-clang-fnext-runtime">
+<tt class="descname">-fnext-runtime</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fnext-runtime" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fno-builtin-">
+<tt class="descname">-fno-builtin-</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-fno-builtin-" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Disable implicit builtin knowledge of a specific function</p>
+<dl class="option">
+<dt id="cmdoption-clang-fno-elide-type">
+<tt class="descname">-fno-elide-type</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fno-elide-type" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Do not elide types when printing diagnostics</p>
+<dl class="option">
+<dt id="cmdoption-clang-fno-max-type-align">
+<tt class="descname">-fno-max-type-align</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fno-max-type-align" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fno-operator-names">
+<tt class="descname">-fno-operator-names</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fno-operator-names" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Do not treat C++ operator name keywords as synonyms for operators</p>
+<dl class="option">
+<dt id="cmdoption-clang-fno-strict-modules-decluse">
+<tt class="descname">-fno-strict-modules-decluse</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fno-strict-modules-decluse" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fno-working-directory">
+<tt class="descname">-fno-working-directory</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fno-working-directory" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fnoopenmp-relocatable-target">
+<tt class="descname">-fnoopenmp-relocatable-target</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fnoopenmp-relocatable-target" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Do not compile OpenMP target code as relocatable.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fnoopenmp-use-tls">
+<tt class="descname">-fnoopenmp-use-tls</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fnoopenmp-use-tls" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fobjc-abi-version">
+<tt class="descname">-fobjc-abi-version</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fobjc-abi-version" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fobjc-arc">
+<tt class="descname">-fobjc-arc</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-objc-arc</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fobjc-arc" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Synthesize retain and release calls for Objective-C pointers</p>
+<dl class="option">
+<dt id="cmdoption-clang-fobjc-arc-exceptions">
+<tt class="descname">-fobjc-arc-exceptions</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-objc-arc-exceptions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fobjc-arc-exceptions" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use EH-safe code when synthesizing retains and releases in -fobjc-arc</p>
+<dl class="option">
+<dt id="cmdoption-clang-fobjc-exceptions">
+<tt class="descname">-fobjc-exceptions</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-objc-exceptions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fobjc-exceptions" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable Objective-C exceptions</p>
+<dl class="option">
+<dt id="cmdoption-clang-fobjc-infer-related-result-type">
+<tt class="descname">-fobjc-infer-related-result-type</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-objc-infer-related-result-type</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fobjc-infer-related-result-type" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fobjc-legacy-dispatch">
+<tt class="descname">-fobjc-legacy-dispatch</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-objc-legacy-dispatch</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fobjc-legacy-dispatch" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fobjc-link-runtime">
+<tt class="descname">-fobjc-link-runtime</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fobjc-link-runtime" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fobjc-nonfragile-abi">
+<tt class="descname">-fobjc-nonfragile-abi</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-objc-nonfragile-abi</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fobjc-nonfragile-abi" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fobjc-nonfragile-abi-version">
+<tt class="descname">-fobjc-nonfragile-abi-version</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fobjc-nonfragile-abi-version" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fobjc-runtime">
+<tt class="descname">-fobjc-runtime</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fobjc-runtime" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify the target Objective-C runtime kind and version</p>
+<dl class="option">
+<dt id="cmdoption-clang-fobjc-sender-dependent-dispatch">
+<tt class="descname">-fobjc-sender-dependent-dispatch</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fobjc-sender-dependent-dispatch" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fobjc-weak">
+<tt class="descname">-fobjc-weak</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-objc-weak</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fobjc-weak" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable ARC-style weak references in Objective-C</p>
+<dl class="option">
+<dt id="cmdoption-clang-fomit-frame-pointer">
+<tt class="descname">-fomit-frame-pointer</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-omit-frame-pointer</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fomit-frame-pointer" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fopenmp">
+<tt class="descname">-fopenmp</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-openmp</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fopenmp" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fopenmp-dump-offload-linker-script">
+<tt class="descname">-fopenmp-dump-offload-linker-script</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fopenmp-dump-offload-linker-script" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fopenmp-relocatable-target">
+<tt class="descname">-fopenmp-relocatable-target</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fopenmp-relocatable-target" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>OpenMP target code is compiled as relocatable using the -c flag. For OpenMP targets the code is relocatable by default.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fopenmp-simd">
+<tt class="descname">-fopenmp-simd</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-openmp-simd</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fopenmp-simd" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Emit OpenMP code only for SIMD-based constructs.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fopenmp-use-tls">
+<tt class="descname">-fopenmp-use-tls</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fopenmp-use-tls" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fopenmp-version">
+<tt class="descname">-fopenmp-version</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fopenmp-version" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-fopenmp">
+<tt class="descname">-fopenmp</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang1-fopenmp" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-foperator-arrow-depth">
+<tt class="descname">-foperator-arrow-depth</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-foperator-arrow-depth" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-foptimization-record-file">
+<tt class="descname">-foptimization-record-file</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-foptimization-record-file" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify the file name of any generated YAML optimization record</p>
+<dl class="option">
+<dt id="cmdoption-clang-foptimize-sibling-calls">
+<tt class="descname">-foptimize-sibling-calls</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-optimize-sibling-calls</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-foptimize-sibling-calls" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-foutput-class-dir">
+<tt class="descname">-foutput-class-dir</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--output-class-directory</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--output-class-directory</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-foutput-class-dir" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fpack-struct">
+<tt class="descname">-fpack-struct</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-pack-struct</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fpack-struct" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-fpack-struct">
+<tt class="descname">-fpack-struct</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang1-fpack-struct" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify the default maximum struct packing alignment</p>
+<dl class="option">
+<dt id="cmdoption-clang-fpascal-strings">
+<tt class="descname">-fpascal-strings</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-pascal-strings</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mpascal-strings</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fpascal-strings" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Recognize and construct Pascal-style string literals</p>
+<dl class="option">
+<dt id="cmdoption-clang-fpcc-struct-return">
+<tt class="descname">-fpcc-struct-return</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fpcc-struct-return" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Override the default ABI to return all structs on the stack</p>
+<dl class="option">
+<dt id="cmdoption-clang-fpch-preprocess">
+<tt class="descname">-fpch-preprocess</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fpch-preprocess" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fpic">
+<tt class="descname">-fpic</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-pic</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fpic" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fpie">
+<tt class="descname">-fpie</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-pie</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fpie" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fplt">
+<tt class="descname">-fplt</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-plt</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fplt" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use the PLT to make function calls</p>
+<dl class="option">
+<dt id="cmdoption-clang-fplugin">
+<tt class="descname">-fplugin</tt><tt class="descclassname">=<dsopath></tt><a class="headerlink" href="#cmdoption-clang-fplugin" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Load the named plugin (dynamic shared object)</p>
+<dl class="option">
+<dt id="cmdoption-clang-fpreserve-as-comments">
+<tt class="descname">-fpreserve-as-comments</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-preserve-as-comments</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fpreserve-as-comments" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fprofile-arcs">
+<tt class="descname">-fprofile-arcs</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-profile-arcs</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fprofile-arcs" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fprofile-dir">
+<tt class="descname">-fprofile-dir</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fprofile-dir" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fprofile-generate">
+<tt class="descname">-fprofile-generate</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-profile-generate</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fprofile-generate" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate instrumented code to collect execution counts into default.profraw (overridden by LLVM_PROFILE_FILE env var)</p>
+<dl class="option">
+<dt id="cmdoption-clang1-fprofile-generate">
+<tt class="descname">-fprofile-generate</tt><tt class="descclassname">=<directory></tt><a class="headerlink" href="#cmdoption-clang1-fprofile-generate" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate instrumented code to collect execution counts into <directory>/default.profraw (overridden by LLVM_PROFILE_FILE env var)</p>
+<dl class="option">
+<dt id="cmdoption-clang-fprofile-instr-generate">
+<tt class="descname">-fprofile-instr-generate</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-profile-instr-generate</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fprofile-instr-generate" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate instrumented code to collect execution counts into default.profraw file (overridden by ‘=’ form of option or LLVM_PROFILE_FILE env var)</p>
+<dl class="option">
+<dt id="cmdoption-clang1-fprofile-instr-generate">
+<tt class="descname">-fprofile-instr-generate</tt><tt class="descclassname">=<file></tt><a class="headerlink" href="#cmdoption-clang1-fprofile-instr-generate" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate instrumented code to collect execution counts into <file> (overridden by LLVM_PROFILE_FILE env var)</p>
+<dl class="option">
+<dt id="cmdoption-clang-fprofile-instr-use">
+<tt class="descname">-fprofile-instr-use</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-profile-instr-use</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fprofile-use</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fprofile-instr-use" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-fprofile-instr-use">
+<tt class="descname">-fprofile-instr-use</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang1-fprofile-instr-use" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use instrumentation data for profile-guided optimization</p>
+<dl class="option">
+<dt id="cmdoption-clang-fprofile-sample-accurate">
+<tt class="descname">-fprofile-sample-accurate</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fauto-profile-accurate</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-profile-sample-accurate</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fprofile-sample-accurate" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="docutils">
+<dt>Specifies that the sample profile is accurate. If the sample</dt>
+<dd>profile is accurate, callsites without profile samples are marked
+as cold. Otherwise, treat callsites without profile samples as if
+we have no profile</dd>
+</dl>
+<dl class="option">
+<dt id="cmdoption-clang-fprofile-sample-use">
+<tt class="descname">-fprofile-sample-use</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fauto-profile</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-profile-sample-use</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fprofile-sample-use" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-fprofile-sample-use">
+<tt class="descname">-fprofile-sample-use</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">-fauto-profile</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang1-fprofile-sample-use" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable sample-based profile guided optimizations</p>
+<dl class="option">
+<dt id="cmdoption-clang1-fprofile-use">
+<tt class="descname">-fprofile-use</tt><tt class="descclassname">=<pathname></tt><a class="headerlink" href="#cmdoption-clang1-fprofile-use" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use instrumentation data for profile-guided optimization. If pathname is a directory, it reads from <pathname>/default.profdata. Otherwise, it reads from file <pathname>.</p>
+<dl class="option">
+<dt id="cmdoption-clang-freciprocal-math">
+<tt class="descname">-freciprocal-math</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-reciprocal-math</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-freciprocal-math" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Allow division operations to be reassociated</p>
+<dl class="option">
+<dt id="cmdoption-clang-freg-struct-return">
+<tt class="descname">-freg-struct-return</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-freg-struct-return" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Override the default ABI to return small structs in registers</p>
+<dl class="option">
+<dt id="cmdoption-clang-frelaxed-template-template-args">
+<tt class="descname">-frelaxed-template-template-args</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-relaxed-template-template-args</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-frelaxed-template-template-args" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable C++17 relaxed template template argument matching</p>
+<dl class="option">
+<dt id="cmdoption-clang-freroll-loops">
+<tt class="descname">-freroll-loops</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-reroll-loops</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-freroll-loops" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Turn on loop reroller</p>
+<dl class="option">
+<dt id="cmdoption-clang-fretain-comments-from-system-headers">
+<tt class="descname">-fretain-comments-from-system-headers</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fretain-comments-from-system-headers" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-frewrite-imports">
+<tt class="descname">-frewrite-imports</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-rewrite-imports</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-frewrite-imports" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-frewrite-includes">
+<tt class="descname">-frewrite-includes</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-rewrite-includes</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-frewrite-includes" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-frewrite-map-file">
+<tt class="descname">-frewrite-map-file</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-frewrite-map-file" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-frewrite-map-file">
+<tt class="descname">-frewrite-map-file</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang1-frewrite-map-file" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fropi">
+<tt class="descname">-fropi</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-ropi</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fropi" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-frtti">
+<tt class="descname">-frtti</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-rtti</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-frtti" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-frwpi">
+<tt class="descname">-frwpi</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-rwpi</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-frwpi" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fsave-optimization-record">
+<tt class="descname">-fsave-optimization-record</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-save-optimization-record</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsave-optimization-record" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate a YAML optimization record file</p>
+<dl class="option">
+<dt id="cmdoption-clang-fseh-exceptions">
+<tt class="descname">-fseh-exceptions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fseh-exceptions" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use SEH style exceptions</p>
+<dl class="option">
+<dt id="cmdoption-clang-fshort-enums">
+<tt class="descname">-fshort-enums</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-short-enums</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fshort-enums" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Allocate to an enum type only as many bytes as it needs for the declared range of possible values</p>
+<dl class="option">
+<dt id="cmdoption-clang-fshort-wchar">
+<tt class="descname">-fshort-wchar</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-short-wchar</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fshort-wchar" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Force wchar_t to be a short unsigned int</p>
+<dl class="option">
+<dt id="cmdoption-clang-fshow-column">
+<tt class="descname">-fshow-column</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-show-column</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fshow-column" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fshow-overloads">
+<tt class="descname">-fshow-overloads</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fshow-overloads" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Which overload candidates to show when overload resolution fails: best|all; defaults to all</p>
+<dl class="option">
+<dt id="cmdoption-clang-fshow-source-location">
+<tt class="descname">-fshow-source-location</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-show-source-location</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fshow-source-location" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fsignaling-math">
+<tt class="descname">-fsignaling-math</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-signaling-math</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsignaling-math" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fsigned-bitfields">
+<tt class="descname">-fsigned-bitfields</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsigned-bitfields" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fsigned-char">
+<tt class="descname">-fsigned-char</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-signed-char</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--signed-char</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsigned-char" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fsigned-zeros">
+<tt class="descname">-fsigned-zeros</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-signed-zeros</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsigned-zeros" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fsized-deallocation">
+<tt class="descname">-fsized-deallocation</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-sized-deallocation</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsized-deallocation" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable C++14 sized global deallocation functions</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsjlj-exceptions">
+<tt class="descname">-fsjlj-exceptions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsjlj-exceptions" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use SjLj style exceptions</p>
+<dl class="option">
+<dt id="cmdoption-clang-fslp-vectorize">
+<tt class="descname">-fslp-vectorize</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-slp-vectorize</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-ftree-slp-vectorize</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fslp-vectorize" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable the superword-level parallelism vectorization passes</p>
+<dl class="option">
+<dt id="cmdoption-clang-fspell-checking">
+<tt class="descname">-fspell-checking</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-spell-checking</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fspell-checking" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fspell-checking-limit">
+<tt class="descname">-fspell-checking-limit</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fspell-checking-limit" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fsplit-dwarf-inlining">
+<tt class="descname">-fsplit-dwarf-inlining</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-split-dwarf-inlining</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsplit-dwarf-inlining" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Place debug types in their own section (ELF Only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsplit-stack">
+<tt class="descname">-fsplit-stack</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsplit-stack" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fstack-protector">
+<tt class="descname">-fstack-protector</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-stack-protector</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fstack-protector" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable stack protectors for functions potentially vulnerable to stack smashing</p>
+<dl class="option">
+<dt id="cmdoption-clang-fstack-protector-all">
+<tt class="descname">-fstack-protector-all</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fstack-protector-all" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Force the usage of stack protectors for all functions</p>
+<dl class="option">
+<dt id="cmdoption-clang-fstack-protector-strong">
+<tt class="descname">-fstack-protector-strong</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fstack-protector-strong" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use a strong heuristic to apply stack protectors to functions</p>
+<dl class="option">
+<dt id="cmdoption-clang-fstandalone-debug">
+<tt class="descname">-fstandalone-debug</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-limit-debug-info</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-standalone-debug</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fstandalone-debug" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Emit full debug info for all types used by the program</p>
+<dl class="option">
+<dt id="cmdoption-clang-fstrict-aliasing">
+<tt class="descname">-fstrict-aliasing</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-strict-aliasing</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fstrict-aliasing" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fstrict-enums">
+<tt class="descname">-fstrict-enums</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-strict-enums</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fstrict-enums" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable optimizations based on the strict definition of an enum’s value range</p>
+<dl class="option">
+<dt id="cmdoption-clang-fstrict-overflow">
+<tt class="descname">-fstrict-overflow</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-strict-overflow</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fstrict-overflow" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fstrict-return">
+<tt class="descname">-fstrict-return</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-strict-return</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fstrict-return" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Always treat control flow paths that fall off the end of a non-void function as unreachable</p>
+<dl class="option">
+<dt id="cmdoption-clang-fstrict-vtable-pointers">
+<tt class="descname">-fstrict-vtable-pointers</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-strict-vtable-pointers</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fstrict-vtable-pointers" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable optimizations based on the strict rules for overwriting polymorphic C++ objects</p>
+<dl class="option">
+<dt id="cmdoption-clang-fstruct-path-tbaa">
+<tt class="descname">-fstruct-path-tbaa</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-struct-path-tbaa</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fstruct-path-tbaa" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ftabstop">
+<tt class="descname">-ftabstop</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-ftabstop" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ftemplate-backtrace-limit">
+<tt class="descname">-ftemplate-backtrace-limit</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-ftemplate-backtrace-limit" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ftemplate-depth-">
+<tt class="descname">-ftemplate-depth-</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-ftemplate-depth-" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ftemplate-depth">
+<tt class="descname">-ftemplate-depth</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-ftemplate-depth" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ftest-coverage">
+<tt class="descname">-ftest-coverage</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ftest-coverage" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fthinlto-index">
+<tt class="descname">-fthinlto-index</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fthinlto-index" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Perform ThinLTO importing using provided function summary index</p>
+<dl class="option">
+<dt id="cmdoption-clang-fthreadsafe-statics">
+<tt class="descname">-fthreadsafe-statics</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-threadsafe-statics</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fthreadsafe-statics" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ftime-report">
+<tt class="descname">-ftime-report</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ftime-report" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ftls-model">
+<tt class="descname">-ftls-model</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-ftls-model" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ftrap-function">
+<tt class="descname">-ftrap-function</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-ftrap-function" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Issue call to specified function rather than a trap instruction</p>
+<dl class="option">
+<dt id="cmdoption-clang-ftrapping-math">
+<tt class="descname">-ftrapping-math</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-trapping-math</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ftrapping-math" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ftrapv">
+<tt class="descname">-ftrapv</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ftrapv" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Trap on integer overflow</p>
+<dl class="option">
+<dt id="cmdoption-clang-ftrapv-handler">
+<tt class="descname">-ftrapv-handler</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-ftrapv-handler" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-ftrapv-handler">
+<tt class="descname">-ftrapv-handler</tt><tt class="descclassname">=<function name></tt><a class="headerlink" href="#cmdoption-clang1-ftrapv-handler" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify the function to be called on overflow</p>
+<dl class="option">
+<dt id="cmdoption-clang-ftrigraphs">
+<tt class="descname">-ftrigraphs</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-trigraphs</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-trigraphs</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--trigraphs</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ftrigraphs" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Process trigraph sequences</p>
+<dl class="option">
+<dt id="cmdoption-clang-funique-section-names">
+<tt class="descname">-funique-section-names</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-unique-section-names</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-funique-section-names" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use unique names for text and data sections (ELF Only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-funit-at-a-time">
+<tt class="descname">-funit-at-a-time</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-unit-at-a-time</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-funit-at-a-time" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-funroll-loops">
+<tt class="descname">-funroll-loops</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-unroll-loops</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-funroll-loops" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Turn on loop unroller</p>
+<dl class="option">
+<dt id="cmdoption-clang-funsafe-math-optimizations">
+<tt class="descname">-funsafe-math-optimizations</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-unsafe-math-optimizations</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-funsafe-math-optimizations" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-funsigned-bitfields">
+<tt class="descname">-funsigned-bitfields</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-funsigned-bitfields" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-funsigned-char">
+<tt class="descname">-funsigned-char</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-unsigned-char</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--unsigned-char</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-funsigned-char" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-funwind-tables">
+<tt class="descname">-funwind-tables</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-unwind-tables</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-funwind-tables" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fuse-cxa-atexit">
+<tt class="descname">-fuse-cxa-atexit</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-use-cxa-atexit</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fuse-cxa-atexit" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fuse-init-array">
+<tt class="descname">-fuse-init-array</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-use-init-array</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fuse-init-array" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use .init_array instead of .ctors</p>
+<dl class="option">
+<dt id="cmdoption-clang-fuse-ld">
+<tt class="descname">-fuse-ld</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fuse-ld" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fuse-line-directives">
+<tt class="descname">-fuse-line-directives</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-use-line-directives</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fuse-line-directives" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fveclib">
+<tt class="descname">-fveclib</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fveclib" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use the given vector functions library</p>
+<dl class="option">
+<dt id="cmdoption-clang-fvectorize">
+<tt class="descname">-fvectorize</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-vectorize</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-ftree-vectorize</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fvectorize" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable the loop vectorization passes</p>
+<dl class="option">
+<dt id="cmdoption-clang-fverbose-asm">
+<tt class="descname">-fverbose-asm</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-verbose-asm</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fverbose-asm" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fvisibility-inlines-hidden">
+<tt class="descname">-fvisibility-inlines-hidden</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fvisibility-inlines-hidden" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Give inline C++ member functions default visibility by default</p>
+<dl class="option">
+<dt id="cmdoption-clang-fvisibility-ms-compat">
+<tt class="descname">-fvisibility-ms-compat</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fvisibility-ms-compat" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Give global types ‘default’ visibility and global functions and variables ‘hidden’ visibility by default</p>
+<dl class="option">
+<dt id="cmdoption-clang-fvisibility">
+<tt class="descname">-fvisibility</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fvisibility" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Set the default symbol visibility for all global declarations</p>
+<dl class="option">
+<dt id="cmdoption-clang-fwhole-program-vtables">
+<tt class="descname">-fwhole-program-vtables</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-whole-program-vtables</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fwhole-program-vtables" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enables whole-program vtable optimization. Requires -flto</p>
+<dl class="option">
+<dt id="cmdoption-clang-fwrapv">
+<tt class="descname">-fwrapv</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-wrapv</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fwrapv" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Treat signed integer overflow as two’s complement</p>
+<dl class="option">
+<dt id="cmdoption-clang-fwritable-strings">
+<tt class="descname">-fwritable-strings</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fwritable-strings" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Store string literals as writable data</p>
+<dl class="option">
+<dt id="cmdoption-clang-fxray-always-emit-customevents">
+<tt class="descname">-fxray-always-emit-customevents</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-xray-always-emit-customevents</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fxray-always-emit-customevents" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Determine whether to always emit __xray_customevent(...) calls even if the function it appears in is not always instrumented.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fxray-always-instrument">
+<tt class="descname">-fxray-always-instrument</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fxray-always-instrument" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Filename defining the whitelist for imbuing the ‘always instrument’ XRay attribute.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fxray-instruction-threshold">
+<tt class="descname">-fxray-instruction-threshold</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-fxray-instruction-threshold" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-fxray-instruction-threshold">
+<tt class="descname">-fxray-instruction-threshold</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang1-fxray-instruction-threshold" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Sets the minimum function size to instrument with XRay</p>
+<dl class="option">
+<dt id="cmdoption-clang-fxray-instrument">
+<tt class="descname">-fxray-instrument</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-xray-instrument</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fxray-instrument" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate XRay instrumentation sleds on function entry and exit</p>
+<dl class="option">
+<dt id="cmdoption-clang-fxray-never-instrument">
+<tt class="descname">-fxray-never-instrument</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fxray-never-instrument" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Filename defining the whitelist for imbuing the ‘never instrument’ XRay attribute.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fzero-initialized-in-bss">
+<tt class="descname">-fzero-initialized-in-bss</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-zero-initialized-in-bss</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fzero-initialized-in-bss" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fzvector">
+<tt class="descname">-fzvector</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-zvector</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mzvector</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fzvector" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable System z vector language extension</p>
+<dl class="option">
+<dt id="cmdoption-clang-pedantic">
+<tt class="descname">-pedantic</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--pedantic</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-no-pedantic</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--no-pedantic</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-pedantic" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-pedantic-errors">
+<tt class="descname">-pedantic-errors</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--pedantic-errors</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-pedantic-errors" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<div class="section" id="opencl-flags">
+<h4><a class="toc-backref" href="#id11">OpenCL flags</a><a class="headerlink" href="#opencl-flags" title="Permalink to this headline">¶</a></h4>
+<dl class="option">
+<dt id="cmdoption-clang-cl-denorms-are-zero">
+<tt class="descname">-cl-denorms-are-zero</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-cl-denorms-are-zero" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>OpenCL only. Allow denormals to be flushed to zero.</p>
+<dl class="option">
+<dt id="cmdoption-clang-cl-fast-relaxed-math">
+<tt class="descname">-cl-fast-relaxed-math</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-cl-fast-relaxed-math" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>OpenCL only. Sets -cl-finite-math-only and -cl-unsafe-math-optimizations, and defines __FAST_RELAXED_MATH__.</p>
+<dl class="option">
+<dt id="cmdoption-clang-cl-finite-math-only">
+<tt class="descname">-cl-finite-math-only</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-cl-finite-math-only" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>OpenCL only. Allow floating-point optimizations that assume arguments and results are not NaNs or +-Inf.</p>
+<dl class="option">
+<dt id="cmdoption-clang-cl-fp32-correctly-rounded-divide-sqrt">
+<tt class="descname">-cl-fp32-correctly-rounded-divide-sqrt</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-cl-fp32-correctly-rounded-divide-sqrt" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>OpenCL only. Specify that single precision floating-point divide and sqrt used in the program source are correctly rounded.</p>
+<dl class="option">
+<dt id="cmdoption-clang-cl-kernel-arg-info">
+<tt class="descname">-cl-kernel-arg-info</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-cl-kernel-arg-info" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>OpenCL only. Generate kernel argument metadata.</p>
+<dl class="option">
+<dt id="cmdoption-clang-cl-mad-enable">
+<tt class="descname">-cl-mad-enable</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-cl-mad-enable" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>OpenCL only. Allow use of less precise MAD computations in the generated binary.</p>
+<dl class="option">
+<dt id="cmdoption-clang-cl-no-signed-zeros">
+<tt class="descname">-cl-no-signed-zeros</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-cl-no-signed-zeros" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>OpenCL only. Allow use of less precise no signed zeros computations in the generated binary.</p>
+<dl class="option">
+<dt id="cmdoption-clang-cl-opt-disable">
+<tt class="descname">-cl-opt-disable</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-cl-opt-disable" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>OpenCL only. This option disables all optimizations. By default optimizations are enabled.</p>
+<dl class="option">
+<dt id="cmdoption-clang-cl-single-precision-constant">
+<tt class="descname">-cl-single-precision-constant</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-cl-single-precision-constant" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>OpenCL only. Treat double precision floating-point constant as single precision constant.</p>
+<dl class="option">
+<dt id="cmdoption-clang-cl-std">
+<tt class="descname">-cl-std</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-cl-std" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>OpenCL language standard to compile for.</p>
+<dl class="option">
+<dt id="cmdoption-clang-cl-strict-aliasing">
+<tt class="descname">-cl-strict-aliasing</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-cl-strict-aliasing" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>OpenCL only. This option is added for compatibility with OpenCL 1.0.</p>
+<dl class="option">
+<dt id="cmdoption-clang-cl-unsafe-math-optimizations">
+<tt class="descname">-cl-unsafe-math-optimizations</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-cl-unsafe-math-optimizations" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>OpenCL only. Allow unsafe floating-point optimizations. Also implies -cl-no-signed-zeros and -cl-mad-enable.</p>
+</div>
+</div>
+<div class="section" id="target-dependent-compilation-options">
+<h3><a class="toc-backref" href="#id12">Target-dependent compilation options</a><a class="headerlink" href="#target-dependent-compilation-options" title="Permalink to this headline">¶</a></h3>
+<dl class="option">
+<dt id="cmdoption-clang-G">
+<tt class="descname">-G</tt><tt class="descclassname"><size></tt><tt class="descclassname">, </tt><tt class="descname">-G</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">-msmall-data-threshold</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-G" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Put objects of at most <size> bytes into small data section (MIPS / Hexagon)</p>
+<dl class="option">
+<dt id="cmdoption-clang-m16">
+<tt class="descname">-m16</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-m16" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-m32">
+<tt class="descname">-m32</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-m32" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-m64">
+<tt class="descname">-m64</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-m64" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mabi">
+<tt class="descname">-mabi</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mabi" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mabicalls">
+<tt class="descname">-mabicalls</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-abicalls</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mabicalls" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable SVR4-style position-independent code (Mips only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mabs">
+<tt class="descname">-mabs</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mabs" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-malign-double">
+<tt class="descname">-malign-double</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-malign-double" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Align doubles to two words in structs (x86 only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-march">
+<tt class="descname">-march</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-march" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-masm">
+<tt class="descname">-masm</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-masm" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mbackchain">
+<tt class="descname">-mbackchain</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-backchain</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mbackchain" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Link stack frames through backchain on System Z</p>
+<dl class="option">
+<dt id="cmdoption-clang-mcheck-zero-division">
+<tt class="descname">-mcheck-zero-division</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-check-zero-division</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mcheck-zero-division" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mcmodel">
+<tt class="descname">-mcmodel</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mcmodel" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mcompact-branches">
+<tt class="descname">-mcompact-branches</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mcompact-branches" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mconsole">
+<tt class="descname">-mconsole</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-mconsole" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mcpu">
+<tt class="descname">-mcpu</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">-mv4</tt><tt class="descclassname"> (equivalent to -mcpu=hexagonv4)</tt><tt class="descclassname">, </tt><tt class="descname">-mv5</tt><tt class="descclassname"> (equivalent to -mcpu=hexagonv5)</tt><tt class="descclassname">, </tt><tt class="descname">-mv55</tt><tt class="descclassname"> (equivalent to -mcpu=hexagonv55)</tt><tt class="descclassname">, </tt><tt class="descname">-mv60</tt><tt class="descclassname"> (equivalent to -mcpu=hexagonv60)</tt><tt class="descclassname">, </tt><tt class="descname">-mv62</tt><tt class="descclassname"> (equivalent to -mcpu=hexagonv62)</tt><tt class="descclassname">, </tt><tt class="descname">-mv65</tt><tt class="descclassname"> (equivalent to -mcpu=hexagonv65)</tt><a class="headerlink" href="#cmdoption-clang-mcpu" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mdefault-build-attributes">
+<tt class="descname">-mdefault-build-attributes</tt><tt class="descclassname"><arg></tt><tt class="descclassname">, </tt><tt class="descname">-mno-default-build-attributes</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-mdefault-build-attributes" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mdll">
+<tt class="descname">-mdll</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-mdll" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mdouble-float">
+<tt class="descname">-mdouble-float</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mdouble-float" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mdsp">
+<tt class="descname">-mdsp</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-dsp</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mdsp" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mdspr2">
+<tt class="descname">-mdspr2</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-dspr2</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mdspr2" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mdynamic-no-pic">
+<tt class="descname">-mdynamic-no-pic</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-mdynamic-no-pic" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-meabi">
+<tt class="descname">-meabi</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-meabi" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Set EABI type, e.g. 4, 5 or gnu (default depends on triple)</p>
+<dl class="option">
+<dt id="cmdoption-clang-membedded-data">
+<tt class="descname">-membedded-data</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-embedded-data</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-membedded-data" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Place constants in the .rodata section instead of the .sdata section even if they meet the -G <size> threshold (MIPS)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mextern-sdata">
+<tt class="descname">-mextern-sdata</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-extern-sdata</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mextern-sdata" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Assume that externally defined data is in the small data if it meets the -G <size> threshold (MIPS)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mfentry">
+<tt class="descname">-mfentry</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mfentry" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Insert calls to fentry at function entry (x86 only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mfloat-abi">
+<tt class="descname">-mfloat-abi</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mfloat-abi" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mfp32">
+<tt class="descname">-mfp32</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mfp32" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use 32-bit floating point registers (MIPS only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mfp64">
+<tt class="descname">-mfp64</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mfp64" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use 64-bit floating point registers (MIPS only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mfpmath">
+<tt class="descname">-mfpmath</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mfpmath" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mfpu">
+<tt class="descname">-mfpu</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mfpu" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mglobal-merge">
+<tt class="descname">-mglobal-merge</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-global-merge</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mglobal-merge" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable merging of globals</p>
+<dl class="option">
+<dt id="cmdoption-clang-mgpopt">
+<tt class="descname">-mgpopt</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-gpopt</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mgpopt" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use GP relative accesses for symbols known to be in a small data section (MIPS)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mhard-float">
+<tt class="descname">-mhard-float</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mhard-float" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mhwdiv">
+<tt class="descname">-mhwdiv</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--mhwdiv</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--mhwdiv</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mhwdiv" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-miamcu">
+<tt class="descname">-miamcu</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-iamcu</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-miamcu" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use Intel MCU ABI</p>
+<dl class="option">
+<dt id="cmdoption-clang-mimplicit-float">
+<tt class="descname">-mimplicit-float</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-implicit-float</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mimplicit-float" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mimplicit-it">
+<tt class="descname">-mimplicit-it</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mimplicit-it" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mincremental-linker-compatible">
+<tt class="descname">-mincremental-linker-compatible</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-incremental-linker-compatible</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mincremental-linker-compatible" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>(integrated-as) Emit an object file which can be used with an incremental linker</p>
+<dl class="option">
+<dt id="cmdoption-clang-miphoneos-version-min">
+<tt class="descname">-miphoneos-version-min</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">-mios-version-min</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-miphoneos-version-min" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mips16">
+<tt class="descname">-mips16</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mips16" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mkernel">
+<tt class="descname">-mkernel</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mkernel" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mldc1-sdc1">
+<tt class="descname">-mldc1-sdc1</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-ldc1-sdc1</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mldc1-sdc1" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mlocal-sdata">
+<tt class="descname">-mlocal-sdata</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-local-sdata</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mlocal-sdata" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Extend the -G behaviour to object local data (MIPS)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mlong-calls">
+<tt class="descname">-mlong-calls</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-long-calls</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mlong-calls" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate branches with extended addressability, usually via indirect jumps.</p>
+<dl class="option">
+<dt id="cmdoption-clang-mmacosx-version-min">
+<tt class="descname">-mmacosx-version-min</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">-mmacos-version-min</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mmacosx-version-min" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Set Mac OS X deployment target</p>
+<dl class="option">
+<dt id="cmdoption-clang-mmadd4">
+<tt class="descname">-mmadd4</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-madd4</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mmadd4" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable the generation of 4-operand madd.s, madd.d and related instructions.</p>
+<dl class="option">
+<dt id="cmdoption-clang-mmcu">
+<tt class="descname">-mmcu</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mmcu" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mmicromips">
+<tt class="descname">-mmicromips</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-micromips</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mmicromips" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mms-bitfields">
+<tt class="descname">-mms-bitfields</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-ms-bitfields</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mms-bitfields" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Set the default structure layout to be compatible with the Microsoft compiler standard</p>
+<dl class="option">
+<dt id="cmdoption-clang-mmsa">
+<tt class="descname">-mmsa</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-msa</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mmsa" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable MSA ASE (MIPS only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mmt">
+<tt class="descname">-mmt</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-mt</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mmt" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable MT ASE (MIPS only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mnan">
+<tt class="descname">-mnan</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mnan" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mno-mips16">
+<tt class="descname">-mno-mips16</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mno-mips16" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-momit-leaf-frame-pointer">
+<tt class="descname">-momit-leaf-frame-pointer</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-omit-leaf-frame-pointer</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-momit-leaf-frame-pointer" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Omit frame pointer setup for leaf functions</p>
+<dl class="option">
+<dt id="cmdoption-clang-moslib">
+<tt class="descname">-moslib</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-moslib" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mpie-copy-relocations">
+<tt class="descname">-mpie-copy-relocations</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-pie-copy-relocations</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mpie-copy-relocations" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use copy relocations support for PIE builds</p>
+<dl class="option">
+<dt id="cmdoption-clang-mprefer-vector-width">
+<tt class="descname">-mprefer-vector-width</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mprefer-vector-width" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Specifies preferred vector width for auto-vectorization. Defaults to ‘none’ which allows target specific decisions.</p>
+<dl class="option">
+<dt id="cmdoption-clang-mqdsp6-compat">
+<tt class="descname">-mqdsp6-compat</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mqdsp6-compat" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable hexagon-qdsp6 backward compatibility</p>
+<dl class="option">
+<dt id="cmdoption-clang-mrecip">
+<tt class="descname">-mrecip</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mrecip" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-mrecip">
+<tt class="descname">-mrecip</tt><tt class="descclassname">=<arg1>,<arg2>...</tt><a class="headerlink" href="#cmdoption-clang1-mrecip" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mred-zone">
+<tt class="descname">-mred-zone</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-red-zone</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mred-zone" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mregparm">
+<tt class="descname">-mregparm</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mregparm" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mrelax-all">
+<tt class="descname">-mrelax-all</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-relax-all</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mrelax-all" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>(integrated-as) Relax all machine instructions</p>
+<dl class="option">
+<dt id="cmdoption-clang-mrtd">
+<tt class="descname">-mrtd</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-rtd</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mrtd" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Make StdCall calling convention the default</p>
+<dl class="option">
+<dt id="cmdoption-clang-msingle-float">
+<tt class="descname">-msingle-float</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-msingle-float" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-msoft-float">
+<tt class="descname">-msoft-float</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-soft-float</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-msoft-float" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use software floating point</p>
+<dl class="option">
+<dt id="cmdoption-clang-mstack-alignment">
+<tt class="descname">-mstack-alignment</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mstack-alignment" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Set the stack alignment</p>
+<dl class="option">
+<dt id="cmdoption-clang-mstack-probe-size">
+<tt class="descname">-mstack-probe-size</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mstack-probe-size" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Set the stack probe size</p>
+<dl class="option">
+<dt id="cmdoption-clang-mstackrealign">
+<tt class="descname">-mstackrealign</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-stackrealign</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mstackrealign" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Force realign the stack at entry to every function</p>
+<dl class="option">
+<dt id="cmdoption-clang-mthread-model">
+<tt class="descname">-mthread-model</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-mthread-model" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>The thread model to use, e.g. posix, single (posix by default)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mthreads">
+<tt class="descname">-mthreads</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-mthreads" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mthumb">
+<tt class="descname">-mthumb</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-thumb</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mthumb" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mtune">
+<tt class="descname">-mtune</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mtune" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mtvos-version-min">
+<tt class="descname">-mtvos-version-min</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">-mappletvos-version-min</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mtvos-version-min" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-municode">
+<tt class="descname">-municode</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-municode" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mvx">
+<tt class="descname">-mvx</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-vx</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mvx" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mwarn-nonportable-cfstrings">
+<tt class="descname">-mwarn-nonportable-cfstrings</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-warn-nonportable-cfstrings</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mwarn-nonportable-cfstrings" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mwatchos-version-min">
+<tt class="descname">-mwatchos-version-min</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mwatchos-version-min" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mwindows">
+<tt class="descname">-mwindows</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-mwindows" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mx32">
+<tt class="descname">-mx32</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mx32" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mxgot">
+<tt class="descname">-mxgot</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-xgot</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mxgot" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<div class="section" id="aarch64">
+<h4><a class="toc-backref" href="#id13">AARCH64</a><a class="headerlink" href="#aarch64" title="Permalink to this headline">¶</a></h4>
+<dl class="option">
+<dt id="cmdoption-clang-ffixed-x18">
+<tt class="descname">-ffixed-x18</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ffixed-x18" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Reserve the x18 register (AArch64 only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mfix-cortex-a53-835769">
+<tt class="descname">-mfix-cortex-a53-835769</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-fix-cortex-a53-835769</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mfix-cortex-a53-835769" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Workaround Cortex-A53 erratum 835769 (AArch64 only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mgeneral-regs-only">
+<tt class="descname">-mgeneral-regs-only</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mgeneral-regs-only" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate code which only uses the general purpose registers (AArch64 only)</p>
+</div>
+<div class="section" id="amdgpu">
+<h4><a class="toc-backref" href="#id14">AMDGPU</a><a class="headerlink" href="#amdgpu" title="Permalink to this headline">¶</a></h4>
+<dl class="option">
+<dt id="cmdoption-clang-mxnack">
+<tt class="descname">-mxnack</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-xnack</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mxnack" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable XNACK (AMDGPU only)</p>
+</div>
+<div class="section" id="arm">
+<h4><a class="toc-backref" href="#id15">ARM</a><a class="headerlink" href="#arm" title="Permalink to this headline">¶</a></h4>
+<dl class="option">
+<dt id="cmdoption-clang-ffixed-r9">
+<tt class="descname">-ffixed-r9</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ffixed-r9" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Reserve the r9 register (ARM only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mcrc">
+<tt class="descname">-mcrc</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mcrc" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Allow use of CRC instructions (ARM only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mexecute-only">
+<tt class="descname">-mexecute-only</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-execute-only</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mpure-code</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mexecute-only" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Disallow generation of data access to code sections (ARM only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mno-movt">
+<tt class="descname">-mno-movt</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mno-movt" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Disallow use of movt/movw pairs (ARM only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mno-neg-immediates">
+<tt class="descname">-mno-neg-immediates</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mno-neg-immediates" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Disallow converting instructions with negative immediates to their negation or inversion.</p>
+<dl class="option">
+<dt id="cmdoption-clang-mnocrc">
+<tt class="descname">-mnocrc</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mnocrc" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Disallow use of CRC instructions (ARM only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mrestrict-it">
+<tt class="descname">-mrestrict-it</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-restrict-it</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mrestrict-it" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Disallow generation of deprecated IT blocks for ARMv8. It is on by default for ARMv8 Thumb mode.</p>
+<dl class="option">
+<dt id="cmdoption-clang-mtp">
+<tt class="descname">-mtp</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mtp" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Read thread pointer from coprocessor register (ARM only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-munaligned-access">
+<tt class="descname">-munaligned-access</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-unaligned-access</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-munaligned-access" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Allow memory accesses to be unaligned (AArch32/AArch64 only)</p>
+</div>
+<div class="section" id="hexagon">
+<h4><a class="toc-backref" href="#id16">Hexagon</a><a class="headerlink" href="#hexagon" title="Permalink to this headline">¶</a></h4>
+<dl class="option">
+<dt id="cmdoption-clang-mieee-rnd-near">
+<tt class="descname">-mieee-rnd-near</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mieee-rnd-near" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+</div>
+<div class="section" id="id1">
+<h4><a class="toc-backref" href="#id17">Hexagon</a><a class="headerlink" href="#id1" title="Permalink to this headline">¶</a></h4>
+<dl class="option">
+<dt id="cmdoption-clang-mhvx">
+<tt class="descname">-mhvx</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-hvx</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mhvx" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable Hexagon Vector eXtensions</p>
+<dl class="option">
+<dt id="cmdoption-clang-mhvx-double">
+<tt class="descname">-mhvx-double</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-hvx-double</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mhvx-double" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable Hexagon Double Vector eXtensions</p>
+<dl class="option">
+<dt id="cmdoption-clang-mhvx-length">
+<tt class="descname">-mhvx-length</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mhvx-length" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Set Hexagon Vector Length</p>
+<dl class="option">
+<dt id="cmdoption-clang1-mhvx">
+<tt class="descname">-mhvx</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang1-mhvx" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable Hexagon Vector eXtensions</p>
+</div>
+<div class="section" id="powerpc">
+<h4><a class="toc-backref" href="#id18">PowerPC</a><a class="headerlink" href="#powerpc" title="Permalink to this headline">¶</a></h4>
+<dl class="option">
+<dt id="cmdoption-clang-maltivec">
+<tt class="descname">-maltivec</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-altivec</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-maltivec" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mcmpb">
+<tt class="descname">-mcmpb</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-cmpb</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mcmpb" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mcrbits">
+<tt class="descname">-mcrbits</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-crbits</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mcrbits" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mcrypto">
+<tt class="descname">-mcrypto</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-crypto</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mcrypto" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mdirect-move">
+<tt class="descname">-mdirect-move</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-direct-move</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mdirect-move" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mfloat128">
+<tt class="descname">-mfloat128</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-float128</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mfloat128" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mfprnd">
+<tt class="descname">-mfprnd</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-fprnd</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mfprnd" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mhtm">
+<tt class="descname">-mhtm</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-htm</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mhtm" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-minvariant-function-descriptors">
+<tt class="descname">-minvariant-function-descriptors</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-invariant-function-descriptors</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-minvariant-function-descriptors" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-misel">
+<tt class="descname">-misel</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-isel</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-misel" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mlongcall">
+<tt class="descname">-mlongcall</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-longcall</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mlongcall" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mmfocrf">
+<tt class="descname">-mmfocrf</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mmfcrf</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-mfocrf</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mmfocrf" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mpopcntd">
+<tt class="descname">-mpopcntd</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-popcntd</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mpopcntd" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mpower8-vector">
+<tt class="descname">-mpower8-vector</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-power8-vector</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mpower8-vector" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mpower9-vector">
+<tt class="descname">-mpower9-vector</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-power9-vector</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mpower9-vector" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mqpx">
+<tt class="descname">-mqpx</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-qpx</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mqpx" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mvsx">
+<tt class="descname">-mvsx</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-vsx</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mvsx" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+</div>
+<div class="section" id="webassembly">
+<h4><a class="toc-backref" href="#id19">WebAssembly</a><a class="headerlink" href="#webassembly" title="Permalink to this headline">¶</a></h4>
+<dl class="option">
+<dt id="cmdoption-clang-mnontrapping-fptoint">
+<tt class="descname">-mnontrapping-fptoint</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-nontrapping-fptoint</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mnontrapping-fptoint" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-msimd128">
+<tt class="descname">-msimd128</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-simd128</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-msimd128" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+</div>
+<div class="section" id="x86">
+<h4><a class="toc-backref" href="#id20">X86</a><a class="headerlink" href="#x86" title="Permalink to this headline">¶</a></h4>
+<dl class="option">
+<dt id="cmdoption-clang-m3dnow">
+<tt class="descname">-m3dnow</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-3dnow</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-m3dnow" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-m3dnowa">
+<tt class="descname">-m3dnowa</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-3dnowa</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-m3dnowa" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-madx">
+<tt class="descname">-madx</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-adx</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-madx" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-maes">
+<tt class="descname">-maes</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-aes</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-maes" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mavx">
+<tt class="descname">-mavx</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-avx</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mavx" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mavx2">
+<tt class="descname">-mavx2</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-avx2</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mavx2" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mavx512bitalg">
+<tt class="descname">-mavx512bitalg</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-avx512bitalg</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mavx512bitalg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mavx512bw">
+<tt class="descname">-mavx512bw</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-avx512bw</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mavx512bw" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mavx512cd">
+<tt class="descname">-mavx512cd</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-avx512cd</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mavx512cd" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mavx512dq">
+<tt class="descname">-mavx512dq</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-avx512dq</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mavx512dq" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mavx512er">
+<tt class="descname">-mavx512er</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-avx512er</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mavx512er" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mavx512f">
+<tt class="descname">-mavx512f</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-avx512f</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mavx512f" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mavx512ifma">
+<tt class="descname">-mavx512ifma</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-avx512ifma</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mavx512ifma" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mavx512pf">
+<tt class="descname">-mavx512pf</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-avx512pf</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mavx512pf" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mavx512vbmi">
+<tt class="descname">-mavx512vbmi</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-avx512vbmi</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mavx512vbmi" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mavx512vbmi2">
+<tt class="descname">-mavx512vbmi2</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-avx512vbmi2</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mavx512vbmi2" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mavx512vl">
+<tt class="descname">-mavx512vl</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-avx512vl</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mavx512vl" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mavx512vnni">
+<tt class="descname">-mavx512vnni</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-avx512vnni</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mavx512vnni" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mavx512vpopcntdq">
+<tt class="descname">-mavx512vpopcntdq</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-avx512vpopcntdq</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mavx512vpopcntdq" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mbmi">
+<tt class="descname">-mbmi</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-bmi</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mbmi" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mbmi2">
+<tt class="descname">-mbmi2</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-bmi2</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mbmi2" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mclflushopt">
+<tt class="descname">-mclflushopt</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-clflushopt</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mclflushopt" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mclwb">
+<tt class="descname">-mclwb</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-clwb</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mclwb" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mclzero">
+<tt class="descname">-mclzero</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-clzero</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mclzero" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mcx16">
+<tt class="descname">-mcx16</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-cx16</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mcx16" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mf16c">
+<tt class="descname">-mf16c</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-f16c</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mf16c" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mfma">
+<tt class="descname">-mfma</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-fma</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mfma" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mfma4">
+<tt class="descname">-mfma4</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-fma4</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mfma4" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mfsgsbase">
+<tt class="descname">-mfsgsbase</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-fsgsbase</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mfsgsbase" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mfxsr">
+<tt class="descname">-mfxsr</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-fxsr</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mfxsr" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mgfni">
+<tt class="descname">-mgfni</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-gfni</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mgfni" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mibt">
+<tt class="descname">-mibt</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-ibt</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mibt" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mlwp">
+<tt class="descname">-mlwp</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-lwp</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mlwp" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mlzcnt">
+<tt class="descname">-mlzcnt</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-lzcnt</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mlzcnt" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mmmx">
+<tt class="descname">-mmmx</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-mmx</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mmmx" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mmovbe">
+<tt class="descname">-mmovbe</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-movbe</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mmovbe" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mmpx">
+<tt class="descname">-mmpx</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-mpx</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mmpx" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mmwaitx">
+<tt class="descname">-mmwaitx</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-mwaitx</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mmwaitx" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mpclmul">
+<tt class="descname">-mpclmul</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-pclmul</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mpclmul" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mpku">
+<tt class="descname">-mpku</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-pku</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mpku" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mpopcnt">
+<tt class="descname">-mpopcnt</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-popcnt</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mpopcnt" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mprefetchwt1">
+<tt class="descname">-mprefetchwt1</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-prefetchwt1</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mprefetchwt1" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mprfchw">
+<tt class="descname">-mprfchw</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-prfchw</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mprfchw" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mrdrnd">
+<tt class="descname">-mrdrnd</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-rdrnd</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mrdrnd" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mrdseed">
+<tt class="descname">-mrdseed</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-rdseed</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mrdseed" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mretpoline">
+<tt class="descname">-mretpoline</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-retpoline</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mretpoline" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mretpoline-external-thunk">
+<tt class="descname">-mretpoline-external-thunk</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-retpoline-external-thunk</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mretpoline-external-thunk" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mrtm">
+<tt class="descname">-mrtm</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-rtm</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mrtm" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-msgx">
+<tt class="descname">-msgx</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-sgx</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-msgx" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-msha">
+<tt class="descname">-msha</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-sha</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-msha" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mshstk">
+<tt class="descname">-mshstk</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-shstk</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mshstk" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-msse">
+<tt class="descname">-msse</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-sse</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-msse" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-msse2">
+<tt class="descname">-msse2</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-sse2</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-msse2" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-msse3">
+<tt class="descname">-msse3</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-sse3</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-msse3" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-msse4">
+<tt class="descname">-msse4</tt><tt class="descclassname">.1</tt><tt class="descclassname">, </tt><tt class="descname">-mno-sse4</tt><tt class="descclassname">.1</tt><a class="headerlink" href="#cmdoption-clang-msse4" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-msse4">
+<tt class="descname">-msse4</tt><tt class="descclassname">.2</tt><tt class="descclassname">, </tt><tt class="descname">-mno-sse4</tt><tt class="descclassname">.2</tt><tt class="descclassname">, </tt><tt class="descname">-msse4</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang1-msse4" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-msse4a">
+<tt class="descname">-msse4a</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-sse4a</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-msse4a" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mssse3">
+<tt class="descname">-mssse3</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-ssse3</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mssse3" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mtbm">
+<tt class="descname">-mtbm</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-tbm</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mtbm" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mvaes">
+<tt class="descname">-mvaes</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-vaes</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mvaes" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mvpclmulqdq">
+<tt class="descname">-mvpclmulqdq</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-vpclmulqdq</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mvpclmulqdq" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mx87">
+<tt class="descname">-mx87</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-m80387</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-x87</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mx87" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mxop">
+<tt class="descname">-mxop</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-xop</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mxop" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mxsave">
+<tt class="descname">-mxsave</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-xsave</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mxsave" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mxsavec">
+<tt class="descname">-mxsavec</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-xsavec</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mxsavec" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mxsaveopt">
+<tt class="descname">-mxsaveopt</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-xsaveopt</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mxsaveopt" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mxsaves">
+<tt class="descname">-mxsaves</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-xsaves</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mxsaves" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+</div>
+</div>
+<div class="section" id="optimization-level">
+<h3><a class="toc-backref" href="#id21">Optimization level</a><a class="headerlink" href="#optimization-level" title="Permalink to this headline">¶</a></h3>
+<p>Flags controlling how much optimization should be performed.</p>
+<dl class="option">
+<dt id="cmdoption-clang-O">
+<tt class="descname">-O</tt><tt class="descclassname"><arg></tt><tt class="descclassname">, </tt><tt class="descname">-O</tt><tt class="descclassname"> (equivalent to -O2)</tt><tt class="descclassname">, </tt><tt class="descname">--optimize</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--optimize</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-O" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-Ofast">
+<tt class="descname">-Ofast</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-Ofast" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+</div>
+<div class="section" id="debug-information-generation">
+<h3><a class="toc-backref" href="#id22">Debug information generation</a><a class="headerlink" href="#debug-information-generation" title="Permalink to this headline">¶</a></h3>
+<p>Flags controlling how much and what kind of debug information should be
+generated.</p>
+<div class="section" id="kind-and-level-of-debug-information">
+<h4><a class="toc-backref" href="#id23">Kind and level of debug information</a><a class="headerlink" href="#kind-and-level-of-debug-information" title="Permalink to this headline">¶</a></h4>
+<dl class="option">
+<dt id="cmdoption-clang-g">
+<tt class="descname">-g</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--debug</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--debug</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-g" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate source-level debug information</p>
+<dl class="option">
+<dt id="cmdoption-clang-gdwarf-2">
+<tt class="descname">-gdwarf-2</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gdwarf-2" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate source-level debug information with dwarf version 2</p>
+<dl class="option">
+<dt id="cmdoption-clang-gdwarf-3">
+<tt class="descname">-gdwarf-3</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gdwarf-3" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate source-level debug information with dwarf version 3</p>
+<dl class="option">
+<dt id="cmdoption-clang-gdwarf-4">
+<tt class="descname">-gdwarf-4</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-gdwarf</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gdwarf-4" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate source-level debug information with dwarf version 4</p>
+<dl class="option">
+<dt id="cmdoption-clang-gdwarf-5">
+<tt class="descname">-gdwarf-5</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gdwarf-5" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate source-level debug information with dwarf version 5</p>
+<dl class="option">
+<dt id="cmdoption-clang-gfull">
+<tt class="descname">-gfull</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gfull" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-gused">
+<tt class="descname">-gused</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gused" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<div class="section" id="debug-level">
+<h5><a class="toc-backref" href="#id24">Debug level</a><a class="headerlink" href="#debug-level" title="Permalink to this headline">¶</a></h5>
+<dl class="option">
+<dt id="cmdoption-clang-g0">
+<tt class="descname">-g0</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-g0" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-g2">
+<tt class="descname">-g2</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-g2" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-g3">
+<tt class="descname">-g3</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-g3" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ggdb0">
+<tt class="descname">-ggdb0</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ggdb0" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ggdb1">
+<tt class="descname">-ggdb1</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ggdb1" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ggdb2">
+<tt class="descname">-ggdb2</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ggdb2" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ggdb3">
+<tt class="descname">-ggdb3</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ggdb3" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-gline-tables-only">
+<tt class="descname">-gline-tables-only</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-g1</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-gmlt</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gline-tables-only" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Emit debug line number tables only</p>
+<dl class="option">
+<dt id="cmdoption-clang-gmodules">
+<tt class="descname">-gmodules</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gmodules" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate debug info with external references to clang modules or precompiled headers</p>
+</div>
+<div class="section" id="debugger-to-tune-debug-information-for">
+<h5><a class="toc-backref" href="#id25">Debugger to tune debug information for</a><a class="headerlink" href="#debugger-to-tune-debug-information-for" title="Permalink to this headline">¶</a></h5>
+<dl class="option">
+<dt id="cmdoption-clang-ggdb">
+<tt class="descname">-ggdb</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ggdb" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-glldb">
+<tt class="descname">-glldb</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-glldb" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-gsce">
+<tt class="descname">-gsce</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gsce" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+</div>
+</div>
+<div class="section" id="debug-information-flags">
+<h4><a class="toc-backref" href="#id26">Debug information flags</a><a class="headerlink" href="#debug-information-flags" title="Permalink to this headline">¶</a></h4>
+<dl class="option">
+<dt id="cmdoption-clang-gcolumn-info">
+<tt class="descname">-gcolumn-info</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-gno-column-info</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gcolumn-info" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-gdwarf-aranges">
+<tt class="descname">-gdwarf-aranges</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gdwarf-aranges" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ggnu-pubnames">
+<tt class="descname">-ggnu-pubnames</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ggnu-pubnames" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-grecord-gcc-switches">
+<tt class="descname">-grecord-gcc-switches</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-gno-record-gcc-switches</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-grecord-gcc-switches" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-gsplit-dwarf">
+<tt class="descname">-gsplit-dwarf</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gsplit-dwarf" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-gstrict-dwarf">
+<tt class="descname">-gstrict-dwarf</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-gno-strict-dwarf</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gstrict-dwarf" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-gz">
+<tt class="descname">-gz</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gz" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>DWARF debug sections compression type</p>
+<dl class="option">
+<dt id="cmdoption-clang1-gz">
+<tt class="descname">-gz</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang1-gz" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>DWARF debug sections compression type</p>
+</div>
+</div>
+</div>
+<div class="section" id="static-analyzer-flags">
+<h2><a class="toc-backref" href="#id27">Static analyzer flags</a><a class="headerlink" href="#static-analyzer-flags" title="Permalink to this headline">¶</a></h2>
+<p>Flags controlling the behavior of the Clang Static Analyzer.</p>
+<dl class="option">
+<dt id="cmdoption-clang-Xanalyzer">
+<tt class="descname">-Xanalyzer</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-Xanalyzer" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Pass <arg> to the static analyzer</p>
+</div>
+<div class="section" id="fortran-compilation-flags">
+<h2><a class="toc-backref" href="#id28">Fortran compilation flags</a><a class="headerlink" href="#fortran-compilation-flags" title="Permalink to this headline">¶</a></h2>
+<p>Flags that will be passed onto the <tt class="docutils literal"><span class="pre">gfortran</span></tt> compiler when Clang is given
+a Fortran input.</p>
+<dl class="option">
+<dt id="cmdoption-clang-A">
+<tt class="descname">-A</tt><tt class="descclassname"><arg></tt><tt class="descclassname">, </tt><tt class="descname">--assert</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--assert</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-A" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-A-">
+<tt class="descname">-A-</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-A-" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-J">
+<tt class="descname">-J</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-J" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-cpp">
+<tt class="descname">-cpp</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-cpp" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-faggressive-function-elimination">
+<tt class="descname">-faggressive-function-elimination</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-aggressive-function-elimination</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-faggressive-function-elimination" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-falign-commons">
+<tt class="descname">-falign-commons</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-align-commons</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-falign-commons" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fall-intrinsics">
+<tt class="descname">-fall-intrinsics</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-all-intrinsics</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fall-intrinsics" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fautomatic">
+<tt class="descname">-fautomatic</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-automatic</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fautomatic" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fbackslash">
+<tt class="descname">-fbackslash</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-backslash</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fbackslash" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fbacktrace">
+<tt class="descname">-fbacktrace</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-backtrace</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fbacktrace" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fblas-matmul-limit">
+<tt class="descname">-fblas-matmul-limit</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fblas-matmul-limit" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fbounds-check">
+<tt class="descname">-fbounds-check</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-bounds-check</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fbounds-check" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fcheck-array-temporaries">
+<tt class="descname">-fcheck-array-temporaries</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-check-array-temporaries</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fcheck-array-temporaries" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fcheck">
+<tt class="descname">-fcheck</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fcheck" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fcoarray">
+<tt class="descname">-fcoarray</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fcoarray" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fconvert">
+<tt class="descname">-fconvert</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fconvert" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fcray-pointer">
+<tt class="descname">-fcray-pointer</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-cray-pointer</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fcray-pointer" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fd-lines-as-code">
+<tt class="descname">-fd-lines-as-code</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-d-lines-as-code</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fd-lines-as-code" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fd-lines-as-comments">
+<tt class="descname">-fd-lines-as-comments</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-d-lines-as-comments</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fd-lines-as-comments" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdefault-double-8">
+<tt class="descname">-fdefault-double-8</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-default-double-8</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdefault-double-8" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdefault-integer-8">
+<tt class="descname">-fdefault-integer-8</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-default-integer-8</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdefault-integer-8" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdefault-real-8">
+<tt class="descname">-fdefault-real-8</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-default-real-8</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdefault-real-8" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdollar-ok">
+<tt class="descname">-fdollar-ok</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-dollar-ok</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdollar-ok" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdump-fortran-optimized">
+<tt class="descname">-fdump-fortran-optimized</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-dump-fortran-optimized</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdump-fortran-optimized" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdump-fortran-original">
+<tt class="descname">-fdump-fortran-original</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-dump-fortran-original</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdump-fortran-original" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdump-parse-tree">
+<tt class="descname">-fdump-parse-tree</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-dump-parse-tree</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdump-parse-tree" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fexternal-blas">
+<tt class="descname">-fexternal-blas</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-external-blas</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fexternal-blas" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ff2c">
+<tt class="descname">-ff2c</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-f2c</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ff2c" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ffixed-form">
+<tt class="descname">-ffixed-form</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-fixed-form</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ffixed-form" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ffixed-line-length-">
+<tt class="descname">-ffixed-line-length-</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-ffixed-line-length-" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ffpe-trap">
+<tt class="descname">-ffpe-trap</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-ffpe-trap" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ffree-form">
+<tt class="descname">-ffree-form</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-free-form</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ffree-form" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ffree-line-length-">
+<tt class="descname">-ffree-line-length-</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-ffree-line-length-" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ffrontend-optimize">
+<tt class="descname">-ffrontend-optimize</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-frontend-optimize</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ffrontend-optimize" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fimplicit-none">
+<tt class="descname">-fimplicit-none</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-implicit-none</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fimplicit-none" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-finit-character">
+<tt class="descname">-finit-character</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-finit-character" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-finit-integer">
+<tt class="descname">-finit-integer</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-finit-integer" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-finit-local-zero">
+<tt class="descname">-finit-local-zero</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-init-local-zero</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-finit-local-zero" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-finit-logical">
+<tt class="descname">-finit-logical</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-finit-logical" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-finit-real">
+<tt class="descname">-finit-real</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-finit-real" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-finteger-4-integer-8">
+<tt class="descname">-finteger-4-integer-8</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-integer-4-integer-8</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-finteger-4-integer-8" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fintrinsic-modules-path">
+<tt class="descname">-fintrinsic-modules-path</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-intrinsic-modules-path</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fintrinsic-modules-path" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fmax-array-constructor">
+<tt class="descname">-fmax-array-constructor</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fmax-array-constructor" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fmax-errors">
+<tt class="descname">-fmax-errors</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fmax-errors" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fmax-identifier-length">
+<tt class="descname">-fmax-identifier-length</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-max-identifier-length</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmax-identifier-length" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fmax-stack-var-size">
+<tt class="descname">-fmax-stack-var-size</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fmax-stack-var-size" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fmax-subrecord-length">
+<tt class="descname">-fmax-subrecord-length</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fmax-subrecord-length" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fmodule-private">
+<tt class="descname">-fmodule-private</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-module-private</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmodule-private" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fpack-derived">
+<tt class="descname">-fpack-derived</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-pack-derived</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fpack-derived" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fprotect-parens">
+<tt class="descname">-fprotect-parens</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-protect-parens</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fprotect-parens" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-frange-check">
+<tt class="descname">-frange-check</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-range-check</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-frange-check" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-freal-4-real-10">
+<tt class="descname">-freal-4-real-10</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-real-4-real-10</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-freal-4-real-10" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-freal-4-real-16">
+<tt class="descname">-freal-4-real-16</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-real-4-real-16</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-freal-4-real-16" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-freal-4-real-8">
+<tt class="descname">-freal-4-real-8</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-real-4-real-8</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-freal-4-real-8" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-freal-8-real-10">
+<tt class="descname">-freal-8-real-10</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-real-8-real-10</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-freal-8-real-10" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-freal-8-real-16">
+<tt class="descname">-freal-8-real-16</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-real-8-real-16</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-freal-8-real-16" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-freal-8-real-4">
+<tt class="descname">-freal-8-real-4</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-real-8-real-4</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-freal-8-real-4" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-frealloc-lhs">
+<tt class="descname">-frealloc-lhs</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-realloc-lhs</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-frealloc-lhs" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-frecord-marker">
+<tt class="descname">-frecord-marker</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-frecord-marker" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-frecursive">
+<tt class="descname">-frecursive</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-recursive</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-frecursive" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-frepack-arrays">
+<tt class="descname">-frepack-arrays</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-repack-arrays</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-frepack-arrays" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fsecond-underscore">
+<tt class="descname">-fsecond-underscore</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-second-underscore</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsecond-underscore" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fsign-zero">
+<tt class="descname">-fsign-zero</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-sign-zero</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsign-zero" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fstack-arrays">
+<tt class="descname">-fstack-arrays</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-stack-arrays</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fstack-arrays" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-funderscoring">
+<tt class="descname">-funderscoring</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-underscoring</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-funderscoring" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fwhole-file">
+<tt class="descname">-fwhole-file</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-whole-file</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fwhole-file" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-nocpp">
+<tt class="descname">-nocpp</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-nocpp" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-static-libgfortran">
+<tt class="descname">-static-libgfortran</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-static-libgfortran" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+</div>
+<div class="section" id="linker-flags">
+<h2><a class="toc-backref" href="#id29">Linker flags</a><a class="headerlink" href="#linker-flags" title="Permalink to this headline">¶</a></h2>
+<p>Flags that are passed on to the linker</p>
+<dl class="option">
+<dt id="cmdoption-clang-L">
+<tt class="descname">-L</tt><tt class="descclassname"><dir></tt><tt class="descclassname">, </tt><tt class="descname">--library-directory</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--library-directory</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-L" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Add directory to library search path</p>
+<dl class="option">
+<dt id="cmdoption-clang-Mach">
+<tt class="descname">-Mach</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-Mach" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-T">
+<tt class="descname">-T</tt><tt class="descclassname"><script></tt><a class="headerlink" href="#cmdoption-clang-T" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify <script> as linker script</p>
+<dl class="option">
+<dt id="cmdoption-clang-Tbss">
+<tt class="descname">-Tbss</tt><tt class="descclassname"><addr></tt><a class="headerlink" href="#cmdoption-clang-Tbss" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Set starting address of BSS to <addr></p>
+<dl class="option">
+<dt id="cmdoption-clang-Tdata">
+<tt class="descname">-Tdata</tt><tt class="descclassname"><addr></tt><a class="headerlink" href="#cmdoption-clang-Tdata" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Set starting address of BSS to <addr></p>
+<dl class="option">
+<dt id="cmdoption-clang-Ttext">
+<tt class="descname">-Ttext</tt><tt class="descclassname"><addr></tt><a class="headerlink" href="#cmdoption-clang-Ttext" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Set starting address of BSS to <addr></p>
+<dl class="option">
+<dt id="cmdoption-clang-Wl">
+<tt class="descname">-Wl</tt><tt class="descclassname">,<arg>,<arg2>...</tt><a class="headerlink" href="#cmdoption-clang-Wl" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Pass the comma separated arguments in <arg> to the linker</p>
+<dl class="option">
+<dt id="cmdoption-clang-X">
+<tt class="descname">-X</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-X" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-Xlinker">
+<tt class="descname">-Xlinker</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--for-linker</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--for-linker</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-Xlinker" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Pass <arg> to the linker</p>
+<dl class="option">
+<dt id="cmdoption-clang1-Z">
+<tt class="descname">-Z</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang1-Z" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-e">
+<tt class="descname">-e</tt><tt class="descclassname"><arg></tt><tt class="descclassname">, </tt><tt class="descname">--entry</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-e" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-filelist">
+<tt class="descname">-filelist</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-filelist" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-l">
+<tt class="descname">-l</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-l" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-r">
+<tt class="descname">-r</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-r" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-rpath">
+<tt class="descname">-rpath</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-rpath" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-s">
+<tt class="descname">-s</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-s" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-t">
+<tt class="descname">-t</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-t" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-u">
+<tt class="descname">-u</tt><tt class="descclassname"><arg></tt><tt class="descclassname">, </tt><tt class="descname">--force-link</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--force-link</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-u" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-undef">
+<tt class="descname">-undef</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-undef" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>undef all system defines</p>
+<dl class="option">
+<dt id="cmdoption-clang-undefined">
+<tt class="descname">-undefined</tt><tt class="descclassname"><arg></tt><tt class="descclassname">, </tt><tt class="descname">--no-undefined</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-undefined" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-z">
+<tt class="descname">-z</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-z" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Pass -z <arg> to the linker</p>
+</div>
+</div>
+
+
+ </div>
+ <div class="bottomnav">
+
+ <p>
+ « <a href="AutomaticReferenceCounting.html">Objective-C Automatic Reference Counting (ARC)</a>
+ ::
+ <a class="uplink" href="index.html">Contents</a>
+ ::
+ <a href="AttributeReference.html">Attributes in Clang</a> »
+ </p>
+
+ </div>
+
+ <div class="footer">
+ © Copyright 2007-2018, The Clang Team.
+ Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/6.0.1/tools/clang/docs/ClangFormat.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/6.0.1/tools/clang/docs/ClangFormat.html?rev=336152&view=auto
==============================================================================
--- www-releases/trunk/6.0.1/tools/clang/docs/ClangFormat.html (added)
+++ www-releases/trunk/6.0.1/tools/clang/docs/ClangFormat.html Mon Jul 2 16:21:43 2018
@@ -0,0 +1,248 @@
+
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+ <title>ClangFormat — Clang 6 documentation</title>
+
+ <link rel="stylesheet" href="_static/haiku.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+ <link rel="stylesheet" href="_static/print.css" type="text/css" />
+
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: '',
+ VERSION: '6',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true
+ };
+ </script>
+ <script type="text/javascript" src="_static/jquery.js"></script>
+ <script type="text/javascript" src="_static/underscore.js"></script>
+ <script type="text/javascript" src="_static/doctools.js"></script>
+ <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+ <script type="text/javascript" src="_static/theme_extras.js"></script>
+ <link rel="top" title="Clang 6 documentation" href="index.html" />
+ <link rel="next" title="Clang-Format Style Options" href="ClangFormatStyleOptions.html" />
+ <link rel="prev" title="ClangCheck" href="ClangCheck.html" />
+ </head>
+ <body>
+ <div class="header"><h1 class="heading"><a href="index.html">
+ <span>Clang 6 documentation</span></a></h1>
+ <h2 class="heading"><span>ClangFormat</span></h2>
+ </div>
+ <div class="topnav">
+
+ <p>
+ « <a href="ClangCheck.html">ClangCheck</a>
+ ::
+ <a class="uplink" href="index.html">Contents</a>
+ ::
+ <a href="ClangFormatStyleOptions.html">Clang-Format Style Options</a> »
+ </p>
+
+ </div>
+ <div class="content">
+
+
+ <div class="section" id="clangformat">
+<h1>ClangFormat<a class="headerlink" href="#clangformat" title="Permalink to this headline">¶</a></h1>
+<p><cite>ClangFormat</cite> describes a set of tools that are built on top of
+<a class="reference internal" href="LibFormat.html"><em>LibFormat</em></a>. It can support your workflow in a variety of ways including a
+standalone tool and editor integrations.</p>
+<div class="section" id="standalone-tool">
+<h2>Standalone Tool<a class="headerlink" href="#standalone-tool" title="Permalink to this headline">¶</a></h2>
+<p><strong class="program">clang-format</strong> is located in <cite>clang/tools/clang-format</cite> and can be used
+to format C/C++/Java/JavaScript/Objective-C/Protobuf code.</p>
+<div class="highlight-console"><div class="highlight"><pre><span class="gp">$</span> clang-format -help
+<span class="go">OVERVIEW: A tool to format C/C++/Java/JavaScript/Objective-C/Protobuf code.</span>
+
+<span class="go">If no arguments are specified, it formats the code from standard input</span>
+<span class="go">and writes the result to the standard output.</span>
+<span class="go">If <file>s are given, it reformats the files. If -i is specified</span>
+<span class="go">together with <file>s, the files are edited in-place. Otherwise, the</span>
+<span class="go">result is written to the standard output.</span>
+
+<span class="go">USAGE: clang-format [options] [<file> ...]</span>
+
+<span class="go">OPTIONS:</span>
+
+<span class="go">Clang-format options:</span>
+
+<span class="go"> -assume-filename=<string> - When reading from stdin, clang-format assumes this</span>
+<span class="go"> filename to look for a style config file (with</span>
+<span class="go"> -style=file) and to determine the language.</span>
+<span class="go"> -cursor=<uint> - The position of the cursor when invoking</span>
+<span class="go"> clang-format from an editor integration</span>
+<span class="go"> -dump-config - Dump configuration options to stdout and exit.</span>
+<span class="go"> Can be used with -style option.</span>
+<span class="go"> -fallback-style=<string> - The name of the predefined style used as a</span>
+<span class="go"> fallback in case clang-format is invoked with</span>
+<span class="go"> -style=file, but can not find the .clang-format</span>
+<span class="go"> file to use.</span>
+<span class="go"> Use -fallback-style=none to skip formatting.</span>
+<span class="go"> -i - Inplace edit <file>s, if specified.</span>
+<span class="go"> -length=<uint> - Format a range of this length (in bytes).</span>
+<span class="go"> Multiple ranges can be formatted by specifying</span>
+<span class="go"> several -offset and -length pairs.</span>
+<span class="go"> When only a single -offset is specified without</span>
+<span class="go"> -length, clang-format will format up to the end</span>
+<span class="go"> of the file.</span>
+<span class="go"> Can only be used with one input file.</span>
+<span class="go"> -lines=<string> - <start line>:<end line> - format a range of</span>
+<span class="go"> lines (both 1-based).</span>
+<span class="go"> Multiple ranges can be formatted by specifying</span>
+<span class="go"> several -lines arguments.</span>
+<span class="go"> Can't be used with -offset and -length.</span>
+<span class="go"> Can only be used with one input file.</span>
+<span class="go"> -offset=<uint> - Format a range starting at this byte offset.</span>
+<span class="go"> Multiple ranges can be formatted by specifying</span>
+<span class="go"> several -offset and -length pairs.</span>
+<span class="go"> Can only be used with one input file.</span>
+<span class="go"> -output-replacements-xml - Output replacements as XML.</span>
+<span class="go"> -sort-includes - Sort touched include lines</span>
+<span class="go"> -style=<string> - Coding style, currently supports:</span>
+<span class="go"> LLVM, Google, Chromium, Mozilla, WebKit.</span>
+<span class="go"> Use -style=file to load style configuration from</span>
+<span class="go"> .clang-format file located in one of the parent</span>
+<span class="go"> directories of the source file (or current</span>
+<span class="go"> directory for stdin).</span>
+<span class="go"> Use -style="{key: value, ...}" to set specific</span>
+<span class="go"> parameters, e.g.:</span>
+<span class="go"> -style="{BasedOnStyle: llvm, IndentWidth: 8}"</span>
+<span class="go"> -verbose - If set, shows the list of processed files</span>
+
+<span class="go">Generic Options:</span>
+
+<span class="go"> -help - Display available options (-help-hidden for more)</span>
+<span class="go"> -help-list - Display list of available options (-help-list-hidden for more)</span>
+<span class="go"> -version - Display the version of this program</span>
+</pre></div>
+</div>
+<p>When the desired code formatting style is different from the available options,
+the style can be customized using the <tt class="docutils literal"><span class="pre">-style="{key:</span> <span class="pre">value,</span> <span class="pre">...}"</span></tt> option or
+by putting your style configuration in the <tt class="docutils literal"><span class="pre">.clang-format</span></tt> or <tt class="docutils literal"><span class="pre">_clang-format</span></tt>
+file in your project’s directory and using <tt class="docutils literal"><span class="pre">clang-format</span> <span class="pre">-style=file</span></tt>.</p>
+<p>An easy way to create the <tt class="docutils literal"><span class="pre">.clang-format</span></tt> file is:</p>
+<div class="highlight-console"><div class="highlight"><pre><span class="go">clang-format -style=llvm -dump-config > .clang-format</span>
+</pre></div>
+</div>
+<p>Available style options are described in <a class="reference internal" href="ClangFormatStyleOptions.html"><em>Clang-Format Style Options</em></a>.</p>
+</div>
+<div class="section" id="vim-integration">
+<h2>Vim Integration<a class="headerlink" href="#vim-integration" title="Permalink to this headline">¶</a></h2>
+<p>There is an integration for <strong class="program">vim</strong> which lets you run the
+<strong class="program">clang-format</strong> standalone tool on your current buffer, optionally
+selecting regions to reformat. The integration has the form of a <cite>python</cite>-file
+which can be found under <cite>clang/tools/clang-format/clang-format.py</cite>.</p>
+<p>This can be integrated by adding the following to your <cite>.vimrc</cite>:</p>
+<div class="highlight-vim"><div class="highlight"><pre>map <span class="p"><</span>C<span class="p">-</span>K<span class="p">></span> :<span class="k">pyf</span> <span class="p"><</span><span class="nb">path</span><span class="p">-</span><span class="k">to</span><span class="p">-</span>this<span class="p">-</span><span class="k">file</span><span class="p">></span>/clang<span class="p">-</span>format.<span class="k">py</span><span class="p"><</span><span class="k">cr</span><span class="p">></span>
+imap <span class="p"><</span>C<span class="p">-</span>K<span class="p">></span> <span class="p"><</span><span class="k">c</span><span class="p">-</span><span class="k">o</span><span class="p">></span>:<span class="k">pyf</span> <span class="p"><</span><span class="nb">path</span><span class="p">-</span><span class="k">to</span><span class="p">-</span>this<span class="p">-</span><span class="k">file</span><span class="p">></span>/clang<span class="p">-</span>format.<span class="k">py</span><span class="p"><</span><span class="k">cr</span><span class="p">></span>
+</pre></div>
+</div>
+<p>The first line enables <strong class="program">clang-format</strong> for NORMAL and VISUAL mode, the
+second line adds support for INSERT mode. Change “C-K” to another binding if
+you need <strong class="program">clang-format</strong> on a different key (C-K stands for Ctrl+k).</p>
+<p>With this integration you can press the bound key and clang-format will
+format the current line in NORMAL and INSERT mode or the selected region in
+VISUAL mode. The line or region is extended to the next bigger syntactic
+entity.</p>
+<p>It operates on the current, potentially unsaved buffer and does not create
+or save any files. To revert a formatting, just undo.</p>
+<p>An alternative option is to format changes when saving a file and thus to
+have a zero-effort integration into the coding workflow. To do this, add this to
+your <cite>.vimrc</cite>:</p>
+<div class="highlight-vim"><div class="highlight"><pre><span class="k">function</span><span class="p">!</span> Formatonsave<span class="p">()</span>
+ <span class="k">let</span> <span class="k">l</span>:formatdiff <span class="p">=</span> <span class="m">1</span>
+ <span class="k">pyf</span> <span class="p">~</span><span class="sr">/llvm/</span>tools<span class="sr">/clang/</span>tools<span class="sr">/clang-format/</span>clang<span class="p">-</span>format.<span class="k">py</span>
+<span class="k">endfunction</span>
+autocmd <span class="nb">BufWritePre</span> *.<span class="k">h</span><span class="p">,</span>*.<span class="k">cc</span><span class="p">,</span>*.cpp <span class="k">call</span> Formatonsave<span class="p">()</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="emacs-integration">
+<h2>Emacs Integration<a class="headerlink" href="#emacs-integration" title="Permalink to this headline">¶</a></h2>
+<p>Similar to the integration for <strong class="program">vim</strong>, there is an integration for
+<strong class="program">emacs</strong>. It can be found at <cite>clang/tools/clang-format/clang-format.el</cite>
+and used by adding this to your <cite>.emacs</cite>:</p>
+<div class="highlight-common-lisp"><div class="highlight"><pre><span class="p">(</span><span class="nb">load</span> <span class="s">"<path-to-clang>/tools/clang-format/clang-format.el"</span><span class="p">)</span>
+<span class="p">(</span><span class="nv">global-set-key</span> <span class="nv">[C-M-tab]</span> <span class="ss">'clang-format-region</span><span class="p">)</span>
+</pre></div>
+</div>
+<p>This binds the function <cite>clang-format-region</cite> to C-M-tab, which then formats the
+current line or selected region.</p>
+</div>
+<div class="section" id="bbedit-integration">
+<h2>BBEdit Integration<a class="headerlink" href="#bbedit-integration" title="Permalink to this headline">¶</a></h2>
+<p><strong class="program">clang-format</strong> cannot be used as a text filter with BBEdit, but works
+well via a script. The AppleScript to do this integration can be found at
+<cite>clang/tools/clang-format/clang-format-bbedit.applescript</cite>; place a copy in
+<cite>~/Library/Application Support/BBEdit/Scripts</cite>, and edit the path within it to
+point to your local copy of <strong class="program">clang-format</strong>.</p>
+<p>With this integration you can select the script from the Script menu and
+<strong class="program">clang-format</strong> will format the selection. Note that you can rename the
+menu item by renaming the script, and can assign the menu item a keyboard
+shortcut in the BBEdit preferences, under Menus & Shortcuts.</p>
+</div>
+<div class="section" id="visual-studio-integration">
+<h2>Visual Studio Integration<a class="headerlink" href="#visual-studio-integration" title="Permalink to this headline">¶</a></h2>
+<p>Download the latest Visual Studio extension from the <a class="reference external" href="http://llvm.org/builds/">alpha build site</a>. The default key-binding is Ctrl-R,Ctrl-F.</p>
+</div>
+<div class="section" id="script-for-patch-reformatting">
+<h2>Script for patch reformatting<a class="headerlink" href="#script-for-patch-reformatting" title="Permalink to this headline">¶</a></h2>
+<p>The python script <cite>clang/tools/clang-format/clang-format-diff.py</cite> parses the
+output of a unified diff and reformats all contained lines with
+<strong class="program">clang-format</strong>.</p>
+<div class="highlight-console"><div class="highlight"><pre><span class="go">usage: clang-format-diff.py [-h] [-i] [-p NUM] [-regex PATTERN] [-style STYLE]</span>
+
+<span class="go">Reformat changed lines in diff. Without -i option just output the diff that</span>
+<span class="go">would be introduced.</span>
+
+<span class="go">optional arguments:</span>
+<span class="go"> -h, --help show this help message and exit</span>
+<span class="go"> -i apply edits to files instead of displaying a diff</span>
+<span class="go"> -p NUM strip the smallest prefix containing P slashes</span>
+<span class="go"> -regex PATTERN custom pattern selecting file paths to reformat</span>
+<span class="go"> -style STYLE formatting style to apply (LLVM, Google, Chromium, Mozilla,</span>
+<span class="go"> WebKit)</span>
+</pre></div>
+</div>
+<p>So to reformat all the lines in the latest <strong class="program">git</strong> commit, just do:</p>
+<div class="highlight-console"><div class="highlight"><pre><span class="go">git diff -U0 --no-color HEAD^ | clang-format-diff.py -i -p1</span>
+</pre></div>
+</div>
+<p>In an SVN client, you can do:</p>
+<div class="highlight-console"><div class="highlight"><pre><span class="go">svn diff --diff-cmd=diff -x -U0 | clang-format-diff.py -i</span>
+</pre></div>
+</div>
+<p>The option <cite>-U0</cite> will create a diff without context lines (the script would format
+those as well).</p>
+</div>
+</div>
+
+
+ </div>
+ <div class="bottomnav">
+
+ <p>
+ « <a href="ClangCheck.html">ClangCheck</a>
+ ::
+ <a class="uplink" href="index.html">Contents</a>
+ ::
+ <a href="ClangFormatStyleOptions.html">Clang-Format Style Options</a> »
+ </p>
+
+ </div>
+
+ <div class="footer">
+ © Copyright 2007-2018, The Clang Team.
+ Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/6.0.1/tools/clang/docs/ClangFormatStyleOptions.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/6.0.1/tools/clang/docs/ClangFormatStyleOptions.html?rev=336152&view=auto
==============================================================================
--- www-releases/trunk/6.0.1/tools/clang/docs/ClangFormatStyleOptions.html (added)
+++ www-releases/trunk/6.0.1/tools/clang/docs/ClangFormatStyleOptions.html Mon Jul 2 16:21:43 2018
@@ -0,0 +1,1788 @@
+
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+ <title>Clang-Format Style Options — Clang 6 documentation</title>
+
+ <link rel="stylesheet" href="_static/haiku.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+ <link rel="stylesheet" href="_static/print.css" type="text/css" />
+
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: '',
+ VERSION: '6',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true
+ };
+ </script>
+ <script type="text/javascript" src="_static/jquery.js"></script>
+ <script type="text/javascript" src="_static/underscore.js"></script>
+ <script type="text/javascript" src="_static/doctools.js"></script>
+ <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+ <script type="text/javascript" src="_static/theme_extras.js"></script>
+ <link rel="top" title="Clang 6 documentation" href="index.html" />
+ <link rel="next" title="âClangâ CFE Internals Manual" href="InternalsManual.html" />
+ <link rel="prev" title="ClangFormat" href="ClangFormat.html" />
+ </head>
+ <body>
+ <div class="header"><h1 class="heading"><a href="index.html">
+ <span>Clang 6 documentation</span></a></h1>
+ <h2 class="heading"><span>Clang-Format Style Options</span></h2>
+ </div>
+ <div class="topnav">
+
+ <p>
+ « <a href="ClangFormat.html">ClangFormat</a>
+ ::
+ <a class="uplink" href="index.html">Contents</a>
+ ::
+ <a href="InternalsManual.html">“Clang” CFE Internals Manual</a> »
+ </p>
+
+ </div>
+ <div class="content">
+
+
+ <div class="section" id="clang-format-style-options">
+<h1>Clang-Format Style Options<a class="headerlink" href="#clang-format-style-options" title="Permalink to this headline">¶</a></h1>
+<p><a class="reference internal" href=""><em>Clang-Format Style Options</em></a> describes configurable formatting style options
+supported by <a class="reference internal" href="LibFormat.html"><em>LibFormat</em></a> and <a class="reference internal" href="ClangFormat.html"><em>ClangFormat</em></a>.</p>
+<p>When using <strong class="program">clang-format</strong> command line utility or
+<tt class="docutils literal"><span class="pre">clang::format::reformat(...)</span></tt> functions from code, one can either use one of
+the predefined styles (LLVM, Google, Chromium, Mozilla, WebKit) or create a
+custom style by configuring specific style options.</p>
+<div class="section" id="configuring-style-with-clang-format">
+<h2>Configuring Style with clang-format<a class="headerlink" href="#configuring-style-with-clang-format" title="Permalink to this headline">¶</a></h2>
+<p><strong class="program">clang-format</strong> supports two ways to provide custom style options:
+directly specify style configuration in the <tt class="docutils literal"><span class="pre">-style=</span></tt> command line option or
+use <tt class="docutils literal"><span class="pre">-style=file</span></tt> and put style configuration in the <tt class="docutils literal"><span class="pre">.clang-format</span></tt> or
+<tt class="docutils literal"><span class="pre">_clang-format</span></tt> file in the project directory.</p>
+<p>When using <tt class="docutils literal"><span class="pre">-style=file</span></tt>, <strong class="program">clang-format</strong> for each input file will
+try to find the <tt class="docutils literal"><span class="pre">.clang-format</span></tt> file located in the closest parent directory
+of the input file. When the standard input is used, the search is started from
+the current directory.</p>
+<p>The <tt class="docutils literal"><span class="pre">.clang-format</span></tt> file uses YAML format:</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="l-Scalar-Plain">key1</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">value1</span>
+<span class="l-Scalar-Plain">key2</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">value2</span>
+<span class="c1"># A comment.</span>
+<span class="nn">...</span>
+</pre></div>
+</div>
+<p>The configuration file can consist of several sections each having different
+<tt class="docutils literal"><span class="pre">Language:</span></tt> parameter denoting the programming language this section of the
+configuration is targeted at. See the description of the <strong>Language</strong> option
+below for the list of supported languages. The first section may have no
+language set, it will set the default style options for all lanugages.
+Configuration sections for specific language will override options set in the
+default section.</p>
+<p>When <strong class="program">clang-format</strong> formats a file, it auto-detects the language using
+the file name. When formatting standard input or a file that doesn’t have the
+extension corresponding to its language, <tt class="docutils literal"><span class="pre">-assume-filename=</span></tt> option can be
+used to override the file name <strong class="program">clang-format</strong> uses to detect the
+language.</p>
+<p>An example of a configuration file for multiple languages:</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="nn">---</span>
+<span class="c1"># We'll use defaults from the LLVM style, but with 4 columns indentation.</span>
+<span class="l-Scalar-Plain">BasedOnStyle</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">LLVM</span>
+<span class="l-Scalar-Plain">IndentWidth</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">4</span>
+<span class="nn">---</span>
+<span class="l-Scalar-Plain">Language</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">Cpp</span>
+<span class="c1"># Force pointers to the type for C++.</span>
+<span class="l-Scalar-Plain">DerivePointerAlignment</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">false</span>
+<span class="l-Scalar-Plain">PointerAlignment</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">Left</span>
+<span class="nn">---</span>
+<span class="l-Scalar-Plain">Language</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">JavaScript</span>
+<span class="c1"># Use 100 columns for JS.</span>
+<span class="l-Scalar-Plain">ColumnLimit</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">100</span>
+<span class="nn">---</span>
+<span class="l-Scalar-Plain">Language</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">Proto</span>
+<span class="c1"># Don't format .proto files.</span>
+<span class="l-Scalar-Plain">DisableFormat</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">true</span>
+<span class="nn">...</span>
+</pre></div>
+</div>
+<p>An easy way to get a valid <tt class="docutils literal"><span class="pre">.clang-format</span></tt> file containing all configuration
+options of a certain predefined style is:</p>
+<div class="highlight-console"><div class="highlight"><pre><span class="go">clang-format -style=llvm -dump-config > .clang-format</span>
+</pre></div>
+</div>
+<p>When specifying configuration in the <tt class="docutils literal"><span class="pre">-style=</span></tt> option, the same configuration
+is applied for all input files. The format of the configuration is:</p>
+<div class="highlight-console"><div class="highlight"><pre><span class="go">-style='{key1: value1, key2: value2, ...}'</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="disabling-formatting-on-a-piece-of-code">
+<h2>Disabling Formatting on a Piece of Code<a class="headerlink" href="#disabling-formatting-on-a-piece-of-code" title="Permalink to this headline">¶</a></h2>
+<p>Clang-format understands also special comments that switch formatting in a
+delimited range. The code between a comment <tt class="docutils literal"><span class="pre">//</span> <span class="pre">clang-format</span> <span class="pre">off</span></tt> or
+<tt class="docutils literal"><span class="pre">/*</span> <span class="pre">clang-format</span> <span class="pre">off</span> <span class="pre">*/</span></tt> up to a comment <tt class="docutils literal"><span class="pre">//</span> <span class="pre">clang-format</span> <span class="pre">on</span></tt> or
+<tt class="docutils literal"><span class="pre">/*</span> <span class="pre">clang-format</span> <span class="pre">on</span> <span class="pre">*/</span></tt> will not be formatted. The comments themselves
+will be formatted (aligned) normally.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="kt">int</span> <span class="n">formatted_code</span><span class="p">;</span>
+<span class="c1">// clang-format off</span>
+ <span class="kt">void</span> <span class="n">unformatted_code</span> <span class="p">;</span>
+<span class="c1">// clang-format on</span>
+<span class="kt">void</span> <span class="n">formatted_code_again</span><span class="p">;</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="configuring-style-in-code">
+<h2>Configuring Style in Code<a class="headerlink" href="#configuring-style-in-code" title="Permalink to this headline">¶</a></h2>
+<p>When using <tt class="docutils literal"><span class="pre">clang::format::reformat(...)</span></tt> functions, the format is specified
+by supplying the <a class="reference external" href="http://clang.llvm.org/doxygen/structclang_1_1format_1_1FormatStyle.html">clang::format::FormatStyle</a>
+structure.</p>
+</div>
+<div class="section" id="configurable-format-style-options">
+<h2>Configurable Format Style Options<a class="headerlink" href="#configurable-format-style-options" title="Permalink to this headline">¶</a></h2>
+<p>This section lists the supported style options. Value type is specified for
+each option. For enumeration types possible values are specified both as a C++
+enumeration member (with a prefix, e.g. <tt class="docutils literal"><span class="pre">LS_Auto</span></tt>), and as a value usable in
+the configuration (without a prefix: <tt class="docutils literal"><span class="pre">Auto</span></tt>).</p>
+<dl class="docutils">
+<dt><strong>BasedOnStyle</strong> (<tt class="docutils literal"><span class="pre">string</span></tt>)</dt>
+<dd><p class="first">The style used for all options not specifically set in the configuration.</p>
+<p>This option is supported only in the <strong class="program">clang-format</strong> configuration
+(both within <tt class="docutils literal"><span class="pre">-style='{...}'</span></tt> and the <tt class="docutils literal"><span class="pre">.clang-format</span></tt> file).</p>
+<p>Possible values:</p>
+<ul class="last simple">
+<li><tt class="docutils literal"><span class="pre">LLVM</span></tt>
+A style complying with the <a class="reference external" href="http://llvm.org/docs/CodingStandards.html">LLVM coding standards</a></li>
+<li><tt class="docutils literal"><span class="pre">Google</span></tt>
+A style complying with <a class="reference external" href="http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml">Google’s C++ style guide</a></li>
+<li><tt class="docutils literal"><span class="pre">Chromium</span></tt>
+A style complying with <a class="reference external" href="http://www.chromium.org/developers/coding-style">Chromium’s style guide</a></li>
+<li><tt class="docutils literal"><span class="pre">Mozilla</span></tt>
+A style complying with <a class="reference external" href="https://developer.mozilla.org/en-US/docs/Developer_Guide/Coding_Style">Mozilla’s style guide</a></li>
+<li><tt class="docutils literal"><span class="pre">WebKit</span></tt>
+A style complying with <a class="reference external" href="http://www.webkit.org/coding/coding-style.html">WebKit’s style guide</a></li>
+</ul>
+</dd>
+</dl>
+<dl class="docutils">
+<dt><strong>AccessModifierOffset</strong> (<tt class="docutils literal"><span class="pre">int</span></tt>)</dt>
+<dd>The extra indent or outdent of access modifiers, e.g. <tt class="docutils literal"><span class="pre">public:</span></tt>.</dd>
+<dt><strong>AlignAfterOpenBracket</strong> (<tt class="docutils literal"><span class="pre">BracketAlignmentStyle</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, horizontally aligns arguments after an open bracket.</p>
+<p>This applies to round brackets (parentheses), angle brackets and square
+brackets.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><tt class="docutils literal"><span class="pre">BAS_Align</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Align</span></tt>)
+Align parameters on the open bracket, e.g.:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="n">someLongFunction</span><span class="p">(</span><span class="n">argument1</span><span class="p">,</span>
+ <span class="n">argument2</span><span class="p">);</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">BAS_DontAlign</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">DontAlign</span></tt>)
+Don’t align, instead use <tt class="docutils literal"><span class="pre">ContinuationIndentWidth</span></tt>, e.g.:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="n">someLongFunction</span><span class="p">(</span><span class="n">argument1</span><span class="p">,</span>
+ <span class="n">argument2</span><span class="p">);</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">BAS_AlwaysBreak</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">AlwaysBreak</span></tt>)
+Always break after an open bracket, if the parameters don’t fit
+on a single line, e.g.:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="n">someLongFunction</span><span class="p">(</span>
+ <span class="n">argument1</span><span class="p">,</span> <span class="n">argument2</span><span class="p">);</span>
+</pre></div>
+</div>
+</li>
+</ul>
+</dd>
+<dt><strong>AlignConsecutiveAssignments</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, aligns consecutive assignments.</p>
+<p>This will align the assignment operators of consecutive lines. This
+will result in formattings like</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kt">int</span> <span class="n">aaaa</span> <span class="o">=</span> <span class="mi">12</span><span class="p">;</span>
+<span class="kt">int</span> <span class="n">b</span> <span class="o">=</span> <span class="mi">23</span><span class="p">;</span>
+<span class="kt">int</span> <span class="n">ccc</span> <span class="o">=</span> <span class="mi">23</span><span class="p">;</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>AlignConsecutiveDeclarations</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, aligns consecutive declarations.</p>
+<p>This will align the declaration names of consecutive lines. This
+will result in formattings like</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kt">int</span> <span class="n">aaaa</span> <span class="o">=</span> <span class="mi">12</span><span class="p">;</span>
+<span class="kt">float</span> <span class="n">b</span> <span class="o">=</span> <span class="mi">23</span><span class="p">;</span>
+<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">ccc</span> <span class="o">=</span> <span class="mi">23</span><span class="p">;</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>AlignEscapedNewlines</strong> (<tt class="docutils literal"><span class="pre">EscapedNewlineAlignmentStyle</span></tt>)</dt>
+<dd><p class="first">Options for aligning backslashes in escaped newlines.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><tt class="docutils literal"><span class="pre">ENAS_DontAlign</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">DontAlign</span></tt>)
+Don’t align escaped newlines.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="cp">#define A \</span>
+<span class="cp"> int aaaa; \</span>
+<span class="cp"> int b; \</span>
+<span class="cp"> int dddddddddd;</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">ENAS_Left</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Left</span></tt>)
+Align escaped newlines as far left as possible.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span>
+<span class="cp">#define A \</span>
+<span class="cp"> int aaaa; \</span>
+<span class="cp"> int b; \</span>
+<span class="cp"> int dddddddddd;</span>
+
+<span class="kc">false</span><span class="o">:</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">ENAS_Right</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Right</span></tt>)
+Align escaped newlines in the right-most column.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="cp">#define A \</span>
+<span class="cp"> int aaaa; \</span>
+<span class="cp"> int b; \</span>
+<span class="cp"> int dddddddddd;</span>
+</pre></div>
+</div>
+</li>
+</ul>
+</dd>
+<dt><strong>AlignOperands</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, horizontally align operands of binary and ternary
+expressions.</p>
+<p>Specifically, this aligns operands of a single expression that needs to be
+split over multiple lines, e.g.:</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kt">int</span> <span class="n">aaa</span> <span class="o">=</span> <span class="n">bbbbbbbbbbbbbbb</span> <span class="o">+</span>
+ <span class="n">ccccccccccccccc</span><span class="p">;</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>AlignTrailingComments</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, aligns trailing comments.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span> <span class="kc">false</span><span class="o">:</span>
+<span class="kt">int</span> <span class="n">a</span><span class="p">;</span> <span class="c1">// My comment a vs. int a; // My comment a</span>
+<span class="kt">int</span> <span class="n">b</span> <span class="o">=</span> <span class="mi">2</span><span class="p">;</span> <span class="c1">// comment b int b = 2; // comment about b</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>AllowAllParametersOfDeclarationOnNextLine</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If the function declaration doesn’t fit on a line,
+allow putting all parameters of a function declaration onto
+the next line even if <tt class="docutils literal"><span class="pre">BinPackParameters</span></tt> is <tt class="docutils literal"><span class="pre">false</span></tt>.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span>
+<span class="kt">void</span> <span class="n">myFunction</span><span class="p">(</span>
+ <span class="kt">int</span> <span class="n">a</span><span class="p">,</span> <span class="kt">int</span> <span class="n">b</span><span class="p">,</span> <span class="kt">int</span> <span class="n">c</span><span class="p">,</span> <span class="kt">int</span> <span class="n">d</span><span class="p">,</span> <span class="kt">int</span> <span class="n">e</span><span class="p">);</span>
+
+<span class="kc">false</span><span class="o">:</span>
+<span class="kt">void</span> <span class="n">myFunction</span><span class="p">(</span><span class="kt">int</span> <span class="n">a</span><span class="p">,</span>
+ <span class="kt">int</span> <span class="n">b</span><span class="p">,</span>
+ <span class="kt">int</span> <span class="n">c</span><span class="p">,</span>
+ <span class="kt">int</span> <span class="n">d</span><span class="p">,</span>
+ <span class="kt">int</span> <span class="n">e</span><span class="p">);</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>AllowShortBlocksOnASingleLine</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">Allows contracting simple braced statements to a single line.</p>
+<p class="last">E.g., this allows <tt class="docutils literal"><span class="pre">if</span> <span class="pre">(a)</span> <span class="pre">{</span> <span class="pre">return;</span> <span class="pre">}</span></tt> to be put on a single line.</p>
+</dd>
+<dt><strong>AllowShortCaseLabelsOnASingleLine</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, short case labels will be contracted to a single line.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span> <span class="kc">false</span><span class="o">:</span>
+<span class="k">switch</span> <span class="p">(</span><span class="n">a</span><span class="p">)</span> <span class="p">{</span> <span class="n">vs</span><span class="p">.</span> <span class="k">switch</span> <span class="p">(</span><span class="n">a</span><span class="p">)</span> <span class="p">{</span>
+<span class="k">case</span> <span class="mi">1</span><span class="o">:</span> <span class="n">x</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span> <span class="k">break</span><span class="p">;</span> <span class="k">case</span> <span class="mi">1</span><span class="o">:</span>
+<span class="k">case</span> <span class="mi">2</span><span class="o">:</span> <span class="k">return</span><span class="p">;</span> <span class="n">x</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span>
+<span class="p">}</span> <span class="k">break</span><span class="p">;</span>
+ <span class="k">case</span> <span class="mi">2</span><span class="o">:</span>
+ <span class="k">return</span><span class="p">;</span>
+ <span class="p">}</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>AllowShortFunctionsOnASingleLine</strong> (<tt class="docutils literal"><span class="pre">ShortFunctionStyle</span></tt>)</dt>
+<dd><p class="first">Dependent on the value, <tt class="docutils literal"><span class="pre">int</span> <span class="pre">f()</span> <span class="pre">{</span> <span class="pre">return</span> <span class="pre">0;</span> <span class="pre">}</span></tt> can be put on a
+single line.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><tt class="docutils literal"><span class="pre">SFS_None</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">None</span></tt>)
+Never merge functions into a single line.</p>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">SFS_InlineOnly</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">InlineOnly</span></tt>)
+Only merge functions defined inside a class. Same as “inline”,
+except it does not implies “empty”: i.e. top level empty functions
+are not merged either.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">class</span> <span class="nc">Foo</span> <span class="p">{</span>
+ <span class="kt">void</span> <span class="n">f</span><span class="p">()</span> <span class="p">{</span> <span class="n">foo</span><span class="p">();</span> <span class="p">}</span>
+<span class="p">};</span>
+<span class="kt">void</span> <span class="n">f</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">foo</span><span class="p">();</span>
+<span class="p">}</span>
+<span class="kt">void</span> <span class="n">f</span><span class="p">()</span> <span class="p">{</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">SFS_Empty</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Empty</span></tt>)
+Only merge empty functions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="kt">void</span> <span class="n">f</span><span class="p">()</span> <span class="p">{}</span>
+<span class="kt">void</span> <span class="n">f2</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">bar2</span><span class="p">();</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">SFS_Inline</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Inline</span></tt>)
+Only merge functions defined inside a class. Implies “empty”.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">class</span> <span class="nc">Foo</span> <span class="p">{</span>
+ <span class="kt">void</span> <span class="n">f</span><span class="p">()</span> <span class="p">{</span> <span class="n">foo</span><span class="p">();</span> <span class="p">}</span>
+<span class="p">};</span>
+<span class="kt">void</span> <span class="n">f</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">foo</span><span class="p">();</span>
+<span class="p">}</span>
+<span class="kt">void</span> <span class="n">f</span><span class="p">()</span> <span class="p">{}</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">SFS_All</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">All</span></tt>)
+Merge all functions fitting on a single line.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">class</span> <span class="nc">Foo</span> <span class="p">{</span>
+ <span class="kt">void</span> <span class="n">f</span><span class="p">()</span> <span class="p">{</span> <span class="n">foo</span><span class="p">();</span> <span class="p">}</span>
+<span class="p">};</span>
+<span class="kt">void</span> <span class="n">f</span><span class="p">()</span> <span class="p">{</span> <span class="n">bar</span><span class="p">();</span> <span class="p">}</span>
+</pre></div>
+</div>
+</li>
+</ul>
+</dd>
+<dt><strong>AllowShortIfStatementsOnASingleLine</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd>If <tt class="docutils literal"><span class="pre">true</span></tt>, <tt class="docutils literal"><span class="pre">if</span> <span class="pre">(a)</span> <span class="pre">return;</span></tt> can be put on a single line.</dd>
+<dt><strong>AllowShortLoopsOnASingleLine</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd>If <tt class="docutils literal"><span class="pre">true</span></tt>, <tt class="docutils literal"><span class="pre">while</span> <span class="pre">(true)</span> <span class="pre">continue;</span></tt> can be put on a single
+line.</dd>
+<dt><strong>AlwaysBreakAfterDefinitionReturnType</strong> (<tt class="docutils literal"><span class="pre">DefinitionReturnTypeBreakingStyle</span></tt>)</dt>
+<dd><p class="first">The function definition return type breaking style to use. This
+option is <strong>deprecated</strong> and is retained for backwards compatibility.</p>
+<p>Possible values:</p>
+<ul class="last simple">
+<li><tt class="docutils literal"><span class="pre">DRTBS_None</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">None</span></tt>)
+Break after return type automatically.
+<tt class="docutils literal"><span class="pre">PenaltyReturnTypeOnItsOwnLine</span></tt> is taken into account.</li>
+<li><tt class="docutils literal"><span class="pre">DRTBS_All</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">All</span></tt>)
+Always break after the return type.</li>
+<li><tt class="docutils literal"><span class="pre">DRTBS_TopLevel</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">TopLevel</span></tt>)
+Always break after the return types of top-level functions.</li>
+</ul>
+</dd>
+<dt><strong>AlwaysBreakAfterReturnType</strong> (<tt class="docutils literal"><span class="pre">ReturnTypeBreakingStyle</span></tt>)</dt>
+<dd><p class="first">The function declaration return type breaking style to use.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><tt class="docutils literal"><span class="pre">RTBS_None</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">None</span></tt>)
+Break after return type automatically.
+<tt class="docutils literal"><span class="pre">PenaltyReturnTypeOnItsOwnLine</span></tt> is taken into account.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">class</span> <span class="nc">A</span> <span class="p">{</span>
+ <span class="kt">int</span> <span class="n">f</span><span class="p">()</span> <span class="p">{</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span> <span class="p">};</span>
+<span class="p">};</span>
+<span class="kt">int</span> <span class="n">f</span><span class="p">();</span>
+<span class="kt">int</span> <span class="n">f</span><span class="p">()</span> <span class="p">{</span> <span class="k">return</span> <span class="mi">1</span><span class="p">;</span> <span class="p">}</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">RTBS_All</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">All</span></tt>)
+Always break after the return type.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">class</span> <span class="nc">A</span> <span class="p">{</span>
+ <span class="kt">int</span>
+ <span class="n">f</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="p">};</span>
+<span class="p">};</span>
+<span class="kt">int</span>
+<span class="n">f</span><span class="p">();</span>
+<span class="kt">int</span>
+<span class="n">f</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="mi">1</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">RTBS_TopLevel</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">TopLevel</span></tt>)
+Always break after the return types of top-level functions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">class</span> <span class="nc">A</span> <span class="p">{</span>
+ <span class="kt">int</span> <span class="n">f</span><span class="p">()</span> <span class="p">{</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span> <span class="p">};</span>
+<span class="p">};</span>
+<span class="kt">int</span>
+<span class="n">f</span><span class="p">();</span>
+<span class="kt">int</span>
+<span class="n">f</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="mi">1</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">RTBS_AllDefinitions</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">AllDefinitions</span></tt>)
+Always break after the return type of function definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">class</span> <span class="nc">A</span> <span class="p">{</span>
+ <span class="kt">int</span>
+ <span class="n">f</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="p">};</span>
+<span class="p">};</span>
+<span class="kt">int</span> <span class="n">f</span><span class="p">();</span>
+<span class="kt">int</span>
+<span class="n">f</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="mi">1</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">RTBS_TopLevelDefinitions</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">TopLevelDefinitions</span></tt>)
+Always break after the return type of top-level definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">class</span> <span class="nc">A</span> <span class="p">{</span>
+ <span class="kt">int</span> <span class="n">f</span><span class="p">()</span> <span class="p">{</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span> <span class="p">};</span>
+<span class="p">};</span>
+<span class="kt">int</span> <span class="n">f</span><span class="p">();</span>
+<span class="kt">int</span>
+<span class="n">f</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="mi">1</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</li>
+</ul>
+</dd>
+<dt><strong>AlwaysBreakBeforeMultilineStrings</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, always break before multiline string literals.</p>
+<p>This flag is mean to make cases where there are multiple multiline strings
+in a file look more consistent. Thus, it will only take effect if wrapping
+the string at that point leads to it being indented
+<tt class="docutils literal"><span class="pre">ContinuationIndentWidth</span></tt> spaces from the start of the line.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span> <span class="kc">false</span><span class="o">:</span>
+<span class="n">aaaa</span> <span class="o">=</span> <span class="n">vs</span><span class="p">.</span> <span class="n">aaaa</span> <span class="o">=</span> <span class="s">"bbbb"</span>
+ <span class="s">"bbbb"</span> <span class="s">"cccc"</span><span class="p">;</span>
+ <span class="s">"cccc"</span><span class="p">;</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>AlwaysBreakTemplateDeclarations</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, always break after the <tt class="docutils literal"><span class="pre">template<...></span></tt> of a template
+declaration.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span> <span class="kc">false</span><span class="o">:</span>
+<span class="k">template</span> <span class="o"><</span><span class="k">typename</span> <span class="n">T</span><span class="o">></span> <span class="n">vs</span><span class="p">.</span> <span class="k">template</span> <span class="o"><</span><span class="k">typename</span> <span class="n">T</span><span class="o">></span> <span class="k">class</span> <span class="nc">C</span> <span class="p">{};</span>
+<span class="k">class</span> <span class="nc">C</span> <span class="p">{};</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>BinPackArguments</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">false</span></tt>, a function call’s arguments will either be all on the
+same line or will have one line each.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span>
+<span class="kt">void</span> <span class="n">f</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">f</span><span class="p">(</span><span class="n">aaaaaaaaaaaaaaaaaaaa</span><span class="p">,</span> <span class="n">aaaaaaaaaaaaaaaaaaaa</span><span class="p">,</span>
+ <span class="n">aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="kc">false</span><span class="o">:</span>
+<span class="kt">void</span> <span class="n">f</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">f</span><span class="p">(</span><span class="n">aaaaaaaaaaaaaaaaaaaa</span><span class="p">,</span>
+ <span class="n">aaaaaaaaaaaaaaaaaaaa</span><span class="p">,</span>
+ <span class="n">aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa</span><span class="p">);</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>BinPackParameters</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">false</span></tt>, a function declaration’s or function definition’s
+parameters will either all be on the same line or will have one line each.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span>
+<span class="kt">void</span> <span class="n">f</span><span class="p">(</span><span class="kt">int</span> <span class="n">aaaaaaaaaaaaaaaaaaaa</span><span class="p">,</span> <span class="kt">int</span> <span class="n">aaaaaaaaaaaaaaaaaaaa</span><span class="p">,</span>
+ <span class="kt">int</span> <span class="n">aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa</span><span class="p">)</span> <span class="p">{}</span>
+
+<span class="kc">false</span><span class="o">:</span>
+<span class="kt">void</span> <span class="n">f</span><span class="p">(</span><span class="kt">int</span> <span class="n">aaaaaaaaaaaaaaaaaaaa</span><span class="p">,</span>
+ <span class="kt">int</span> <span class="n">aaaaaaaaaaaaaaaaaaaa</span><span class="p">,</span>
+ <span class="kt">int</span> <span class="n">aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa</span><span class="p">)</span> <span class="p">{}</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>BraceWrapping</strong> (<tt class="docutils literal"><span class="pre">BraceWrappingFlags</span></tt>)</dt>
+<dd><p class="first">Control of individual brace wrapping cases.</p>
+<p>If <tt class="docutils literal"><span class="pre">BreakBeforeBraces</span></tt> is set to <tt class="docutils literal"><span class="pre">BS_Custom</span></tt>, use this to specify how
+each individual brace case should be handled. Otherwise, this is ignored.</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="c1"># Example of usage:</span>
+<span class="l-Scalar-Plain">BreakBeforeBraces</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">Custom</span>
+<span class="l-Scalar-Plain">BraceWrapping</span><span class="p-Indicator">:</span>
+ <span class="l-Scalar-Plain">AfterEnum</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">true</span>
+ <span class="l-Scalar-Plain">AfterStruct</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">false</span>
+ <span class="l-Scalar-Plain">SplitEmptyFunction</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">false</span>
+</pre></div>
+</div>
+<p>Nested configuration flags:</p>
+<ul class="last">
+<li><p class="first"><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">AfterClass</span></tt> Wrap class definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span>
+<span class="k">class</span> <span class="nc">foo</span> <span class="p">{};</span>
+
+<span class="kc">false</span><span class="o">:</span>
+<span class="k">class</span> <span class="nc">foo</span>
+<span class="p">{};</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">AfterControlStatement</span></tt> Wrap control statements (<tt class="docutils literal"><span class="pre">if</span></tt>/<tt class="docutils literal"><span class="pre">for</span></tt>/<tt class="docutils literal"><span class="pre">while</span></tt>/<tt class="docutils literal"><span class="pre">switch</span></tt>/..).</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">foo</span><span class="p">())</span>
+<span class="p">{</span>
+<span class="p">}</span> <span class="k">else</span>
+<span class="p">{}</span>
+<span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o"><</span> <span class="mi">10</span><span class="p">;</span> <span class="o">++</span><span class="n">i</span><span class="p">)</span>
+<span class="p">{}</span>
+
+<span class="kc">false</span><span class="o">:</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">foo</span><span class="p">())</span> <span class="p">{</span>
+<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+<span class="p">}</span>
+<span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o"><</span> <span class="mi">10</span><span class="p">;</span> <span class="o">++</span><span class="n">i</span><span class="p">)</span> <span class="p">{</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">AfterEnum</span></tt> Wrap enum definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span>
+<span class="k">enum</span> <span class="n">X</span> <span class="o">:</span> <span class="kt">int</span>
+<span class="p">{</span>
+ <span class="n">B</span>
+<span class="p">};</span>
+
+<span class="kc">false</span><span class="o">:</span>
+<span class="k">enum</span> <span class="n">X</span> <span class="o">:</span> <span class="kt">int</span> <span class="p">{</span> <span class="n">B</span> <span class="p">};</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">AfterFunction</span></tt> Wrap function definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span>
+<span class="kt">void</span> <span class="n">foo</span><span class="p">()</span>
+<span class="p">{</span>
+ <span class="n">bar</span><span class="p">();</span>
+ <span class="n">bar2</span><span class="p">();</span>
+<span class="p">}</span>
+
+<span class="kc">false</span><span class="o">:</span>
+<span class="kt">void</span> <span class="n">foo</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">bar</span><span class="p">();</span>
+ <span class="n">bar2</span><span class="p">();</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">AfterNamespace</span></tt> Wrap namespace definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span>
+<span class="k">namespace</span>
+<span class="p">{</span>
+<span class="kt">int</span> <span class="n">foo</span><span class="p">();</span>
+<span class="kt">int</span> <span class="n">bar</span><span class="p">();</span>
+<span class="p">}</span>
+
+<span class="kc">false</span><span class="o">:</span>
+<span class="k">namespace</span> <span class="p">{</span>
+<span class="kt">int</span> <span class="n">foo</span><span class="p">();</span>
+<span class="kt">int</span> <span class="n">bar</span><span class="p">();</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">AfterObjCDeclaration</span></tt> Wrap ObjC definitions (<tt class="docutils literal"><span class="pre">@autoreleasepool</span></tt>, interfaces, ..).</p>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">AfterStruct</span></tt> Wrap struct definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span>
+<span class="k">struct</span> <span class="n">foo</span>
+<span class="p">{</span>
+ <span class="kt">int</span> <span class="n">x</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="kc">false</span><span class="o">:</span>
+<span class="k">struct</span> <span class="n">foo</span> <span class="p">{</span>
+ <span class="kt">int</span> <span class="n">x</span><span class="p">;</span>
+<span class="p">};</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">AfterUnion</span></tt> Wrap union definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span>
+<span class="k">union</span> <span class="n">foo</span>
+<span class="p">{</span>
+ <span class="kt">int</span> <span class="n">x</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="kc">false</span><span class="o">:</span>
+<span class="k">union</span> <span class="n">foo</span> <span class="p">{</span>
+ <span class="kt">int</span> <span class="n">x</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">AfterExternBlock</span></tt> Wrap extern blocks.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span>
+<span class="k">extern</span> <span class="s">"C"</span>
+<span class="p">{</span>
+ <span class="kt">int</span> <span class="n">foo</span><span class="p">();</span>
+<span class="p">}</span>
+
+<span class="kc">false</span><span class="o">:</span>
+<span class="k">extern</span> <span class="s">"C"</span> <span class="p">{</span>
+<span class="kt">int</span> <span class="n">foo</span><span class="p">();</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">BeforeCatch</span></tt> Wrap before <tt class="docutils literal"><span class="pre">catch</span></tt>.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span>
+<span class="k">try</span> <span class="p">{</span>
+ <span class="n">foo</span><span class="p">();</span>
+<span class="p">}</span>
+<span class="k">catch</span> <span class="p">()</span> <span class="p">{</span>
+<span class="p">}</span>
+
+<span class="kc">false</span><span class="o">:</span>
+<span class="k">try</span> <span class="p">{</span>
+ <span class="n">foo</span><span class="p">();</span>
+<span class="p">}</span> <span class="k">catch</span> <span class="p">()</span> <span class="p">{</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">BeforeElse</span></tt> Wrap before <tt class="docutils literal"><span class="pre">else</span></tt>.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">foo</span><span class="p">())</span> <span class="p">{</span>
+<span class="p">}</span>
+<span class="k">else</span> <span class="p">{</span>
+<span class="p">}</span>
+
+<span class="kc">false</span><span class="o">:</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">foo</span><span class="p">())</span> <span class="p">{</span>
+<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">IndentBraces</span></tt> Indent the wrapped braces themselves.</p>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">SplitEmptyFunction</span></tt> If <tt class="docutils literal"><span class="pre">false</span></tt>, empty function body can be put on a single line.
+This option is used only if the opening brace of the function has
+already been wrapped, i.e. the <cite>AfterFunction</cite> brace wrapping mode is
+set, and the function could/should not be put on a single line (as per
+<cite>AllowShortFunctionsOnASingleLine</cite> and constructor formatting options).</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="kt">int</span> <span class="n">f</span><span class="p">()</span> <span class="n">vs</span><span class="p">.</span> <span class="n">inf</span> <span class="n">f</span><span class="p">()</span>
+<span class="p">{}</span> <span class="p">{</span>
+ <span class="p">}</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">SplitEmptyRecord</span></tt> If <tt class="docutils literal"><span class="pre">false</span></tt>, empty record (e.g. class, struct or union) body
+can be put on a single line. This option is used only if the opening
+brace of the record has already been wrapped, i.e. the <cite>AfterClass</cite>
+(for classes) brace wrapping mode is set.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">class</span> <span class="nc">Foo</span> <span class="n">vs</span><span class="p">.</span> <span class="k">class</span> <span class="nc">Foo</span>
+<span class="p">{}</span> <span class="p">{</span>
+ <span class="p">}</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">SplitEmptyNamespace</span></tt> If <tt class="docutils literal"><span class="pre">false</span></tt>, empty namespace body can be put on a single line.
+This option is used only if the opening brace of the namespace has
+already been wrapped, i.e. the <cite>AfterNamespace</cite> brace wrapping mode is
+set.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">namespace</span> <span class="n">Foo</span> <span class="n">vs</span><span class="p">.</span> <span class="k">namespace</span> <span class="n">Foo</span>
+<span class="p">{}</span> <span class="p">{</span>
+ <span class="p">}</span>
+</pre></div>
+</div>
+</li>
+</ul>
+</dd>
+<dt><strong>BreakAfterJavaFieldAnnotations</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">Break after each annotation on a field in Java files.</p>
+<div class="last highlight-java"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span> <span class="kc">false</span><span class="o">:</span>
+<span class="nd">@Partial</span> <span class="n">vs</span><span class="o">.</span> <span class="nd">@Partial</span> <span class="nd">@Mock</span> <span class="n">DataLoad</span> <span class="n">loader</span><span class="o">;</span>
+<span class="nd">@Mock</span>
+<span class="n">DataLoad</span> <span class="n">loader</span><span class="o">;</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>BreakBeforeBinaryOperators</strong> (<tt class="docutils literal"><span class="pre">BinaryOperatorStyle</span></tt>)</dt>
+<dd><p class="first">The way to wrap binary operators.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><tt class="docutils literal"><span class="pre">BOS_None</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">None</span></tt>)
+Break after operators.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="n">LooooooooooongType</span> <span class="n">loooooooooooooooooooooongVariable</span> <span class="o">=</span>
+ <span class="n">someLooooooooooooooooongFunction</span><span class="p">();</span>
+
+<span class="kt">bool</span> <span class="n">value</span> <span class="o">=</span> <span class="n">aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa</span> <span class="o">+</span>
+ <span class="n">aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa</span> <span class="o">==</span>
+ <span class="n">aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa</span> <span class="o">&&</span>
+ <span class="n">aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa</span> <span class="o">></span>
+ <span class="n">ccccccccccccccccccccccccccccccccccccccccc</span><span class="p">;</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">BOS_NonAssignment</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">NonAssignment</span></tt>)
+Break before operators that aren’t assignments.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="n">LooooooooooongType</span> <span class="n">loooooooooooooooooooooongVariable</span> <span class="o">=</span>
+ <span class="n">someLooooooooooooooooongFunction</span><span class="p">();</span>
+
+<span class="kt">bool</span> <span class="n">value</span> <span class="o">=</span> <span class="n">aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa</span>
+ <span class="o">+</span> <span class="n">aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa</span>
+ <span class="o">==</span> <span class="n">aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa</span>
+ <span class="o">&&</span> <span class="n">aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa</span>
+ <span class="o">></span> <span class="n">ccccccccccccccccccccccccccccccccccccccccc</span><span class="p">;</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">BOS_All</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">All</span></tt>)
+Break before operators.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="n">LooooooooooongType</span> <span class="n">loooooooooooooooooooooongVariable</span>
+ <span class="o">=</span> <span class="n">someLooooooooooooooooongFunction</span><span class="p">();</span>
+
+<span class="kt">bool</span> <span class="n">value</span> <span class="o">=</span> <span class="n">aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa</span>
+ <span class="o">+</span> <span class="n">aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa</span>
+ <span class="o">==</span> <span class="n">aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa</span>
+ <span class="o">&&</span> <span class="n">aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa</span>
+ <span class="o">></span> <span class="n">ccccccccccccccccccccccccccccccccccccccccc</span><span class="p">;</span>
+</pre></div>
+</div>
+</li>
+</ul>
+</dd>
+<dt><strong>BreakBeforeBraces</strong> (<tt class="docutils literal"><span class="pre">BraceBreakingStyle</span></tt>)</dt>
+<dd><p class="first">The brace breaking style to use.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><tt class="docutils literal"><span class="pre">BS_Attach</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Attach</span></tt>)
+Always attach braces to surrounding context.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">try</span> <span class="p">{</span>
+ <span class="n">foo</span><span class="p">();</span>
+<span class="p">}</span> <span class="k">catch</span> <span class="p">()</span> <span class="p">{</span>
+<span class="p">}</span>
+<span class="kt">void</span> <span class="n">foo</span><span class="p">()</span> <span class="p">{</span> <span class="n">bar</span><span class="p">();</span> <span class="p">}</span>
+<span class="k">class</span> <span class="nc">foo</span> <span class="p">{};</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">foo</span><span class="p">())</span> <span class="p">{</span>
+<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+<span class="p">}</span>
+<span class="k">enum</span> <span class="n">X</span> <span class="o">:</span> <span class="kt">int</span> <span class="p">{</span> <span class="n">A</span><span class="p">,</span> <span class="n">B</span> <span class="p">};</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">BS_Linux</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Linux</span></tt>)
+Like <tt class="docutils literal"><span class="pre">Attach</span></tt>, but break before braces on function, namespace and
+class definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">try</span> <span class="p">{</span>
+ <span class="n">foo</span><span class="p">();</span>
+<span class="p">}</span> <span class="k">catch</span> <span class="p">()</span> <span class="p">{</span>
+<span class="p">}</span>
+<span class="kt">void</span> <span class="n">foo</span><span class="p">()</span> <span class="p">{</span> <span class="n">bar</span><span class="p">();</span> <span class="p">}</span>
+<span class="k">class</span> <span class="nc">foo</span>
+<span class="p">{</span>
+<span class="p">};</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">foo</span><span class="p">())</span> <span class="p">{</span>
+<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+<span class="p">}</span>
+<span class="k">enum</span> <span class="n">X</span> <span class="o">:</span> <span class="kt">int</span> <span class="p">{</span> <span class="n">A</span><span class="p">,</span> <span class="n">B</span> <span class="p">};</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">BS_Mozilla</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Mozilla</span></tt>)
+Like <tt class="docutils literal"><span class="pre">Attach</span></tt>, but break before braces on enum, function, and record
+definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">try</span> <span class="p">{</span>
+ <span class="n">foo</span><span class="p">();</span>
+<span class="p">}</span> <span class="k">catch</span> <span class="p">()</span> <span class="p">{</span>
+<span class="p">}</span>
+<span class="kt">void</span> <span class="n">foo</span><span class="p">()</span> <span class="p">{</span> <span class="n">bar</span><span class="p">();</span> <span class="p">}</span>
+<span class="k">class</span> <span class="nc">foo</span>
+<span class="p">{</span>
+<span class="p">};</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">foo</span><span class="p">())</span> <span class="p">{</span>
+<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+<span class="p">}</span>
+<span class="k">enum</span> <span class="n">X</span> <span class="o">:</span> <span class="kt">int</span> <span class="p">{</span> <span class="n">A</span><span class="p">,</span> <span class="n">B</span> <span class="p">};</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">BS_Stroustrup</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Stroustrup</span></tt>)
+Like <tt class="docutils literal"><span class="pre">Attach</span></tt>, but break before function definitions, <tt class="docutils literal"><span class="pre">catch</span></tt>, and
+<tt class="docutils literal"><span class="pre">else</span></tt>.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">try</span> <span class="p">{</span>
+ <span class="n">foo</span><span class="p">();</span>
+<span class="p">}</span> <span class="k">catch</span> <span class="p">()</span> <span class="p">{</span>
+<span class="p">}</span>
+<span class="kt">void</span> <span class="n">foo</span><span class="p">()</span> <span class="p">{</span> <span class="n">bar</span><span class="p">();</span> <span class="p">}</span>
+<span class="k">class</span> <span class="nc">foo</span>
+<span class="p">{</span>
+<span class="p">};</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">foo</span><span class="p">())</span> <span class="p">{</span>
+<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+<span class="p">}</span>
+<span class="k">enum</span> <span class="n">X</span> <span class="o">:</span> <span class="kt">int</span>
+<span class="p">{</span>
+ <span class="n">A</span><span class="p">,</span>
+ <span class="n">B</span>
+<span class="p">};</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">BS_Allman</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Allman</span></tt>)
+Always break before braces.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">try</span> <span class="p">{</span>
+ <span class="n">foo</span><span class="p">();</span>
+<span class="p">}</span>
+<span class="k">catch</span> <span class="p">()</span> <span class="p">{</span>
+<span class="p">}</span>
+<span class="kt">void</span> <span class="n">foo</span><span class="p">()</span> <span class="p">{</span> <span class="n">bar</span><span class="p">();</span> <span class="p">}</span>
+<span class="k">class</span> <span class="nc">foo</span> <span class="p">{</span>
+<span class="p">};</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">foo</span><span class="p">())</span> <span class="p">{</span>
+<span class="p">}</span>
+<span class="k">else</span> <span class="p">{</span>
+<span class="p">}</span>
+<span class="k">enum</span> <span class="n">X</span> <span class="o">:</span> <span class="kt">int</span> <span class="p">{</span> <span class="n">A</span><span class="p">,</span> <span class="n">B</span> <span class="p">};</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">BS_GNU</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">GNU</span></tt>)
+Always break before braces and add an extra level of indentation to
+braces of control statements, not to those of class, function
+or other definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">try</span>
+ <span class="p">{</span>
+ <span class="n">foo</span><span class="p">();</span>
+ <span class="p">}</span>
+<span class="k">catch</span> <span class="p">()</span>
+ <span class="p">{</span>
+ <span class="p">}</span>
+<span class="kt">void</span> <span class="n">foo</span><span class="p">()</span> <span class="p">{</span> <span class="n">bar</span><span class="p">();</span> <span class="p">}</span>
+<span class="k">class</span> <span class="nc">foo</span>
+<span class="p">{</span>
+<span class="p">};</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">foo</span><span class="p">())</span>
+ <span class="p">{</span>
+ <span class="p">}</span>
+<span class="k">else</span>
+ <span class="p">{</span>
+ <span class="p">}</span>
+<span class="k">enum</span> <span class="n">X</span> <span class="o">:</span> <span class="kt">int</span>
+<span class="p">{</span>
+ <span class="n">A</span><span class="p">,</span>
+ <span class="n">B</span>
+<span class="p">};</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">BS_WebKit</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">WebKit</span></tt>)
+Like <tt class="docutils literal"><span class="pre">Attach</span></tt>, but break before functions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">try</span> <span class="p">{</span>
+ <span class="n">foo</span><span class="p">();</span>
+<span class="p">}</span> <span class="k">catch</span> <span class="p">()</span> <span class="p">{</span>
+<span class="p">}</span>
+<span class="kt">void</span> <span class="n">foo</span><span class="p">()</span> <span class="p">{</span> <span class="n">bar</span><span class="p">();</span> <span class="p">}</span>
+<span class="k">class</span> <span class="nc">foo</span> <span class="p">{</span>
+<span class="p">};</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">foo</span><span class="p">())</span> <span class="p">{</span>
+<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+<span class="p">}</span>
+<span class="k">enum</span> <span class="n">X</span> <span class="o">:</span> <span class="kt">int</span> <span class="p">{</span> <span class="n">A</span><span class="p">,</span> <span class="n">B</span> <span class="p">};</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">BS_Custom</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Custom</span></tt>)
+Configure each individual brace in <cite>BraceWrapping</cite>.</p>
+</li>
+</ul>
+</dd>
+<dt><strong>BreakBeforeInheritanceComma</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, in the class inheritance expression clang-format will
+break before <tt class="docutils literal"><span class="pre">:</span></tt> and <tt class="docutils literal"><span class="pre">,</span></tt> if there is multiple inheritance.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span> <span class="kc">false</span><span class="o">:</span>
+<span class="k">class</span> <span class="nc">MyClass</span> <span class="n">vs</span><span class="p">.</span> <span class="k">class</span> <span class="nc">MyClass</span> <span class="o">:</span> <span class="k">public</span> <span class="n">X</span><span class="p">,</span> <span class="k">public</span> <span class="n">Y</span> <span class="p">{</span>
+ <span class="o">:</span> <span class="k">public</span> <span class="n">X</span> <span class="p">};</span>
+ <span class="p">,</span> <span class="k">public</span> <span class="n">Y</span> <span class="p">{</span>
+<span class="p">};</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>BreakBeforeTernaryOperators</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, ternary operators will be placed after line breaks.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span>
+<span class="n">veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription</span>
+ <span class="o">?</span> <span class="n">firstValue</span>
+ <span class="o">:</span> <span class="n">SecondValueVeryVeryVeryVeryLong</span><span class="p">;</span>
+
+<span class="kc">false</span><span class="o">:</span>
+<span class="n">veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription</span> <span class="o">?</span>
+ <span class="n">firstValue</span> <span class="o">:</span>
+ <span class="n">SecondValueVeryVeryVeryVeryLong</span><span class="p">;</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>BreakConstructorInitializers</strong> (<tt class="docutils literal"><span class="pre">BreakConstructorInitializersStyle</span></tt>)</dt>
+<dd><p class="first">The constructor initializers style to use.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><tt class="docutils literal"><span class="pre">BCIS_BeforeColon</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">BeforeColon</span></tt>)
+Break constructor initializers before the colon and after the commas.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="n">Constructor</span><span class="p">()</span>
+ <span class="o">:</span> <span class="n">initializer1</span><span class="p">(),</span>
+ <span class="n">initializer2</span><span class="p">()</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">BCIS_BeforeComma</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">BeforeComma</span></tt>)
+Break constructor initializers before the colon and commas, and align
+the commas with the colon.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="n">Constructor</span><span class="p">()</span>
+ <span class="o">:</span> <span class="n">initializer1</span><span class="p">()</span>
+ <span class="p">,</span> <span class="n">initializer2</span><span class="p">()</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">BCIS_AfterColon</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">AfterColon</span></tt>)
+Break constructor initializers after the colon and commas.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="n">Constructor</span><span class="p">()</span> <span class="o">:</span>
+ <span class="n">initializer1</span><span class="p">(),</span>
+ <span class="n">initializer2</span><span class="p">()</span>
+</pre></div>
+</div>
+</li>
+</ul>
+</dd>
+<dt><strong>BreakStringLiterals</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd>Allow breaking string literals when formatting.</dd>
+<dt><strong>ColumnLimit</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd><p class="first">The column limit.</p>
+<p class="last">A column limit of <tt class="docutils literal"><span class="pre">0</span></tt> means that there is no column limit. In this case,
+clang-format will respect the input’s line breaking decisions within
+statements unless they contradict other rules.</p>
+</dd>
+<dt><strong>CommentPragmas</strong> (<tt class="docutils literal"><span class="pre">std::string</span></tt>)</dt>
+<dd><p class="first">A regular expression that describes comments with special meaning,
+which should not be split into lines or otherwise changed.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="cp">// CommentPragmas: '^ FOOBAR pragma:'</span>
+<span class="cp">// Will leave the following line unaffected</span>
+<span class="cp">#include <vector> </span><span class="c1">// FOOBAR pragma: keep</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>CompactNamespaces</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, consecutive namespace declarations will be on the same
+line. If <tt class="docutils literal"><span class="pre">false</span></tt>, each namespace is declared on a new line.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span>
+<span class="k">namespace</span> <span class="n">Foo</span> <span class="p">{</span> <span class="k">namespace</span> <span class="n">Bar</span> <span class="p">{</span>
+<span class="p">}}</span>
+
+<span class="kc">false</span><span class="o">:</span>
+<span class="k">namespace</span> <span class="n">Foo</span> <span class="p">{</span>
+<span class="k">namespace</span> <span class="n">Bar</span> <span class="p">{</span>
+<span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>If it does not fit on a single line, the overflowing namespaces get
+wrapped:</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="k">namespace</span> <span class="n">Foo</span> <span class="p">{</span> <span class="k">namespace</span> <span class="n">Bar</span> <span class="p">{</span>
+<span class="k">namespace</span> <span class="n">Extra</span> <span class="p">{</span>
+<span class="p">}}}</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>ConstructorInitializerAllOnOneLineOrOnePerLine</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If the constructor initializers don’t fit on a line, put each
+initializer on its own line.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span>
+<span class="n">SomeClass</span><span class="o">::</span><span class="n">Constructor</span><span class="p">()</span>
+ <span class="o">:</span> <span class="n">aaaaaaaa</span><span class="p">(</span><span class="n">aaaaaaaa</span><span class="p">),</span> <span class="n">aaaaaaaa</span><span class="p">(</span><span class="n">aaaaaaaa</span><span class="p">),</span> <span class="n">aaaaaaaa</span><span class="p">(</span><span class="n">aaaaaaaaaaaaaaaaaaaaaaaaa</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="kc">false</span><span class="o">:</span>
+<span class="n">SomeClass</span><span class="o">::</span><span class="n">Constructor</span><span class="p">()</span>
+ <span class="o">:</span> <span class="n">aaaaaaaa</span><span class="p">(</span><span class="n">aaaaaaaa</span><span class="p">),</span> <span class="n">aaaaaaaa</span><span class="p">(</span><span class="n">aaaaaaaa</span><span class="p">),</span>
+ <span class="n">aaaaaaaa</span><span class="p">(</span><span class="n">aaaaaaaaaaaaaaaaaaaaaaaaa</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>ConstructorInitializerIndentWidth</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd>The number of characters to use for indentation of constructor
+initializer lists.</dd>
+<dt><strong>ContinuationIndentWidth</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd><p class="first">Indent width for line continuations.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="nl">ContinuationIndentWidth:</span> <span class="mi">2</span>
+
+<span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="c1">// VeryVeryVeryVeryVeryLongComment</span>
+ <span class="n">longFunction</span><span class="p">(</span> <span class="c1">// Again a long comment</span>
+ <span class="n">arg</span><span class="p">);</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>Cpp11BracedListStyle</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, format braced lists as best suited for C++11 braced
+lists.</p>
+<p>Important differences:
+- No spaces inside the braced list.
+- No line break before the closing brace.
+- Indentation with the continuation indent, not with the block indent.</p>
+<p>Fundamentally, C++11 braced lists are formatted exactly like function
+calls would be formatted in their place. If the braced list follows a name
+(e.g. a type or variable name), clang-format formats as if the <tt class="docutils literal"><span class="pre">{}</span></tt> were
+the parentheses of a function call with that name. If there is no name,
+a zero-length name is assumed.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span> <span class="kc">false</span><span class="o">:</span>
+<span class="n">vector</span><span class="o"><</span><span class="kt">int</span><span class="o">></span> <span class="n">x</span><span class="p">{</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">};</span> <span class="n">vs</span><span class="p">.</span> <span class="n">vector</span><span class="o"><</span><span class="kt">int</span><span class="o">></span> <span class="n">x</span><span class="p">{</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span> <span class="p">};</span>
+<span class="n">vector</span><span class="o"><</span><span class="n">T</span><span class="o">></span> <span class="n">x</span><span class="p">{{},</span> <span class="p">{},</span> <span class="p">{},</span> <span class="p">{}};</span> <span class="n">vector</span><span class="o"><</span><span class="n">T</span><span class="o">></span> <span class="n">x</span><span class="p">{</span> <span class="p">{},</span> <span class="p">{},</span> <span class="p">{},</span> <span class="p">{}</span> <span class="p">};</span>
+<span class="n">f</span><span class="p">(</span><span class="n">MyMap</span><span class="p">[{</span><span class="n">composite</span><span class="p">,</span> <span class="n">key</span><span class="p">}]);</span> <span class="n">f</span><span class="p">(</span><span class="n">MyMap</span><span class="p">[{</span> <span class="n">composite</span><span class="p">,</span> <span class="n">key</span> <span class="p">}]);</span>
+<span class="k">new</span> <span class="kt">int</span><span class="p">[</span><span class="mi">3</span><span class="p">]{</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">};</span> <span class="k">new</span> <span class="kt">int</span><span class="p">[</span><span class="mi">3</span><span class="p">]{</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span> <span class="p">};</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>DerivePointerAlignment</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd>If <tt class="docutils literal"><span class="pre">true</span></tt>, analyze the formatted file for the most common
+alignment of <tt class="docutils literal"><span class="pre">&</span></tt> and <tt class="docutils literal"><span class="pre">*</span></tt>.
+Pointer and reference alignment styles are going to be updated according
+to the preferences found in the file.
+<tt class="docutils literal"><span class="pre">PointerAlignment</span></tt> is then used only as fallback.</dd>
+<dt><strong>DisableFormat</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd>Disables formatting completely.</dd>
+<dt><strong>ExperimentalAutoDetectBinPacking</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, clang-format detects whether function calls and
+definitions are formatted with one parameter per line.</p>
+<p>Each call can be bin-packed, one-per-line or inconclusive. If it is
+inconclusive, e.g. completely on one line, but a decision needs to be
+made, clang-format analyzes whether there are other bin-packed cases in
+the input file and act accordingly.</p>
+<p class="last">NOTE: This is an experimental flag, that might go away or be renamed. Do
+not use this in config files, etc. Use at your own risk.</p>
+</dd>
+<dt><strong>FixNamespaceComments</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, clang-format adds missing namespace end comments and
+fixes invalid existing ones.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span> <span class="kc">false</span><span class="o">:</span>
+<span class="k">namespace</span> <span class="n">a</span> <span class="p">{</span> <span class="n">vs</span><span class="p">.</span> <span class="k">namespace</span> <span class="n">a</span> <span class="p">{</span>
+<span class="n">foo</span><span class="p">();</span> <span class="n">foo</span><span class="p">();</span>
+<span class="p">}</span> <span class="c1">// namespace a; }</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>ForEachMacros</strong> (<tt class="docutils literal"><span class="pre">std::vector<std::string></span></tt>)</dt>
+<dd><p class="first">A vector of macros that should be interpreted as foreach loops
+instead of as function calls.</p>
+<p>These are expected to be macros of the form:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="n">FOREACH</span><span class="p">(</span><span class="o"><</span><span class="n">variable</span><span class="o">-</span><span class="n">declaration</span><span class="o">></span><span class="p">,</span> <span class="p">...)</span>
+ <span class="o"><</span><span class="n">loop</span><span class="o">-</span><span class="n">body</span><span class="o">></span>
+</pre></div>
+</div>
+<p>In the .clang-format configuration file, this can be configured like:</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="l-Scalar-Plain">ForEachMacros</span><span class="p-Indicator">:</span> <span class="p-Indicator">[</span><span class="s">'RANGES_FOR'</span><span class="p-Indicator">,</span> <span class="s">'FOREACH'</span><span class="p-Indicator">]</span>
+</pre></div>
+</div>
+<p class="last">For example: BOOST_FOREACH.</p>
+</dd>
+<dt><strong>IncludeBlocks</strong> (<tt class="docutils literal"><span class="pre">IncludeBlocksStyle</span></tt>)</dt>
+<dd><p class="first">Dependent on the value, multiple <tt class="docutils literal"><span class="pre">#include</span></tt> blocks can be sorted
+as one and divided based on category.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><tt class="docutils literal"><span class="pre">IBS_Preserve</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Preserve</span></tt>)
+Sort each <tt class="docutils literal"><span class="pre">#include</span></tt> block separately.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="cp">#include "b.h" into #include "b.h"</span>
+
+<span class="cp">#include <lib/main.h> #include "a.h"</span>
+<span class="cp">#include "a.h" #include <lib/main.h></span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">IBS_Merge</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Merge</span></tt>)
+Merge multiple <tt class="docutils literal"><span class="pre">#include</span></tt> blocks together and sort as one.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="cp">#include "b.h" into #include "a.h"</span>
+<span class="cp"> #include "b.h"</span>
+<span class="cp">#include <lib/main.h> #include <lib/main.h></span>
+<span class="cp">#include "a.h"</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">IBS_Regroup</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Regroup</span></tt>)
+Merge multiple <tt class="docutils literal"><span class="pre">#include</span></tt> blocks together and sort as one.
+Then split into groups based on category priority. See <tt class="docutils literal"><span class="pre">IncludeCategories</span></tt>.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="cp">#include "b.h" into #include "a.h"</span>
+<span class="cp"> #include "b.h"</span>
+<span class="cp">#include <lib/main.h></span>
+<span class="cp">#include "a.h" #include <lib/main.h></span>
+</pre></div>
+</div>
+</li>
+</ul>
+</dd>
+<dt><strong>IncludeCategories</strong> (<tt class="docutils literal"><span class="pre">std::vector<IncludeCategory></span></tt>)</dt>
+<dd><p class="first">Regular expressions denoting the different <tt class="docutils literal"><span class="pre">#include</span></tt> categories
+used for ordering <tt class="docutils literal"><span class="pre">#includes</span></tt>.</p>
+<p>These regular expressions are matched against the filename of an include
+(including the <> or “”) in order. The value belonging to the first
+matching regular expression is assigned and <tt class="docutils literal"><span class="pre">#includes</span></tt> are sorted first
+according to increasing category number and then alphabetically within
+each category.</p>
+<p>If none of the regular expressions match, INT_MAX is assigned as
+category. The main header for a source file automatically gets category 0.
+so that it is generally kept at the beginning of the <tt class="docutils literal"><span class="pre">#includes</span></tt>
+(<a class="reference external" href="http://llvm.org/docs/CodingStandards.html#include-style">http://llvm.org/docs/CodingStandards.html#include-style</a>). However, you
+can also assign negative priorities if you have certain headers that
+always need to be first.</p>
+<p>To configure this in the .clang-format file, use:</p>
+<div class="last highlight-yaml"><div class="highlight"><pre><span class="l-Scalar-Plain">IncludeCategories</span><span class="p-Indicator">:</span>
+ <span class="p-Indicator">-</span> <span class="l-Scalar-Plain">Regex</span><span class="p-Indicator">:</span> <span class="s">'^"(llvm|llvm-c|clang|clang-c)/'</span>
+ <span class="l-Scalar-Plain">Priority</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">2</span>
+ <span class="p-Indicator">-</span> <span class="l-Scalar-Plain">Regex</span><span class="p-Indicator">:</span> <span class="s">'^(<|"(gtest|gmock|isl|json)/)'</span>
+ <span class="l-Scalar-Plain">Priority</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">3</span>
+ <span class="p-Indicator">-</span> <span class="l-Scalar-Plain">Regex</span><span class="p-Indicator">:</span> <span class="s">'.*'</span>
+ <span class="l-Scalar-Plain">Priority</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">1</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>IncludeIsMainRegex</strong> (<tt class="docutils literal"><span class="pre">std::string</span></tt>)</dt>
+<dd><p class="first">Specify a regular expression of suffixes that are allowed in the
+file-to-main-include mapping.</p>
+<p>When guessing whether a #include is the “main” include (to assign
+category 0, see above), use this regex of allowed suffixes to the header
+stem. A partial match is done, so that:
+- “” means “arbitrary suffix”
+- “$” means “no suffix”</p>
+<p class="last">For example, if configured to “(_test)?$”, then a header a.h would be seen
+as the “main” include in both a.cc and a_test.cc.</p>
+</dd>
+<dt><strong>IndentCaseLabels</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">Indent case labels one level from the switch statement.</p>
+<p>When <tt class="docutils literal"><span class="pre">false</span></tt>, use the same indentation level as for the switch statement.
+Switch statement body is always indented one level more than case labels.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kc">false</span><span class="o">:</span> <span class="kc">true</span><span class="o">:</span>
+<span class="k">switch</span> <span class="p">(</span><span class="n">fool</span><span class="p">)</span> <span class="p">{</span> <span class="n">vs</span><span class="p">.</span> <span class="k">switch</span> <span class="p">(</span><span class="n">fool</span><span class="p">)</span> <span class="p">{</span>
+<span class="k">case</span> <span class="mi">1</span><span class="o">:</span> <span class="k">case</span> <span class="mi">1</span><span class="o">:</span>
+ <span class="n">bar</span><span class="p">();</span> <span class="n">bar</span><span class="p">();</span>
+ <span class="k">break</span><span class="p">;</span> <span class="k">break</span><span class="p">;</span>
+<span class="k">default</span><span class="o">:</span> <span class="k">default</span><span class="o">:</span>
+ <span class="n">plop</span><span class="p">();</span> <span class="n">plop</span><span class="p">();</span>
+<span class="p">}</span> <span class="p">}</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>IndentPPDirectives</strong> (<tt class="docutils literal"><span class="pre">PPDirectiveIndentStyle</span></tt>)</dt>
+<dd><p class="first">The preprocessor directive indenting style to use.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><tt class="docutils literal"><span class="pre">PPDIS_None</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">None</span></tt>)
+Does not indent any directives.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="cp">#if FOO</span>
+<span class="cp">#if BAR</span>
+<span class="cp">#include <foo></span>
+<span class="cp">#endif</span>
+<span class="cp">#endif</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">PPDIS_AfterHash</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">AfterHash</span></tt>)
+Indents directives after the hash.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="cp">#if FOO</span>
+<span class="cp"># if BAR</span>
+<span class="cp"># include <foo></span>
+<span class="cp"># endif</span>
+<span class="cp">#endif</span>
+</pre></div>
+</div>
+</li>
+</ul>
+</dd>
+<dt><strong>IndentWidth</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd><p class="first">The number of columns to use for indentation.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="nl">IndentWidth:</span> <span class="mi">3</span>
+
+<span class="kt">void</span> <span class="n">f</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">someFunction</span><span class="p">();</span>
+ <span class="k">if</span> <span class="p">(</span><span class="kc">true</span><span class="p">,</span> <span class="kc">false</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">f</span><span class="p">();</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>IndentWrappedFunctionNames</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">Indent if a function definition or declaration is wrapped after the
+type.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span>
+<span class="n">LoooooooooooooooooooooooooooooooooooooooongReturnType</span>
+ <span class="n">LoooooooooooooooooooooooooooooooongFunctionDeclaration</span><span class="p">();</span>
+
+<span class="kc">false</span><span class="o">:</span>
+<span class="n">LoooooooooooooooooooooooooooooooooooooooongReturnType</span>
+<span class="n">LoooooooooooooooooooooooooooooooongFunctionDeclaration</span><span class="p">();</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>JavaScriptQuotes</strong> (<tt class="docutils literal"><span class="pre">JavaScriptQuoteStyle</span></tt>)</dt>
+<dd><p class="first">The JavaScriptQuoteStyle to use for JavaScript strings.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><tt class="docutils literal"><span class="pre">JSQS_Leave</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Leave</span></tt>)
+Leave string quotes as they are.</p>
+<div class="highlight-js"><div class="highlight"><pre><span class="nx">string1</span> <span class="o">=</span> <span class="s2">"foo"</span><span class="p">;</span>
+<span class="nx">string2</span> <span class="o">=</span> <span class="s1">'bar'</span><span class="p">;</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">JSQS_Single</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Single</span></tt>)
+Always use single quotes.</p>
+<div class="highlight-js"><div class="highlight"><pre><span class="nx">string1</span> <span class="o">=</span> <span class="s1">'foo'</span><span class="p">;</span>
+<span class="nx">string2</span> <span class="o">=</span> <span class="s1">'bar'</span><span class="p">;</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">JSQS_Double</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Double</span></tt>)
+Always use double quotes.</p>
+<div class="highlight-js"><div class="highlight"><pre><span class="nx">string1</span> <span class="o">=</span> <span class="s2">"foo"</span><span class="p">;</span>
+<span class="nx">string2</span> <span class="o">=</span> <span class="s2">"bar"</span><span class="p">;</span>
+</pre></div>
+</div>
+</li>
+</ul>
+</dd>
+<dt><strong>JavaScriptWrapImports</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">Whether to wrap JavaScript import/export statements.</p>
+<div class="last highlight-js"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span>
+<span class="kr">import</span> <span class="p">{</span>
+ <span class="nx">VeryLongImportsAreAnnoying</span><span class="p">,</span>
+ <span class="nx">VeryLongImportsAreAnnoying</span><span class="p">,</span>
+ <span class="nx">VeryLongImportsAreAnnoying</span><span class="p">,</span>
+<span class="p">}</span> <span class="nx">from</span> <span class="s1">'some/module.js'</span>
+
+<span class="kc">false</span><span class="o">:</span>
+<span class="kr">import</span> <span class="p">{</span><span class="nx">VeryLongImportsAreAnnoying</span><span class="p">,</span> <span class="nx">VeryLongImportsAreAnnoying</span><span class="p">,</span> <span class="nx">VeryLongImportsAreAnnoying</span><span class="p">,}</span> <span class="nx">from</span> <span class="s2">"some/module.js"</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>KeepEmptyLinesAtTheStartOfBlocks</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If true, the empty line at the start of blocks is kept.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span> <span class="kc">false</span><span class="o">:</span>
+<span class="k">if</span> <span class="p">(</span><span class="n">foo</span><span class="p">)</span> <span class="p">{</span> <span class="n">vs</span><span class="p">.</span> <span class="k">if</span> <span class="p">(</span><span class="n">foo</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">bar</span><span class="p">();</span>
+ <span class="n">bar</span><span class="p">();</span> <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>Language</strong> (<tt class="docutils literal"><span class="pre">LanguageKind</span></tt>)</dt>
+<dd><p class="first">Language, this format style is targeted at.</p>
+<p>Possible values:</p>
+<ul class="last simple">
+<li><tt class="docutils literal"><span class="pre">LK_None</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">None</span></tt>)
+Do not use.</li>
+<li><tt class="docutils literal"><span class="pre">LK_Cpp</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Cpp</span></tt>)
+Should be used for C, C++.</li>
+<li><tt class="docutils literal"><span class="pre">LK_Java</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Java</span></tt>)
+Should be used for Java.</li>
+<li><tt class="docutils literal"><span class="pre">LK_JavaScript</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">JavaScript</span></tt>)
+Should be used for JavaScript.</li>
+<li><tt class="docutils literal"><span class="pre">LK_ObjC</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">ObjC</span></tt>)
+Should be used for Objective-C, Objective-C++.</li>
+<li><tt class="docutils literal"><span class="pre">LK_Proto</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Proto</span></tt>)
+Should be used for Protocol Buffers
+(<a class="reference external" href="https://developers.google.com/protocol-buffers/">https://developers.google.com/protocol-buffers/</a>).</li>
+<li><tt class="docutils literal"><span class="pre">LK_TableGen</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">TableGen</span></tt>)
+Should be used for TableGen code.</li>
+<li><tt class="docutils literal"><span class="pre">LK_TextProto</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">TextProto</span></tt>)
+Should be used for Protocol Buffer messages in text format
+(<a class="reference external" href="https://developers.google.com/protocol-buffers/">https://developers.google.com/protocol-buffers/</a>).</li>
+</ul>
+</dd>
+<dt><strong>MacroBlockBegin</strong> (<tt class="docutils literal"><span class="pre">std::string</span></tt>)</dt>
+<dd><p class="first">A regular expression matching macros that start a block.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="cp"># With:</span>
+<span class="nl">MacroBlockBegin:</span> <span class="s">"^NS_MAP_BEGIN|\</span>
+<span class="s">NS_TABLE_HEAD$"</span>
+<span class="nl">MacroBlockEnd:</span> <span class="s">"^\</span>
+<span class="s">NS_MAP_END|\</span>
+<span class="s">NS_TABLE_.*_END$"</span>
+
+<span class="n">NS_MAP_BEGIN</span>
+ <span class="n">foo</span><span class="p">();</span>
+<span class="n">NS_MAP_END</span>
+
+<span class="n">NS_TABLE_HEAD</span>
+ <span class="n">bar</span><span class="p">();</span>
+<span class="n">NS_TABLE_FOO_END</span>
+
+<span class="cp"># Without:</span>
+<span class="n">NS_MAP_BEGIN</span>
+<span class="n">foo</span><span class="p">();</span>
+<span class="n">NS_MAP_END</span>
+
+<span class="n">NS_TABLE_HEAD</span>
+<span class="n">bar</span><span class="p">();</span>
+<span class="n">NS_TABLE_FOO_END</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>MacroBlockEnd</strong> (<tt class="docutils literal"><span class="pre">std::string</span></tt>)</dt>
+<dd>A regular expression matching macros that end a block.</dd>
+<dt><strong>MaxEmptyLinesToKeep</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd><p class="first">The maximum number of consecutive empty lines to keep.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="nl">MaxEmptyLinesToKeep:</span> <span class="mi">1</span> <span class="n">vs</span><span class="p">.</span> <span class="nl">MaxEmptyLinesToKeep:</span> <span class="mi">0</span>
+<span class="kt">int</span> <span class="n">f</span><span class="p">()</span> <span class="p">{</span> <span class="kt">int</span> <span class="n">f</span><span class="p">()</span> <span class="p">{</span>
+ <span class="kt">int</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span> <span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span>
+ <span class="n">i</span> <span class="o">=</span> <span class="n">foo</span><span class="p">();</span>
+ <span class="n">i</span> <span class="o">=</span> <span class="n">foo</span><span class="p">();</span> <span class="k">return</span> <span class="n">i</span><span class="p">;</span>
+ <span class="p">}</span>
+ <span class="k">return</span> <span class="n">i</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>NamespaceIndentation</strong> (<tt class="docutils literal"><span class="pre">NamespaceIndentationKind</span></tt>)</dt>
+<dd><p class="first">The indentation used for namespaces.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><tt class="docutils literal"><span class="pre">NI_None</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">None</span></tt>)
+Don’t indent in namespaces.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">namespace</span> <span class="n">out</span> <span class="p">{</span>
+<span class="kt">int</span> <span class="n">i</span><span class="p">;</span>
+<span class="k">namespace</span> <span class="n">in</span> <span class="p">{</span>
+<span class="kt">int</span> <span class="n">i</span><span class="p">;</span>
+<span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">NI_Inner</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Inner</span></tt>)
+Indent only in inner namespaces (nested in other namespaces).</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">namespace</span> <span class="n">out</span> <span class="p">{</span>
+<span class="kt">int</span> <span class="n">i</span><span class="p">;</span>
+<span class="k">namespace</span> <span class="n">in</span> <span class="p">{</span>
+ <span class="kt">int</span> <span class="n">i</span><span class="p">;</span>
+<span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">NI_All</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">All</span></tt>)
+Indent in all namespaces.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">namespace</span> <span class="n">out</span> <span class="p">{</span>
+ <span class="kt">int</span> <span class="n">i</span><span class="p">;</span>
+ <span class="k">namespace</span> <span class="n">in</span> <span class="p">{</span>
+ <span class="kt">int</span> <span class="n">i</span><span class="p">;</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</li>
+</ul>
+</dd>
+<dt><strong>ObjCBlockIndentWidth</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd><p class="first">The number of characters to use for indentation of ObjC blocks.</p>
+<div class="last highlight-objc"><div class="highlight"><pre><span class="nl">ObjCBlockIndentWidth:</span> <span class="mi">4</span>
+
+<span class="p">[</span><span class="n">operation</span> <span class="nl">setCompletionBlock:</span><span class="o">^</span><span class="p">{</span>
+ <span class="p">[</span><span class="n">self</span> <span class="n">onOperationDone</span><span class="p">];</span>
+<span class="p">}];</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>ObjCSpaceAfterProperty</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd>Add a space after <tt class="docutils literal"><span class="pre">@property</span></tt> in Objective-C, i.e. use
+<tt class="docutils literal"><span class="pre">@property</span> <span class="pre">(readonly)</span></tt> instead of <tt class="docutils literal"><span class="pre">@property(readonly)</span></tt>.</dd>
+<dt><strong>ObjCSpaceBeforeProtocolList</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd>Add a space in front of an Objective-C protocol list, i.e. use
+<tt class="docutils literal"><span class="pre">Foo</span> <span class="pre"><Protocol></span></tt> instead of <tt class="docutils literal"><span class="pre">Foo<Protocol></span></tt>.</dd>
+<dt><strong>PenaltyBreakAssignment</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd>The penalty for breaking around an assignment operator.</dd>
+<dt><strong>PenaltyBreakBeforeFirstCallParameter</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd>The penalty for breaking a function call after <tt class="docutils literal"><span class="pre">call(</span></tt>.</dd>
+<dt><strong>PenaltyBreakComment</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd>The penalty for each line break introduced inside a comment.</dd>
+<dt><strong>PenaltyBreakFirstLessLess</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd>The penalty for breaking before the first <tt class="docutils literal"><span class="pre"><<</span></tt>.</dd>
+<dt><strong>PenaltyBreakString</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd>The penalty for each line break introduced inside a string literal.</dd>
+<dt><strong>PenaltyExcessCharacter</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd>The penalty for each character outside of the column limit.</dd>
+<dt><strong>PenaltyReturnTypeOnItsOwnLine</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd>Penalty for putting the return type of a function onto its own
+line.</dd>
+<dt><strong>PointerAlignment</strong> (<tt class="docutils literal"><span class="pre">PointerAlignmentStyle</span></tt>)</dt>
+<dd><p class="first">Pointer and reference alignment style.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><tt class="docutils literal"><span class="pre">PAS_Left</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Left</span></tt>)
+Align pointer to the left.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="kt">int</span><span class="o">*</span> <span class="n">a</span><span class="p">;</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">PAS_Right</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Right</span></tt>)
+Align pointer to the right.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="kt">int</span> <span class="o">*</span><span class="n">a</span><span class="p">;</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">PAS_Middle</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Middle</span></tt>)
+Align pointer in the middle.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="kt">int</span> <span class="o">*</span> <span class="n">a</span><span class="p">;</span>
+</pre></div>
+</div>
+</li>
+</ul>
+</dd>
+<dt><strong>RawStringFormats</strong> (<tt class="docutils literal"><span class="pre">std::vector<RawStringFormat></span></tt>)</dt>
+<dd><p class="first">Raw string delimiters denoting that the raw string contents are
+code in a particular language and can be reformatted.</p>
+<p>A raw string with a matching delimiter will be reformatted assuming the
+specified language based on a predefined style given by ‘BasedOnStyle’.
+If ‘BasedOnStyle’ is not found, the formatting is based on llvm style.</p>
+<p>To configure this in the .clang-format file, use:</p>
+<div class="last highlight-yaml"><div class="highlight"><pre><span class="l-Scalar-Plain">RawStringFormats</span><span class="p-Indicator">:</span>
+ <span class="p-Indicator">-</span> <span class="l-Scalar-Plain">Delimiter</span><span class="p-Indicator">:</span> <span class="s">'pb'</span>
+ <span class="l-Scalar-Plain">Language</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">TextProto</span>
+ <span class="l-Scalar-Plain">BasedOnStyle</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">llvm</span>
+ <span class="p-Indicator">-</span> <span class="l-Scalar-Plain">Delimiter</span><span class="p-Indicator">:</span> <span class="s">'proto'</span>
+ <span class="l-Scalar-Plain">Language</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">TextProto</span>
+ <span class="l-Scalar-Plain">BasedOnStyle</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">google</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>ReflowComments</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, clang-format will attempt to re-flow comments.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kc">false</span><span class="o">:</span>
+<span class="c1">// veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information</span>
+<span class="cm">/* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information */</span>
+
+<span class="kc">true</span><span class="o">:</span>
+<span class="c1">// veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of</span>
+<span class="c1">// information</span>
+<span class="cm">/* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of</span>
+<span class="cm"> * information */</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>SortIncludes</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, clang-format will sort <tt class="docutils literal"><span class="pre">#includes</span></tt>.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kc">false</span><span class="o">:</span> <span class="kc">true</span><span class="o">:</span>
+<span class="cp">#include "b.h" vs. #include "a.h"</span>
+<span class="cp">#include "a.h" #include "b.h"</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>SortUsingDeclarations</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, clang-format will sort using declarations.</p>
+<p>The order of using declarations is defined as follows:
+Split the strings by ”::” and discard any initial empty strings. The last
+element of each list is a non-namespace name; all others are namespace
+names. Sort the lists of names lexicographically, where the sort order of
+individual names is that all non-namespace names come before all namespace
+names, and within those groups, names are in case-insensitive
+lexicographic order.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kc">false</span><span class="o">:</span> <span class="kc">true</span><span class="o">:</span>
+<span class="k">using</span> <span class="n">std</span><span class="o">::</span><span class="n">cout</span><span class="p">;</span> <span class="n">vs</span><span class="p">.</span> <span class="k">using</span> <span class="n">std</span><span class="o">::</span><span class="n">cin</span><span class="p">;</span>
+<span class="k">using</span> <span class="n">std</span><span class="o">::</span><span class="n">cin</span><span class="p">;</span> <span class="k">using</span> <span class="n">std</span><span class="o">::</span><span class="n">cout</span><span class="p">;</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>SpaceAfterCStyleCast</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, a space is inserted after C style casts.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span> <span class="kc">false</span><span class="o">:</span>
+<span class="p">(</span><span class="kt">int</span><span class="p">)</span><span class="n">i</span><span class="p">;</span> <span class="n">vs</span><span class="p">.</span> <span class="p">(</span><span class="kt">int</span><span class="p">)</span> <span class="n">i</span><span class="p">;</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>SpaceAfterTemplateKeyword</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, a space will be inserted after the ‘template’ keyword.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span> <span class="kc">false</span><span class="o">:</span>
+<span class="k">template</span> <span class="o"><</span><span class="kt">int</span><span class="o">></span> <span class="kt">void</span> <span class="n">foo</span><span class="p">();</span> <span class="n">vs</span><span class="p">.</span> <span class="k">template</span><span class="o"><</span><span class="kt">int</span><span class="o">></span> <span class="kt">void</span> <span class="n">foo</span><span class="p">();</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>SpaceBeforeAssignmentOperators</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">false</span></tt>, spaces will be removed before assignment operators.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span> <span class="kc">false</span><span class="o">:</span>
+<span class="kt">int</span> <span class="n">a</span> <span class="o">=</span> <span class="mi">5</span><span class="p">;</span> <span class="n">vs</span><span class="p">.</span> <span class="kt">int</span> <span class="n">a</span><span class="o">=</span><span class="mi">5</span><span class="p">;</span>
+<span class="n">a</span> <span class="o">+=</span> <span class="mi">42</span> <span class="n">a</span><span class="o">+=</span><span class="mi">42</span><span class="p">;</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>SpaceBeforeParens</strong> (<tt class="docutils literal"><span class="pre">SpaceBeforeParensOptions</span></tt>)</dt>
+<dd><p class="first">Defines in which cases to put a space before opening parentheses.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><tt class="docutils literal"><span class="pre">SBPO_Never</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Never</span></tt>)
+Never put a space before opening parentheses.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="kt">void</span> <span class="n">f</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">if</span><span class="p">(</span><span class="kc">true</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">f</span><span class="p">();</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">SBPO_ControlStatements</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">ControlStatements</span></tt>)
+Put a space before opening parentheses only after control statement
+keywords (<tt class="docutils literal"><span class="pre">for/if/while...</span></tt>).</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="kt">void</span> <span class="n">f</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="kc">true</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">f</span><span class="p">();</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">SBPO_Always</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Always</span></tt>)
+Always put a space before opening parentheses, except when it’s
+prohibited by the syntax rules (in function-like macro definitions) or
+when determined by other style rules (after unary operators, opening
+parentheses, etc.)</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="kt">void</span> <span class="n">f</span> <span class="p">()</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="kc">true</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">f</span> <span class="p">();</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</li>
+</ul>
+</dd>
+<dt><strong>SpaceInEmptyParentheses</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, spaces may be inserted into <tt class="docutils literal"><span class="pre">()</span></tt>.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span> <span class="kc">false</span><span class="o">:</span>
+<span class="kt">void</span> <span class="n">f</span><span class="p">(</span> <span class="p">)</span> <span class="p">{</span> <span class="n">vs</span><span class="p">.</span> <span class="kt">void</span> <span class="n">f</span><span class="p">()</span> <span class="p">{</span>
+ <span class="kt">int</span> <span class="n">x</span><span class="p">[]</span> <span class="o">=</span> <span class="p">{</span><span class="n">foo</span><span class="p">(</span> <span class="p">),</span> <span class="n">bar</span><span class="p">(</span> <span class="p">)};</span> <span class="kt">int</span> <span class="n">x</span><span class="p">[]</span> <span class="o">=</span> <span class="p">{</span><span class="n">foo</span><span class="p">(),</span> <span class="n">bar</span><span class="p">()};</span>
+ <span class="k">if</span> <span class="p">(</span><span class="kc">true</span><span class="p">)</span> <span class="p">{</span> <span class="k">if</span> <span class="p">(</span><span class="kc">true</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">f</span><span class="p">(</span> <span class="p">);</span> <span class="n">f</span><span class="p">();</span>
+ <span class="p">}</span> <span class="p">}</span>
+<span class="p">}</span> <span class="p">}</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>SpacesBeforeTrailingComments</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd><p class="first">The number of spaces before trailing line comments
+(<tt class="docutils literal"><span class="pre">//</span></tt> - comments).</p>
+<p>This does not affect trailing block comments (<tt class="docutils literal"><span class="pre">/*</span></tt> - comments) as
+those commonly have different usage patterns and a number of special
+cases.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="nl">SpacesBeforeTrailingComments:</span> <span class="mi">3</span>
+<span class="kt">void</span> <span class="n">f</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="kc">true</span><span class="p">)</span> <span class="p">{</span> <span class="c1">// foo1</span>
+ <span class="n">f</span><span class="p">();</span> <span class="c1">// bar</span>
+ <span class="p">}</span> <span class="c1">// foo</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>SpacesInAngles</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, spaces will be inserted after <tt class="docutils literal"><span class="pre"><</span></tt> and before <tt class="docutils literal"><span class="pre">></span></tt>
+in template argument lists.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span> <span class="kc">false</span><span class="o">:</span>
+<span class="k">static_cast</span><span class="o"><</span> <span class="kt">int</span> <span class="o">></span><span class="p">(</span><span class="n">arg</span><span class="p">);</span> <span class="n">vs</span><span class="p">.</span> <span class="k">static_cast</span><span class="o"><</span><span class="kt">int</span><span class="o">></span><span class="p">(</span><span class="n">arg</span><span class="p">);</span>
+<span class="n">std</span><span class="o">::</span><span class="n">function</span><span class="o"><</span> <span class="kt">void</span><span class="p">(</span><span class="kt">int</span><span class="p">)</span> <span class="o">></span> <span class="n">fct</span><span class="p">;</span> <span class="n">std</span><span class="o">::</span><span class="n">function</span><span class="o"><</span><span class="kt">void</span><span class="p">(</span><span class="kt">int</span><span class="p">)</span><span class="o">></span> <span class="n">fct</span><span class="p">;</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>SpacesInCStyleCastParentheses</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, spaces may be inserted into C style casts.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span> <span class="kc">false</span><span class="o">:</span>
+<span class="n">x</span> <span class="o">=</span> <span class="p">(</span> <span class="n">int32</span> <span class="p">)</span><span class="n">y</span> <span class="n">vs</span><span class="p">.</span> <span class="n">x</span> <span class="o">=</span> <span class="p">(</span><span class="n">int32</span><span class="p">)</span><span class="n">y</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>SpacesInContainerLiterals</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, spaces are inserted inside container literals (e.g.
+ObjC and Javascript array and dict literals).</p>
+<div class="last highlight-js"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span> <span class="kc">false</span><span class="o">:</span>
+<span class="kd">var</span> <span class="nx">arr</span> <span class="o">=</span> <span class="p">[</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span> <span class="p">];</span> <span class="nx">vs</span><span class="p">.</span> <span class="kd">var</span> <span class="nx">arr</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">];</span>
+<span class="nx">f</span><span class="p">({</span><span class="nx">a</span> <span class="o">:</span> <span class="mi">1</span><span class="p">,</span> <span class="nx">b</span> <span class="o">:</span> <span class="mi">2</span><span class="p">,</span> <span class="nx">c</span> <span class="o">:</span> <span class="mi">3</span><span class="p">});</span> <span class="nx">f</span><span class="p">({</span><span class="nx">a</span><span class="o">:</span> <span class="mi">1</span><span class="p">,</span> <span class="nx">b</span><span class="o">:</span> <span class="mi">2</span><span class="p">,</span> <span class="nx">c</span><span class="o">:</span> <span class="mi">3</span><span class="p">});</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>SpacesInParentheses</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, spaces will be inserted after <tt class="docutils literal"><span class="pre">(</span></tt> and before <tt class="docutils literal"><span class="pre">)</span></tt>.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span> <span class="kc">false</span><span class="o">:</span>
+<span class="n">t</span> <span class="n">f</span><span class="p">(</span> <span class="n">Deleted</span> <span class="o">&</span> <span class="p">)</span> <span class="o">&</span> <span class="o">=</span> <span class="k">delete</span><span class="p">;</span> <span class="n">vs</span><span class="p">.</span> <span class="n">t</span> <span class="n">f</span><span class="p">(</span><span class="n">Deleted</span> <span class="o">&</span><span class="p">)</span> <span class="o">&</span> <span class="o">=</span> <span class="k">delete</span><span class="p">;</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>SpacesInSquareBrackets</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, spaces will be inserted after <tt class="docutils literal"><span class="pre">[</span></tt> and before <tt class="docutils literal"><span class="pre">]</span></tt>.
+Lambdas or unspecified size array declarations will not be affected.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span class="kc">true</span><span class="o">:</span> <span class="kc">false</span><span class="o">:</span>
+<span class="kt">int</span> <span class="n">a</span><span class="p">[</span> <span class="mi">5</span> <span class="p">];</span> <span class="n">vs</span><span class="p">.</span> <span class="kt">int</span> <span class="n">a</span><span class="p">[</span><span class="mi">5</span><span class="p">];</span>
+<span class="n">std</span><span class="o">::</span><span class="n">unique_ptr</span><span class="o"><</span><span class="kt">int</span><span class="p">[]</span><span class="o">></span> <span class="n">foo</span><span class="p">()</span> <span class="p">{}</span> <span class="c1">// Won't be affected</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>Standard</strong> (<tt class="docutils literal"><span class="pre">LanguageStandard</span></tt>)</dt>
+<dd><p class="first">Format compatible with this standard, e.g. use <tt class="docutils literal"><span class="pre">A<A<int></span> <span class="pre">></span></tt>
+instead of <tt class="docutils literal"><span class="pre">A<A<int>></span></tt> for <tt class="docutils literal"><span class="pre">LS_Cpp03</span></tt>.</p>
+<p>Possible values:</p>
+<ul class="last simple">
+<li><tt class="docutils literal"><span class="pre">LS_Cpp03</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Cpp03</span></tt>)
+Use C++03-compatible syntax.</li>
+<li><tt class="docutils literal"><span class="pre">LS_Cpp11</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Cpp11</span></tt>)
+Use features of C++11, C++14 and C++1z (e.g. <tt class="docutils literal"><span class="pre">A<A<int>></span></tt> instead of
+<tt class="docutils literal"><span class="pre">A<A<int></span> <span class="pre">></span></tt>).</li>
+<li><tt class="docutils literal"><span class="pre">LS_Auto</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Auto</span></tt>)
+Automatic detection based on the input.</li>
+</ul>
+</dd>
+<dt><strong>TabWidth</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd>The number of columns used for tab stops.</dd>
+<dt><strong>UseTab</strong> (<tt class="docutils literal"><span class="pre">UseTabStyle</span></tt>)</dt>
+<dd><p class="first">The way to use tab characters in the resulting file.</p>
+<p>Possible values:</p>
+<ul class="last simple">
+<li><tt class="docutils literal"><span class="pre">UT_Never</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Never</span></tt>)
+Never use tab.</li>
+<li><tt class="docutils literal"><span class="pre">UT_ForIndentation</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">ForIndentation</span></tt>)
+Use tabs only for indentation.</li>
+<li><tt class="docutils literal"><span class="pre">UT_ForContinuationAndIndentation</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">ForContinuationAndIndentation</span></tt>)
+Use tabs only for line continuation and indentation.</li>
+<li><tt class="docutils literal"><span class="pre">UT_Always</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Always</span></tt>)
+Use tabs whenever we need to fill whitespace that spans at least from
+one tab stop to the next one.</li>
+</ul>
+</dd>
+</dl>
+</div>
+<div class="section" id="adding-additional-style-options">
+<h2>Adding additional style options<a class="headerlink" href="#adding-additional-style-options" title="Permalink to this headline">¶</a></h2>
+<p>Each additional style option adds costs to the clang-format project. Some of
+these costs affect the clang-format development itself, as we need to make
+sure that any given combination of options work and that new features don’t
+break any of the existing options in any way. There are also costs for end users
+as options become less discoverable and people have to think about and make a
+decision on options they don’t really care about.</p>
+<p>The goal of the clang-format project is more on the side of supporting a
+limited set of styles really well as opposed to supporting every single style
+used by a codebase somewhere in the wild. Of course, we do want to support all
+major projects and thus have established the following bar for adding style
+options. Each new style option must ..</p>
+<blockquote>
+<div><ul class="simple">
+<li>be used in a project of significant size (have dozens of contributors)</li>
+<li>have a publicly accessible style guide</li>
+<li>have a person willing to contribute and maintain patches</li>
+</ul>
+</div></blockquote>
+</div>
+<div class="section" id="examples">
+<h2>Examples<a class="headerlink" href="#examples" title="Permalink to this headline">¶</a></h2>
+<p>A style similar to the <a class="reference external" href="https://www.kernel.org/doc/Documentation/CodingStyle">Linux Kernel style</a>:</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="l-Scalar-Plain">BasedOnStyle</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">LLVM</span>
+<span class="l-Scalar-Plain">IndentWidth</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">8</span>
+<span class="l-Scalar-Plain">UseTab</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">Always</span>
+<span class="l-Scalar-Plain">BreakBeforeBraces</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">Linux</span>
+<span class="l-Scalar-Plain">AllowShortIfStatementsOnASingleLine</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">false</span>
+<span class="l-Scalar-Plain">IndentCaseLabels</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">false</span>
+</pre></div>
+</div>
+<p>The result is (imagine that tabs are used for indentation here):</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="kt">void</span> <span class="n">test</span><span class="p">()</span>
+<span class="p">{</span>
+ <span class="k">switch</span> <span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">case</span> <span class="mi">0</span><span class="o">:</span>
+ <span class="k">case</span> <span class="mi">1</span><span class="o">:</span>
+ <span class="n">do_something</span><span class="p">();</span>
+ <span class="k">break</span><span class="p">;</span>
+ <span class="k">case</span> <span class="mi">2</span><span class="o">:</span>
+ <span class="n">do_something_else</span><span class="p">();</span>
+ <span class="k">break</span><span class="p">;</span>
+ <span class="k">default</span><span class="o">:</span>
+ <span class="k">break</span><span class="p">;</span>
+ <span class="p">}</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">condition</span><span class="p">)</span>
+ <span class="n">do_something_completely_different</span><span class="p">();</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">x</span> <span class="o">==</span> <span class="n">y</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">q</span><span class="p">();</span>
+ <span class="p">}</span> <span class="k">else</span> <span class="k">if</span> <span class="p">(</span><span class="n">x</span> <span class="o">></span> <span class="n">y</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">w</span><span class="p">();</span>
+ <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+ <span class="n">r</span><span class="p">();</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>A style similar to the default Visual Studio formatting style:</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="l-Scalar-Plain">UseTab</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">Never</span>
+<span class="l-Scalar-Plain">IndentWidth</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">4</span>
+<span class="l-Scalar-Plain">BreakBeforeBraces</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">Allman</span>
+<span class="l-Scalar-Plain">AllowShortIfStatementsOnASingleLine</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">false</span>
+<span class="l-Scalar-Plain">IndentCaseLabels</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">false</span>
+<span class="l-Scalar-Plain">ColumnLimit</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">0</span>
+</pre></div>
+</div>
+<p>The result is:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="kt">void</span> <span class="n">test</span><span class="p">()</span>
+<span class="p">{</span>
+ <span class="k">switch</span> <span class="p">(</span><span class="n">suffix</span><span class="p">)</span>
+ <span class="p">{</span>
+ <span class="k">case</span> <span class="mi">0</span><span class="o">:</span>
+ <span class="k">case</span> <span class="mi">1</span><span class="o">:</span>
+ <span class="n">do_something</span><span class="p">();</span>
+ <span class="k">break</span><span class="p">;</span>
+ <span class="k">case</span> <span class="mi">2</span><span class="o">:</span>
+ <span class="n">do_something_else</span><span class="p">();</span>
+ <span class="k">break</span><span class="p">;</span>
+ <span class="k">default</span><span class="o">:</span>
+ <span class="k">break</span><span class="p">;</span>
+ <span class="p">}</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">condition</span><span class="p">)</span>
+ <span class="n">do_somthing_completely_different</span><span class="p">();</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">x</span> <span class="o">==</span> <span class="n">y</span><span class="p">)</span>
+ <span class="p">{</span>
+ <span class="n">q</span><span class="p">();</span>
+ <span class="p">}</span>
+ <span class="k">else</span> <span class="k">if</span> <span class="p">(</span><span class="n">x</span> <span class="o">></span> <span class="n">y</span><span class="p">)</span>
+ <span class="p">{</span>
+ <span class="n">w</span><span class="p">();</span>
+ <span class="p">}</span>
+ <span class="k">else</span>
+ <span class="p">{</span>
+ <span class="n">r</span><span class="p">();</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</div>
+</div>
+
+
+ </div>
+ <div class="bottomnav">
+
+ <p>
+ « <a href="ClangFormat.html">ClangFormat</a>
+ ::
+ <a class="uplink" href="index.html">Contents</a>
+ ::
+ <a href="InternalsManual.html">“Clang” CFE Internals Manual</a> »
+ </p>
+
+ </div>
+
+ <div class="footer">
+ © Copyright 2007-2018, The Clang Team.
+ Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/6.0.1/tools/clang/docs/ClangPlugins.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/6.0.1/tools/clang/docs/ClangPlugins.html?rev=336152&view=auto
==============================================================================
--- www-releases/trunk/6.0.1/tools/clang/docs/ClangPlugins.html (added)
+++ www-releases/trunk/6.0.1/tools/clang/docs/ClangPlugins.html Mon Jul 2 16:21:43 2018
@@ -0,0 +1,186 @@
+
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+ <title>Clang Plugins — Clang 6 documentation</title>
+
+ <link rel="stylesheet" href="_static/haiku.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+ <link rel="stylesheet" href="_static/print.css" type="text/css" />
+
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: '',
+ VERSION: '6',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true
+ };
+ </script>
+ <script type="text/javascript" src="_static/jquery.js"></script>
+ <script type="text/javascript" src="_static/underscore.js"></script>
+ <script type="text/javascript" src="_static/doctools.js"></script>
+ <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+ <script type="text/javascript" src="_static/theme_extras.js"></script>
+ <link rel="top" title="Clang 6 documentation" href="index.html" />
+ <link rel="next" title="How to write RecursiveASTVisitor based ASTFrontendActions." href="RAVFrontendAction.html" />
+ <link rel="prev" title="LibFormat" href="LibFormat.html" />
+ </head>
+ <body>
+ <div class="header"><h1 class="heading"><a href="index.html">
+ <span>Clang 6 documentation</span></a></h1>
+ <h2 class="heading"><span>Clang Plugins</span></h2>
+ </div>
+ <div class="topnav">
+
+ <p>
+ « <a href="LibFormat.html">LibFormat</a>
+ ::
+ <a class="uplink" href="index.html">Contents</a>
+ ::
+ <a href="RAVFrontendAction.html">How to write RecursiveASTVisitor based ASTFrontendActions.</a> »
+ </p>
+
+ </div>
+ <div class="content">
+
+
+ <div class="section" id="clang-plugins">
+<h1>Clang Plugins<a class="headerlink" href="#clang-plugins" title="Permalink to this headline">¶</a></h1>
+<p>Clang Plugins make it possible to run extra user defined actions during a
+compilation. This document will provide a basic walkthrough of how to write and
+run a Clang Plugin.</p>
+<div class="section" id="introduction">
+<h2>Introduction<a class="headerlink" href="#introduction" title="Permalink to this headline">¶</a></h2>
+<p>Clang Plugins run FrontendActions over code. See the <a class="reference internal" href="RAVFrontendAction.html"><em>FrontendAction
+tutorial</em></a> on how to write a <tt class="docutils literal"><span class="pre">FrontendAction</span></tt> using the
+<tt class="docutils literal"><span class="pre">RecursiveASTVisitor</span></tt>. In this tutorial, we’ll demonstrate how to write a
+simple clang plugin.</p>
+</div>
+<div class="section" id="writing-a-pluginastaction">
+<h2>Writing a <tt class="docutils literal"><span class="pre">PluginASTAction</span></tt><a class="headerlink" href="#writing-a-pluginastaction" title="Permalink to this headline">¶</a></h2>
+<p>The main difference from writing normal <tt class="docutils literal"><span class="pre">FrontendActions</span></tt> is that you can
+handle plugin command line options. The <tt class="docutils literal"><span class="pre">PluginASTAction</span></tt> base class declares
+a <tt class="docutils literal"><span class="pre">ParseArgs</span></tt> method which you have to implement in your plugin.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="kt">bool</span> <span class="n">ParseArgs</span><span class="p">(</span><span class="k">const</span> <span class="n">CompilerInstance</span> <span class="o">&</span><span class="n">CI</span><span class="p">,</span>
+ <span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">>&</span> <span class="n">args</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">for</span> <span class="p">(</span><span class="kt">unsigned</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">,</span> <span class="n">e</span> <span class="o">=</span> <span class="n">args</span><span class="p">.</span><span class="n">size</span><span class="p">();</span> <span class="n">i</span> <span class="o">!=</span> <span class="n">e</span><span class="p">;</span> <span class="o">++</span><span class="n">i</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">args</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">==</span> <span class="s">"-some-arg"</span><span class="p">)</span> <span class="p">{</span>
+ <span class="c1">// Handle the command line argument.</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+ <span class="k">return</span> <span class="kc">true</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="registering-a-plugin">
+<h2>Registering a plugin<a class="headerlink" href="#registering-a-plugin" title="Permalink to this headline">¶</a></h2>
+<p>A plugin is loaded from a dynamic library at runtime by the compiler. To
+register a plugin in a library, use <tt class="docutils literal"><span class="pre">FrontendPluginRegistry::Add<></span></tt>:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">static</span> <span class="n">FrontendPluginRegistry</span><span class="o">::</span><span class="n">Add</span><span class="o"><</span><span class="n">MyPlugin</span><span class="o">></span> <span class="n">X</span><span class="p">(</span><span class="s">"my-plugin-name"</span><span class="p">,</span> <span class="s">"my plugin description"</span><span class="p">);</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="defining-pragmas">
+<h2>Defining pragmas<a class="headerlink" href="#defining-pragmas" title="Permalink to this headline">¶</a></h2>
+<p>Plugins can also define pragmas by declaring a <tt class="docutils literal"><span class="pre">PragmaHandler</span></tt> and
+registering it using <tt class="docutils literal"><span class="pre">PragmaHandlerRegistry::Add<></span></tt>:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">// Define a pragma handler for #pragma example_pragma</span>
+<span class="k">class</span> <span class="nc">ExamplePragmaHandler</span> <span class="o">:</span> <span class="k">public</span> <span class="n">PragmaHandler</span> <span class="p">{</span>
+<span class="k">public</span><span class="o">:</span>
+ <span class="n">ExamplePragmaHandler</span><span class="p">()</span> <span class="o">:</span> <span class="n">PragmaHandler</span><span class="p">(</span><span class="s">"example_pragma"</span><span class="p">)</span> <span class="p">{</span> <span class="p">}</span>
+ <span class="kt">void</span> <span class="n">HandlePragma</span><span class="p">(</span><span class="n">Preprocessor</span> <span class="o">&</span><span class="n">PP</span><span class="p">,</span> <span class="n">PragmaIntroducerKind</span> <span class="n">Introducer</span><span class="p">,</span>
+ <span class="n">Token</span> <span class="o">&</span><span class="n">PragmaTok</span><span class="p">)</span> <span class="p">{</span>
+ <span class="c1">// Handle the pragma</span>
+ <span class="p">}</span>
+<span class="p">};</span>
+
+<span class="k">static</span> <span class="n">PragmaHandlerRegistry</span><span class="o">::</span><span class="n">Add</span><span class="o"><</span><span class="n">ExamplePragmaHandler</span><span class="o">></span> <span class="n">Y</span><span class="p">(</span><span class="s">"example_pragma"</span><span class="p">,</span><span class="s">"example pragma description"</span><span class="p">);</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="putting-it-all-together">
+<h2>Putting it all together<a class="headerlink" href="#putting-it-all-together" title="Permalink to this headline">¶</a></h2>
+<p>Let’s look at an example plugin that prints top-level function names. This
+example is checked into the clang repository; please take a look at
+the <a class="reference external" href="http://llvm.org/viewvc/llvm-project/cfe/trunk/examples/PrintFunctionNames/PrintFunctionNames.cpp?view=markup">latest version of PrintFunctionNames.cpp</a>.</p>
+</div>
+<div class="section" id="running-the-plugin">
+<h2>Running the plugin<a class="headerlink" href="#running-the-plugin" title="Permalink to this headline">¶</a></h2>
+<div class="section" id="using-the-cc1-command-line">
+<h3>Using the cc1 command line<a class="headerlink" href="#using-the-cc1-command-line" title="Permalink to this headline">¶</a></h3>
+<p>To run a plugin, the dynamic library containing the plugin registry must be
+loaded via the <cite>-load</cite> command line option. This will load all plugins
+that are registered, and you can select the plugins to run by specifying the
+<cite>-plugin</cite> option. Additional parameters for the plugins can be passed with
+<cite>-plugin-arg-<plugin-name></cite>.</p>
+<p>Note that those options must reach clang’s cc1 process. There are two
+ways to do so:</p>
+<ul class="simple">
+<li>Directly call the parsing process by using the <cite>-cc1</cite> option; this
+has the downside of not configuring the default header search paths, so
+you’ll need to specify the full system path configuration on the command
+line.</li>
+<li>Use clang as usual, but prefix all arguments to the cc1 process with
+<cite>-Xclang</cite>.</li>
+</ul>
+<p>For example, to run the <tt class="docutils literal"><span class="pre">print-function-names</span></tt> plugin over a source file in
+clang, first build the plugin, and then call clang with the plugin from the
+source tree:</p>
+<div class="highlight-console"><div class="highlight"><pre><span class="gp">$</span> <span class="nb">export </span><span class="nv">BD</span><span class="o">=</span>/path/to/build/directory
+<span class="gp">$</span> <span class="o">(</span><span class="nb">cd</span> <span class="nv">$BD</span> <span class="o">&&</span> make PrintFunctionNames <span class="o">)</span>
+<span class="gp">$</span> clang++ -D_GNU_SOURCE -D_DEBUG -D__STDC_CONSTANT_MACROS <span class="se">\</span>
+<span class="go"> -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -D_GNU_SOURCE \</span>
+<span class="go"> -I$BD/tools/clang/include -Itools/clang/include -I$BD/include -Iinclude \</span>
+<span class="go"> tools/clang/tools/clang-check/ClangCheck.cpp -fsyntax-only \</span>
+<span class="go"> -Xclang -load -Xclang $BD/lib/PrintFunctionNames.so -Xclang \</span>
+<span class="go"> -plugin -Xclang print-fns</span>
+</pre></div>
+</div>
+<p>Also see the print-function-name plugin example’s
+<a class="reference external" href="http://llvm.org/viewvc/llvm-project/cfe/trunk/examples/PrintFunctionNames/README.txt?view=markup">README</a></p>
+</div>
+<div class="section" id="using-the-clang-command-line">
+<h3>Using the clang command line<a class="headerlink" href="#using-the-clang-command-line" title="Permalink to this headline">¶</a></h3>
+<p>Using <cite>-fplugin=plugin</cite> on the clang command line passes the plugin
+through as an argument to <cite>-load</cite> on the cc1 command line. If the plugin
+class implements the <tt class="docutils literal"><span class="pre">getActionType</span></tt> method then the plugin is run
+automatically. For example, to run the plugin automatically after the main AST
+action (i.e. the same as using <cite>-add-plugin</cite>):</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="c1">// Automatically run the plugin after the main AST action</span>
+<span class="n">PluginASTAction</span><span class="o">::</span><span class="n">ActionType</span> <span class="n">getActionType</span><span class="p">()</span> <span class="n">override</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="n">AddAfterMainAction</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</div>
+</div>
+</div>
+
+
+ </div>
+ <div class="bottomnav">
+
+ <p>
+ « <a href="LibFormat.html">LibFormat</a>
+ ::
+ <a class="uplink" href="index.html">Contents</a>
+ ::
+ <a href="RAVFrontendAction.html">How to write RecursiveASTVisitor based ASTFrontendActions.</a> »
+ </p>
+
+ </div>
+
+ <div class="footer">
+ © Copyright 2007-2018, The Clang Team.
+ Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/6.0.1/tools/clang/docs/ClangTools.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/6.0.1/tools/clang/docs/ClangTools.html?rev=336152&view=auto
==============================================================================
--- www-releases/trunk/6.0.1/tools/clang/docs/ClangTools.html (added)
+++ www-releases/trunk/6.0.1/tools/clang/docs/ClangTools.html Mon Jul 2 16:21:43 2018
@@ -0,0 +1,224 @@
+
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+ <title>Overview — Clang 6 documentation</title>
+
+ <link rel="stylesheet" href="_static/haiku.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+ <link rel="stylesheet" href="_static/print.css" type="text/css" />
+
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: '',
+ VERSION: '6',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true
+ };
+ </script>
+ <script type="text/javascript" src="_static/jquery.js"></script>
+ <script type="text/javascript" src="_static/underscore.js"></script>
+ <script type="text/javascript" src="_static/doctools.js"></script>
+ <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+ <script type="text/javascript" src="_static/theme_extras.js"></script>
+ <link rel="top" title="Clang 6 documentation" href="index.html" />
+ <link rel="next" title="ClangCheck" href="ClangCheck.html" />
+ <link rel="prev" title="Clangâs refactoring engine" href="RefactoringEngine.html" />
+ </head>
+ <body>
+ <div class="header"><h1 class="heading"><a href="index.html">
+ <span>Clang 6 documentation</span></a></h1>
+ <h2 class="heading"><span>Overview</span></h2>
+ </div>
+ <div class="topnav">
+
+ <p>
+ « <a href="RefactoringEngine.html">Clang’s refactoring engine</a>
+ ::
+ <a class="uplink" href="index.html">Contents</a>
+ ::
+ <a href="ClangCheck.html">ClangCheck</a> »
+ </p>
+
+ </div>
+ <div class="content">
+
+
+ <div class="section" id="overview">
+<h1>Overview<a class="headerlink" href="#overview" title="Permalink to this headline">¶</a></h1>
+<p>Clang Tools are standalone command line (and potentially GUI) tools
+designed for use by C++ developers who are already using and enjoying
+Clang as their compiler. These tools provide developer-oriented
+functionality such as fast syntax checking, automatic formatting,
+refactoring, etc.</p>
+<p>Only a couple of the most basic and fundamental tools are kept in the
+primary Clang Subversion project. The rest of the tools are kept in a
+side-project so that developers who don’t want or need to build them
+don’t. If you want to get access to the extra Clang Tools repository,
+simply check it out into the tools tree of your Clang checkout and
+follow the usual process for building and working with a combined
+LLVM/Clang checkout:</p>
+<ul class="simple">
+<li>With Subversion:<ul>
+<li><tt class="docutils literal"><span class="pre">cd</span> <span class="pre">llvm/tools/clang/tools</span></tt></li>
+<li><tt class="docutils literal"><span class="pre">svn</span> <span class="pre">co</span> <span class="pre">http://llvm.org/svn/llvm-project/clang-tools-extra/trunk</span> <span class="pre">extra</span></tt></li>
+</ul>
+</li>
+<li>Or with Git:<ul>
+<li><tt class="docutils literal"><span class="pre">cd</span> <span class="pre">llvm/tools/clang/tools</span></tt></li>
+<li><tt class="docutils literal"><span class="pre">git</span> <span class="pre">clone</span> <span class="pre">http://llvm.org/git/clang-tools-extra.git</span> <span class="pre">extra</span></tt></li>
+</ul>
+</li>
+</ul>
+<p>This document describes a high-level overview of the organization of
+Clang Tools within the project as well as giving an introduction to some
+of the more important tools. However, it should be noted that this
+document is currently focused on Clang and Clang Tool developers, not on
+end users of these tools.</p>
+<div class="section" id="clang-tools-organization">
+<h2>Clang Tools Organization<a class="headerlink" href="#clang-tools-organization" title="Permalink to this headline">¶</a></h2>
+<p>Clang Tools are CLI or GUI programs that are intended to be directly
+used by C++ developers. That is they are <em>not</em> primarily for use by
+Clang developers, although they are hopefully useful to C++ developers
+who happen to work on Clang, and we try to actively dogfood their
+functionality. They are developed in three components: the underlying
+infrastructure for building a standalone tool based on Clang, core
+shared logic used by many different tools in the form of refactoring and
+rewriting libraries, and the tools themselves.</p>
+<p>The underlying infrastructure for Clang Tools is the
+<a class="reference internal" href="LibTooling.html"><em>LibTooling</em></a> platform. See its documentation for much
+more detailed information about how this infrastructure works. The
+common refactoring and rewriting toolkit-style library is also part of
+LibTooling organizationally.</p>
+<p>A few Clang Tools are developed along side the core Clang libraries as
+examples and test cases of fundamental functionality. However, most of
+the tools are developed in a side repository to provide easy separation
+from the core libraries. We intentionally do not support public
+libraries in the side repository, as we want to carefully review and
+find good APIs for libraries as they are lifted out of a few tools and
+into the core Clang library set.</p>
+<p>Regardless of which repository Clang Tools’ code resides in, the
+development process and practices for all Clang Tools are exactly those
+of Clang itself. They are entirely within the Clang <em>project</em>,
+regardless of the version control scheme.</p>
+</div>
+<div class="section" id="core-clang-tools">
+<h2>Core Clang Tools<a class="headerlink" href="#core-clang-tools" title="Permalink to this headline">¶</a></h2>
+<p>The core set of Clang tools that are within the main repository are
+tools that very specifically complement, and allow use and testing of
+<em>Clang</em> specific functionality.</p>
+<div class="section" id="clang-check">
+<h3><tt class="docutils literal"><span class="pre">clang-check</span></tt><a class="headerlink" href="#clang-check" title="Permalink to this headline">¶</a></h3>
+<p><a class="reference internal" href="ClangCheck.html"><em>ClangCheck</em></a> combines the LibTooling framework for running a
+Clang tool with the basic Clang diagnostics by syntax checking specific files
+in a fast, command line interface. It can also accept flags to re-display the
+diagnostics in different formats with different flags, suitable for use driving
+an IDE or editor. Furthermore, it can be used in fixit-mode to directly apply
+fixit-hints offered by clang. See <a class="reference internal" href="HowToSetupToolingForLLVM.html"><em>How To Setup Clang Tooling For LLVM</em></a> for
+instructions on how to setup and used <cite>clang-check</cite>.</p>
+</div>
+<div class="section" id="clang-format">
+<h3><tt class="docutils literal"><span class="pre">clang-format</span></tt><a class="headerlink" href="#clang-format" title="Permalink to this headline">¶</a></h3>
+<p>Clang-format is both a <a class="reference internal" href="LibFormat.html"><em>library</em></a> and a <a class="reference internal" href="ClangFormat.html"><em>stand-alone tool</em></a> with the goal of automatically reformatting C++ sources files
+according to configurable style guides. To do so, clang-format uses Clang’s
+<tt class="docutils literal"><span class="pre">Lexer</span></tt> to transform an input file into a token stream and then changes all
+the whitespace around those tokens. The goal is for clang-format to serve both
+as a user tool (ideally with powerful IDE integrations) and as part of other
+refactoring tools, e.g. to do a reformatting of all the lines changed during a
+renaming.</p>
+</div>
+</div>
+<div class="section" id="extra-clang-tools">
+<h2>Extra Clang Tools<a class="headerlink" href="#extra-clang-tools" title="Permalink to this headline">¶</a></h2>
+<p>As various categories of Clang Tools are added to the extra repository,
+they’ll be tracked here. The focus of this documentation is on the scope
+and features of the tools for other tool developers; each tool should
+provide its own user-focused documentation.</p>
+<div class="section" id="clang-tidy">
+<h3><tt class="docutils literal"><span class="pre">clang-tidy</span></tt><a class="headerlink" href="#clang-tidy" title="Permalink to this headline">¶</a></h3>
+<p><a class="reference external" href="http://clang.llvm.org/extra/clang-tidy/">clang-tidy</a> is a clang-based C++
+linter tool. It provides an extensible framework for building compiler-based
+static analyses detecting and fixing bug-prone patterns, performance,
+portability and maintainability issues.</p>
+</div>
+</div>
+<div class="section" id="ideas-for-new-tools">
+<h2>Ideas for new Tools<a class="headerlink" href="#ideas-for-new-tools" title="Permalink to this headline">¶</a></h2>
+<ul>
+<li><p class="first">C++ cast conversion tool. Will convert C-style casts (<tt class="docutils literal"><span class="pre">(type)</span> <span class="pre">value</span></tt>) to
+appropriate C++ cast (<tt class="docutils literal"><span class="pre">static_cast</span></tt>, <tt class="docutils literal"><span class="pre">const_cast</span></tt> or
+<tt class="docutils literal"><span class="pre">reinterpret_cast</span></tt>).</p>
+</li>
+<li><p class="first">Non-member <tt class="docutils literal"><span class="pre">begin()</span></tt> and <tt class="docutils literal"><span class="pre">end()</span></tt> conversion tool. Will convert
+<tt class="docutils literal"><span class="pre">foo.begin()</span></tt> into <tt class="docutils literal"><span class="pre">begin(foo)</span></tt> and similarly for <tt class="docutils literal"><span class="pre">end()</span></tt>, where
+<tt class="docutils literal"><span class="pre">foo</span></tt> is a standard container. We could also detect similar patterns for
+arrays.</p>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">tr1</span></tt> removal tool. Will migrate source code from using TR1 library
+features to C++11 library. For example:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="cp">#include <tr1/unordered_map></span>
+<span class="kt">int</span> <span class="n">main</span><span class="p">()</span>
+<span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">tr1</span><span class="o">::</span><span class="n">unordered_map</span> <span class="o"><</span><span class="kt">int</span><span class="p">,</span> <span class="kt">int</span><span class="o">></span> <span class="n">ma</span><span class="p">;</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">ma</span><span class="p">.</span><span class="n">size</span> <span class="p">()</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>should be rewritten to:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="cp">#include <unordered_map></span>
+<span class="kt">int</span> <span class="n">main</span><span class="p">()</span>
+<span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">unordered_map</span> <span class="o"><</span><span class="kt">int</span><span class="p">,</span> <span class="kt">int</span><span class="o">></span> <span class="n">ma</span><span class="p">;</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">ma</span><span class="p">.</span><span class="n">size</span> <span class="p">()</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first">A tool to remove <tt class="docutils literal"><span class="pre">auto</span></tt>. Will convert <tt class="docutils literal"><span class="pre">auto</span></tt> to an explicit type or add
+comments with deduced types. The motivation is that there are developers
+that don’t want to use <tt class="docutils literal"><span class="pre">auto</span></tt> because they are afraid that they might lose
+control over their code.</p>
+</li>
+<li><p class="first">C++14: less verbose operator function objects (<a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3421.htm">N3421</a>).
+For example:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="n">sort</span><span class="p">(</span><span class="n">v</span><span class="p">.</span><span class="n">begin</span><span class="p">(),</span> <span class="n">v</span><span class="p">.</span><span class="n">end</span><span class="p">(),</span> <span class="n">greater</span><span class="o"><</span><span class="n">ValueType</span><span class="o">></span><span class="p">());</span>
+</pre></div>
+</div>
+<p>should be rewritten to:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="n">sort</span><span class="p">(</span><span class="n">v</span><span class="p">.</span><span class="n">begin</span><span class="p">(),</span> <span class="n">v</span><span class="p">.</span><span class="n">end</span><span class="p">(),</span> <span class="n">greater</span><span class="o"><></span><span class="p">());</span>
+</pre></div>
+</div>
+</li>
+</ul>
+</div>
+</div>
+
+
+ </div>
+ <div class="bottomnav">
+
+ <p>
+ « <a href="RefactoringEngine.html">Clang’s refactoring engine</a>
+ ::
+ <a class="uplink" href="index.html">Contents</a>
+ ::
+ <a href="ClangCheck.html">ClangCheck</a> »
+ </p>
+
+ </div>
+
+ <div class="footer">
+ © Copyright 2007-2018, The Clang Team.
+ Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/6.0.1/tools/clang/docs/CommandGuide/clang.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/6.0.1/tools/clang/docs/CommandGuide/clang.html?rev=336152&view=auto
==============================================================================
--- www-releases/trunk/6.0.1/tools/clang/docs/CommandGuide/clang.html (added)
+++ www-releases/trunk/6.0.1/tools/clang/docs/CommandGuide/clang.html Mon Jul 2 16:21:43 2018
@@ -0,0 +1,709 @@
+
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+ <title>clang - the Clang C, C++, and Objective-C compiler — Clang 6 documentation</title>
+
+ <link rel="stylesheet" href="../_static/haiku.css" type="text/css" />
+ <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
+ <link rel="stylesheet" href="../_static/print.css" type="text/css" />
+
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: '../',
+ VERSION: '6',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true
+ };
+ </script>
+ <script type="text/javascript" src="../_static/jquery.js"></script>
+ <script type="text/javascript" src="../_static/underscore.js"></script>
+ <script type="text/javascript" src="../_static/doctools.js"></script>
+ <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+ <script type="text/javascript" src="../_static/theme_extras.js"></script>
+ <link rel="top" title="Clang 6 documentation" href="../index.html" />
+ <link rel="up" title="Clang âmanâ pages" href="index.html" />
+ <link rel="next" title="Frequently Asked Questions (FAQ)" href="../FAQ.html" />
+ <link rel="prev" title="Clang âmanâ pages" href="index.html" />
+ </head>
+ <body>
+ <div class="header"><h1 class="heading"><a href="../index.html">
+ <span>Clang 6 documentation</span></a></h1>
+ <h2 class="heading"><span>clang - the Clang C, C++, and Objective-C compiler</span></h2>
+ </div>
+ <div class="topnav">
+
+ <p>
+ « <a href="index.html">Clang “man” pages</a>
+ ::
+ <a class="uplink" href="../index.html">Contents</a>
+ ::
+ <a href="../FAQ.html">Frequently Asked Questions (FAQ)</a> »
+ </p>
+
+ </div>
+ <div class="content">
+
+
+ <div class="section" id="clang-the-clang-c-c-and-objective-c-compiler">
+<h1>clang - the Clang C, C++, and Objective-C compiler<a class="headerlink" href="#clang-the-clang-c-c-and-objective-c-compiler" title="Permalink to this headline">¶</a></h1>
+<div class="section" id="synopsis">
+<h2>SYNOPSIS<a class="headerlink" href="#synopsis" title="Permalink to this headline">¶</a></h2>
+<p><strong class="program">clang</strong> [<em>options</em>] <em>filename ...</em></p>
+</div>
+<div class="section" id="description">
+<h2>DESCRIPTION<a class="headerlink" href="#description" title="Permalink to this headline">¶</a></h2>
+<p><strong class="program">clang</strong> 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. While Clang is highly integrated, it is important to
+understand the stages of compilation, to understand how to invoke it. These
+stages are:</p>
+<dl class="docutils">
+<dt>Driver</dt>
+<dd>The clang executable is actually a small driver which controls the overall
+execution of other tools such as the compiler, assembler and linker.
+Typically you do not need to interact with the driver, but you
+transparently use it to run the other tools.</dd>
+<dt>Preprocessing</dt>
+<dd>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.</dd>
+<dt>Parsing and Semantic Analysis</dt>
+<dd>This stage parses the input file, translating preprocessor tokens into a
+parse tree. Once in the form of a parse tree, it applies semantic
+analysis to compute types for expressions as well and determine whether
+the code is well formed. This stage is responsible for generating most of
+the compiler warnings as well as parse errors. The output of this stage is
+an “Abstract Syntax Tree” (AST).</dd>
+<dt>Code Generation and Optimization</dt>
+<dd><p class="first">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.</p>
+<p class="last">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 target assembler.</p>
+</dd>
+<dt>Assembler</dt>
+<dd>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.</dd>
+<dt>Linker</dt>
+<dd>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.</dd>
+</dl>
+<p><strong class="program">Clang Static Analyzer</strong></p>
+<p>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 <<a class="reference external" href="http://clang-analyzer.llvm.org">http://clang-analyzer.llvm.org</a>> for more details
+on how to use the static analyzer.</p>
+</div>
+<div class="section" id="options">
+<h2>OPTIONS<a class="headerlink" href="#options" title="Permalink to this headline">¶</a></h2>
+<div class="section" id="stage-selection-options">
+<h3>Stage Selection Options<a class="headerlink" href="#stage-selection-options" title="Permalink to this headline">¶</a></h3>
+<dl class="option">
+<dt id="cmdoption-E">
+<tt class="descname">-E</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-E" title="Permalink to this definition">¶</a></dt>
+<dd><p>Run the preprocessor stage.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fsyntax-only">
+<tt class="descname">-fsyntax-only</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-fsyntax-only" title="Permalink to this definition">¶</a></dt>
+<dd><p>Run the preprocessor, parser and type checking stages.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-S">
+<tt class="descname">-S</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-S" title="Permalink to this definition">¶</a></dt>
+<dd><p>Run the previous stages as well as LLVM generation and optimization stages
+and target-specific code generation, producing an assembly file.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-c">
+<tt class="descname">-c</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-c" title="Permalink to this definition">¶</a></dt>
+<dd><p>Run all of the above, plus the assembler, generating a target ”.o” object file.</p>
+</dd></dl>
+
+<dl class="option">
+<dt>
+<tt class="descname">no stage selection option</tt></dt>
+<dd><p>If no stage selection option is specified, all stages above are run, and the
+linker is run to combine the results into an executable or shared library.</p>
+</dd></dl>
+
+</div>
+<div class="section" id="language-selection-and-mode-options">
+<h3>Language Selection and Mode Options<a class="headerlink" href="#language-selection-and-mode-options" title="Permalink to this headline">¶</a></h3>
+<dl class="option">
+<dt id="cmdoption-x">
+<tt class="descname">-x</tt><tt class="descclassname"> <language></tt><a class="headerlink" href="#cmdoption-x" title="Permalink to this definition">¶</a></dt>
+<dd><p>Treat subsequent input files as having type language.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-std">
+<tt class="descname">-std</tt><tt class="descclassname">=<language></tt><a class="headerlink" href="#cmdoption-std" title="Permalink to this definition">¶</a></dt>
+<dd><p>Specify the language standard to compile for.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-stdlib">
+<tt class="descname">-stdlib</tt><tt class="descclassname">=<library></tt><a class="headerlink" href="#cmdoption-stdlib" title="Permalink to this definition">¶</a></dt>
+<dd><p>Specify the C++ standard library to use; supported options are libstdc++ and
+libc++. If not specified, platform default will be used.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-rtlib">
+<tt class="descname">-rtlib</tt><tt class="descclassname">=<library></tt><a class="headerlink" href="#cmdoption-rtlib" title="Permalink to this definition">¶</a></dt>
+<dd><p>Specify the compiler runtime library to use; supported options are libgcc and
+compiler-rt. If not specified, platform default will be used.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-ansi">
+<tt class="descname">-ansi</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-ansi" title="Permalink to this definition">¶</a></dt>
+<dd><p>Same as -std=c89.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-ObjC">
+<tt class="descname">-ObjC</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-ObjC</tt><tt class="descclassname">++</tt><a class="headerlink" href="#cmdoption-ObjC" title="Permalink to this definition">¶</a></dt>
+<dd><p>Treat source input files as Objective-C and Object-C++ inputs respectively.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-trigraphs">
+<tt class="descname">-trigraphs</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-trigraphs" title="Permalink to this definition">¶</a></dt>
+<dd><p>Enable trigraphs.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-ffreestanding">
+<tt class="descname">-ffreestanding</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-ffreestanding" title="Permalink to this definition">¶</a></dt>
+<dd><p>Indicate that the file should be compiled for a freestanding, not a hosted,
+environment.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fno-builtin">
+<tt class="descname">-fno-builtin</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-fno-builtin" title="Permalink to this definition">¶</a></dt>
+<dd><p>Disable special handling and optimizations of builtin functions like
+<tt class="xref c c-func docutils literal"><span class="pre">strlen()</span></tt> and <tt class="xref c c-func docutils literal"><span class="pre">malloc()</span></tt>.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fmath-errno">
+<tt class="descname">-fmath-errno</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-fmath-errno" title="Permalink to this definition">¶</a></dt>
+<dd><p>Indicate that math functions should be treated as updating <tt class="xref c c-data docutils literal"><span class="pre">errno</span></tt>.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fpascal-strings">
+<tt class="descname">-fpascal-strings</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-fpascal-strings" title="Permalink to this definition">¶</a></dt>
+<dd><p>Enable support for Pascal-style strings with “\pfoo”.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fms-extensions">
+<tt class="descname">-fms-extensions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-fms-extensions" title="Permalink to this definition">¶</a></dt>
+<dd><p>Enable support for Microsoft extensions.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fmsc-version">
+<tt class="descname">-fmsc-version</tt><tt class="descclassname">=</tt><a class="headerlink" href="#cmdoption-fmsc-version" title="Permalink to this definition">¶</a></dt>
+<dd><p>Set _MSC_VER. Defaults to 1300 on Windows. Not set otherwise.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fborland-extensions">
+<tt class="descname">-fborland-extensions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-fborland-extensions" title="Permalink to this definition">¶</a></dt>
+<dd><p>Enable support for Borland extensions.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fwritable-strings">
+<tt class="descname">-fwritable-strings</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-fwritable-strings" title="Permalink to this definition">¶</a></dt>
+<dd><p>Make all string literals default to writable. This disables uniquing of
+strings and other optimizations.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-flax-vector-conversions">
+<tt class="descname">-flax-vector-conversions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-flax-vector-conversions" title="Permalink to this definition">¶</a></dt>
+<dd><p>Allow loose type checking rules for implicit vector conversions.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fblocks">
+<tt class="descname">-fblocks</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-fblocks" title="Permalink to this definition">¶</a></dt>
+<dd><p>Enable the “Blocks” language feature.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fobjc-abi-version">
+<tt class="descname">-fobjc-abi-version</tt><tt class="descclassname">=version</tt><a class="headerlink" href="#cmdoption-fobjc-abi-version" title="Permalink to this definition">¶</a></dt>
+<dd><p>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).</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fobjc-nonfragile-abi-version">
+<tt class="descname">-fobjc-nonfragile-abi-version</tt><tt class="descclassname">=<version></tt><a class="headerlink" href="#cmdoption-fobjc-nonfragile-abi-version" title="Permalink to this definition">¶</a></dt>
+<dd><p>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-fragile ABI is enabled
+(either via <a class="reference internal" href="#cmdoption-fobjc-nonfragile-abi"><em class="xref std std-option">-fobjc-nonfragile-abi</em></a>, or because it is the platform
+default).</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fobjc-nonfragile-abi">
+<tt class="descname">-fobjc-nonfragile-abi</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-objc-nonfragile-abi</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-fobjc-nonfragile-abi" title="Permalink to this definition">¶</a></dt>
+<dd><p>Enable use of the Objective-C non-fragile ABI. On platforms for which this is
+the default ABI, it can be disabled with <em class="xref std std-option">-fno-objc-nonfragile-abi</em>.</p>
+</dd></dl>
+
+</div>
+<div class="section" id="target-selection-options">
+<h3>Target Selection Options<a class="headerlink" href="#target-selection-options" title="Permalink to this headline">¶</a></h3>
+<p>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.</p>
+<dl class="option">
+<dt id="cmdoption-arch">
+<tt class="descname">-arch</tt><tt class="descclassname"> <architecture></tt><a class="headerlink" href="#cmdoption-arch" title="Permalink to this definition">¶</a></dt>
+<dd><p>Specify the architecture to build for.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-mmacosx-version-min">
+<tt class="descname">-mmacosx-version-min</tt><tt class="descclassname">=<version></tt><a class="headerlink" href="#cmdoption-mmacosx-version-min" title="Permalink to this definition">¶</a></dt>
+<dd><p>When building for Mac OS X, specify the minimum version supported by your
+application.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-miphoneos-version-min">
+<tt class="descname">-miphoneos-version-min</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-miphoneos-version-min" title="Permalink to this definition">¶</a></dt>
+<dd><p>When building for iPhone OS, specify the minimum version supported by your
+application.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-march">
+<tt class="descname">-march</tt><tt class="descclassname">=<cpu></tt><a class="headerlink" href="#cmdoption-march" title="Permalink to this definition">¶</a></dt>
+<dd><p>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.</p>
+</dd></dl>
+
+</div>
+<div class="section" id="code-generation-options">
+<h3>Code Generation Options<a class="headerlink" href="#code-generation-options" title="Permalink to this headline">¶</a></h3>
+<dl class="option">
+<dt id="cmdoption-O0">
+<tt class="descname">-O0</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-O1</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-O2</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-O3</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-Ofast</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-Os</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-Oz</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-Og</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-O</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-O4</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-O0" title="Permalink to this definition">¶</a></dt>
+<dd><p>Specify which optimization level to use:</p>
+<blockquote>
+<div><p><a class="reference internal" href="#cmdoption-O0"><em class="xref std std-option">-O0</em></a> Means “no optimization”: this level compiles the fastest and
+generates the most debuggable code.</p>
+<p><em class="xref std std-option">-O1</em> Somewhere between <a class="reference internal" href="#cmdoption-O0"><em class="xref std std-option">-O0</em></a> and <em class="xref std std-option">-O2</em>.</p>
+<p><em class="xref std std-option">-O2</em> Moderate level of optimization which enables most
+optimizations.</p>
+<p><em class="xref std std-option">-O3</em> Like <em class="xref std std-option">-O2</em>, 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).</p>
+<p><em class="xref std std-option">-Ofast</em> Enables all the optimizations from <em class="xref std std-option">-O3</em> along
+with other aggressive optimizations that may violate strict compliance with
+language standards.</p>
+<p><em class="xref std std-option">-Os</em> Like <em class="xref std std-option">-O2</em> with extra optimizations to reduce code
+size.</p>
+<p><em class="xref std std-option">-Oz</em> Like <em class="xref std std-option">-Os</em> (and thus <em class="xref std std-option">-O2</em>), but reduces code
+size further.</p>
+<p><em class="xref std std-option">-Og</em> Like <em class="xref std std-option">-O1</em>. In future versions, this option might
+disable different optimizations in order to improve debuggability.</p>
+<p><em class="xref std std-option">-O</em> Equivalent to <em class="xref std std-option">-O2</em>.</p>
+<p><em class="xref std std-option">-O4</em> and higher</p>
+<blockquote>
+<div>Currently equivalent to <em class="xref std std-option">-O3</em></div></blockquote>
+</div></blockquote>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-g">
+<tt class="descname">-g</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-gline-tables-only</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-gmodules</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-g" title="Permalink to this definition">¶</a></dt>
+<dd><p>Control debug information output. Note that Clang debug information works
+best at <a class="reference internal" href="#cmdoption-O0"><em class="xref std std-option">-O0</em></a>. When more than one option starting with <cite>-g</cite> is
+specified, the last one wins:</p>
+<blockquote>
+<div><p><a class="reference internal" href="../UsersManual.html#cmdoption-g"><em class="xref std std-option">-g</em></a> Generate debug information.</p>
+<p><a class="reference internal" href="../UsersManual.html#cmdoption-gline-tables-only"><em class="xref std std-option">-gline-tables-only</em></a> Generate only line table debug information. This
+allows for symbolicated backtraces with inlining information, but does not
+include any information about variables, their locations or types.</p>
+<p><em class="xref std std-option">-gmodules</em> Generate debug information that contains external
+references to types defined in Clang modules or precompiled headers instead
+of emitting redundant debug type information into every object file. This
+option transparently switches the Clang module format to object file
+containers 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 compile
+times and much smaller object files.</p>
+<p>This option should not be used when building static libraries for
+distribution to other machines because the debug info will contain
+references to the module cache on the machine the object files in the
+library were built on.</p>
+</div></blockquote>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fstandalone-debug">
+<tt class="descname">-fstandalone-debug</tt><tt class="descclassname"> -fno-standalone-debug</tt><a class="headerlink" href="#cmdoption-fstandalone-debug" title="Permalink to this definition">¶</a></dt>
+<dd><p>Clang supports a number of optimizations to reduce the size of debug
+information in the binary. They work based on the assumption that the
+debug type information can be spread out over multiple 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 contains the vtable for the class.</p>
+<p>The <a class="reference internal" href="../UsersManual.html#cmdoption-fstandalone-debug"><em class="xref std std-option">-fstandalone-debug</em></a> 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.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fexceptions">
+<tt class="descname">-fexceptions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-fexceptions" title="Permalink to this definition">¶</a></dt>
+<dd><p>Enable generation of unwind information. This allows exceptions to be thrown
+through Clang compiled stack frames. This is on by default in x86-64.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-ftrapv">
+<tt class="descname">-ftrapv</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-ftrapv" title="Permalink to this definition">¶</a></dt>
+<dd><p>Generate code to catch integer overflow errors. Signed integer overflow is
+undefined in C. With this flag, extra code is generated to detect this and
+abort when it happens.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fvisibility">
+<tt class="descname">-fvisibility</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-fvisibility" title="Permalink to this definition">¶</a></dt>
+<dd><p>This flag sets the default visibility level.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fcommon">
+<tt class="descname">-fcommon</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-common</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-fcommon" title="Permalink to this definition">¶</a></dt>
+<dd><p>This flag specifies that variables without initializers get common linkage.
+It can be disabled with <em class="xref std std-option">-fno-common</em>.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-ftls-model">
+<tt class="descname">-ftls-model</tt><tt class="descclassname">=<model></tt><a class="headerlink" href="#cmdoption-ftls-model" title="Permalink to this definition">¶</a></dt>
+<dd><p>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 efficient model if possible.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-flto">
+<tt class="descname">-flto</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-flto</tt><tt class="descclassname">=full</tt><tt class="descclassname">, </tt><tt class="descname">-flto</tt><tt class="descclassname">=thin</tt><tt class="descclassname">, </tt><tt class="descname">-emit-llvm</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-flto" title="Permalink to this definition">¶</a></dt>
+<dd><p>Generate output files in LLVM formats, suitable for link time optimization.
+When used with <a class="reference internal" href="#cmdoption-S"><em class="xref std std-option">-S</em></a> 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).</p>
+<p>The default for <a class="reference internal" href="#cmdoption-flto"><em class="xref std std-option">-flto</em></a> is “full”, in which the
+LLVM bitcode is suitable for monolithic Link Time Optimization (LTO), where
+the linker merges all such modules into a single combined module for
+optimization. With “thin”, <a class="reference internal" href="../ThinLTO.html"><em>ThinLTO</em></a>
+compilation is invoked instead.</p>
+</dd></dl>
+
+</div>
+<div class="section" id="driver-options">
+<h3>Driver Options<a class="headerlink" href="#driver-options" title="Permalink to this headline">¶</a></h3>
+<dl class="option">
+<dt>
+<tt class="descname">-###</tt></dt>
+<dd><p>Print (but do not run) the commands to run for this compilation.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption--help">
+<tt class="descname">--help</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption--help" title="Permalink to this definition">¶</a></dt>
+<dd><p>Display available options.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-Qunused-arguments">
+<tt class="descname">-Qunused-arguments</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-Qunused-arguments" title="Permalink to this definition">¶</a></dt>
+<dd><p>Do not emit any warnings for unused driver arguments.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-Wa">
+<tt class="descname">-Wa</tt><tt class="descclassname">,<args></tt><a class="headerlink" href="#cmdoption-Wa" title="Permalink to this definition">¶</a></dt>
+<dd><p>Pass the comma separated arguments in args to the assembler.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-Wl">
+<tt class="descname">-Wl</tt><tt class="descclassname">,<args></tt><a class="headerlink" href="#cmdoption-Wl" title="Permalink to this definition">¶</a></dt>
+<dd><p>Pass the comma separated arguments in args to the linker.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-Wp">
+<tt class="descname">-Wp</tt><tt class="descclassname">,<args></tt><a class="headerlink" href="#cmdoption-Wp" title="Permalink to this definition">¶</a></dt>
+<dd><p>Pass the comma separated arguments in args to the preprocessor.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-Xanalyzer">
+<tt class="descname">-Xanalyzer</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-Xanalyzer" title="Permalink to this definition">¶</a></dt>
+<dd><p>Pass arg to the static analyzer.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-Xassembler">
+<tt class="descname">-Xassembler</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-Xassembler" title="Permalink to this definition">¶</a></dt>
+<dd><p>Pass arg to the assembler.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-Xlinker">
+<tt class="descname">-Xlinker</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-Xlinker" title="Permalink to this definition">¶</a></dt>
+<dd><p>Pass arg to the linker.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-Xpreprocessor">
+<tt class="descname">-Xpreprocessor</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-Xpreprocessor" title="Permalink to this definition">¶</a></dt>
+<dd><p>Pass arg to the preprocessor.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-o">
+<tt class="descname">-o</tt><tt class="descclassname"> <file></tt><a class="headerlink" href="#cmdoption-o" title="Permalink to this definition">¶</a></dt>
+<dd><p>Write output to file.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-print-file-name">
+<tt class="descname">-print-file-name</tt><tt class="descclassname">=<file></tt><a class="headerlink" href="#cmdoption-print-file-name" title="Permalink to this definition">¶</a></dt>
+<dd><p>Print the full library path of file.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-print-libgcc-file-name">
+<tt class="descname">-print-libgcc-file-name</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-print-libgcc-file-name" title="Permalink to this definition">¶</a></dt>
+<dd><p>Print the library path for the currently used compiler runtime library
+(“libgcc.a” or “libclang_rt.builtins.*.a”).</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-print-prog-name">
+<tt class="descname">-print-prog-name</tt><tt class="descclassname">=<name></tt><a class="headerlink" href="#cmdoption-print-prog-name" title="Permalink to this definition">¶</a></dt>
+<dd><p>Print the full program path of name.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-print-search-dirs">
+<tt class="descname">-print-search-dirs</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-print-search-dirs" title="Permalink to this definition">¶</a></dt>
+<dd><p>Print the paths used for finding libraries and programs.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-save-temps">
+<tt class="descname">-save-temps</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-save-temps" title="Permalink to this definition">¶</a></dt>
+<dd><p>Save intermediate compilation results.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-save-stats">
+<tt class="descname">-save-stats</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-save-stats</tt><tt class="descclassname">=cwd</tt><tt class="descclassname">, </tt><tt class="descname">-save-stats</tt><tt class="descclassname">=obj</tt><a class="headerlink" href="#cmdoption-save-stats" title="Permalink to this definition">¶</a></dt>
+<dd><p>Save internal code generation (LLVM) statistics to a file in the current
+directory (<a class="reference internal" href="#cmdoption-save-stats"><em class="xref std std-option">-save-stats</em></a>/”-save-stats=cwd”) or the directory
+of the output file (“-save-state=obj”).</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-integrated-as">
+<tt class="descname">-integrated-as</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-no-integrated-as</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-integrated-as" title="Permalink to this definition">¶</a></dt>
+<dd><p>Used to enable and disable, respectively, the use of the integrated
+assembler. Whether the integrated assembler is on by default is target
+dependent.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-time">
+<tt class="descname">-time</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-time" title="Permalink to this definition">¶</a></dt>
+<dd><p>Time individual commands.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-ftime-report">
+<tt class="descname">-ftime-report</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-ftime-report" title="Permalink to this definition">¶</a></dt>
+<dd><p>Print timing summary of each stage of compilation.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-v">
+<tt class="descname">-v</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-v" title="Permalink to this definition">¶</a></dt>
+<dd><p>Show commands to run and use verbose output.</p>
+</dd></dl>
+
+</div>
+<div class="section" id="diagnostics-options">
+<h3>Diagnostics Options<a class="headerlink" href="#diagnostics-options" title="Permalink to this headline">¶</a></h3>
+<dl class="option">
+<dt id="cmdoption-fshow-column">
+<tt class="descname">-fshow-column</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fshow-source-location</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fcaret-diagnostics</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fdiagnostics-fixit-info</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fdiagnostics-parseable-fixits</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fdiagnostics-print-source-range-info</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fprint-source-range-info</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fdiagnostics-show-option</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fmessage-length</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-fshow-column" title="Permalink to this definition">¶</a></dt>
+<dd><p>These options control how Clang prints out information about diagnostics
+(errors and warnings). Please see the Clang User’s Manual for more information.</p>
+</dd></dl>
+
+</div>
+<div class="section" id="preprocessor-options">
+<h3>Preprocessor Options<a class="headerlink" href="#preprocessor-options" title="Permalink to this headline">¶</a></h3>
+<dl class="option">
+<dt id="cmdoption-D">
+<tt class="descname">-D</tt><tt class="descclassname"><macroname>=<value></tt><a class="headerlink" href="#cmdoption-D" title="Permalink to this definition">¶</a></dt>
+<dd><p>Adds an implicit #define into the predefines buffer which is read before the
+source file is preprocessed.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-U">
+<tt class="descname">-U</tt><tt class="descclassname"><macroname></tt><a class="headerlink" href="#cmdoption-U" title="Permalink to this definition">¶</a></dt>
+<dd><p>Adds an implicit #undef into the predefines buffer which is read before the
+source file is preprocessed.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-include">
+<tt class="descname">-include</tt><tt class="descclassname"> <filename></tt><a class="headerlink" href="#cmdoption-include" title="Permalink to this definition">¶</a></dt>
+<dd><p>Adds an implicit #include into the predefines buffer which is read before the
+source file is preprocessed.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-I">
+<tt class="descname">-I</tt><tt class="descclassname"><directory></tt><a class="headerlink" href="#cmdoption-I" title="Permalink to this definition">¶</a></dt>
+<dd><p>Add the specified directory to the search path for include files.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-F">
+<tt class="descname">-F</tt><tt class="descclassname"><directory></tt><a class="headerlink" href="#cmdoption-F" title="Permalink to this definition">¶</a></dt>
+<dd><p>Add the specified directory to the search path for framework include files.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-nostdinc">
+<tt class="descname">-nostdinc</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-nostdinc" title="Permalink to this definition">¶</a></dt>
+<dd><p>Do not search the standard system directories or compiler builtin directories
+for include files.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-nostdlibinc">
+<tt class="descname">-nostdlibinc</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-nostdlibinc" title="Permalink to this definition">¶</a></dt>
+<dd><p>Do not search the standard system directories for include files, but do
+search compiler builtin include directories.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-nobuiltininc">
+<tt class="descname">-nobuiltininc</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-nobuiltininc" title="Permalink to this definition">¶</a></dt>
+<dd><p>Do not search clang’s builtin directory for include files.</p>
+</dd></dl>
+
+</div>
+</div>
+<div class="section" id="environment">
+<h2>ENVIRONMENT<a class="headerlink" href="#environment" title="Permalink to this headline">¶</a></h2>
+<dl class="envvar">
+<dt id="envvar-TMPDIR,TEMP,TMP">
+<tt class="descname">TMPDIR, TEMP, TMP</tt><a class="headerlink" href="#envvar-TMPDIR,TEMP,TMP" title="Permalink to this definition">¶</a></dt>
+<dd><p>These environment variables are checked, in order, for the location to write
+temporary files used during the compilation process.</p>
+</dd></dl>
+
+<dl class="envvar">
+<dt id="envvar-CPATH">
+<tt class="descname">CPATH</tt><a class="headerlink" href="#envvar-CPATH" title="Permalink to this definition">¶</a></dt>
+<dd><p>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 delimiter, as used in the PATH environment variable.</p>
+<p>Empty components in the environment variable are ignored.</p>
+</dd></dl>
+
+<dl class="envvar">
+<dt id="envvar-C_INCLUDE_PATH,OBJC_INCLUDE_PATH,CPLUS_INCLUDE_PATH,OBJCPLUS_INCLUDE_PATH">
+<tt class="descname">C_INCLUDE_PATH, OBJC_INCLUDE_PATH, CPLUS_INCLUDE_PATH, OBJCPLUS_INCLUDE_PATH</tt><a class="headerlink" href="#envvar-C_INCLUDE_PATH,OBJC_INCLUDE_PATH,CPLUS_INCLUDE_PATH,OBJCPLUS_INCLUDE_PATH" title="Permalink to this definition">¶</a></dt>
+<dd><p>These environment variables specify additional paths, as for <span class="target" id="index-0"></span><a class="reference internal" href="#envvar-CPATH"><tt class="xref std std-envvar docutils literal"><span class="pre">CPATH</span></tt></a>, which are
+only used when processing the appropriate language.</p>
+</dd></dl>
+
+<dl class="envvar">
+<dt id="envvar-MACOSX_DEPLOYMENT_TARGET">
+<tt class="descname">MACOSX_DEPLOYMENT_TARGET</tt><a class="headerlink" href="#envvar-MACOSX_DEPLOYMENT_TARGET" title="Permalink to this definition">¶</a></dt>
+<dd><p>If <a class="reference internal" href="#cmdoption-mmacosx-version-min"><em class="xref std std-option">-mmacosx-version-min</em></a> is unspecified, the default deployment
+target is read from this environment variable. This option only affects
+Darwin targets.</p>
+</dd></dl>
+
+</div>
+<div class="section" id="bugs">
+<h2>BUGS<a class="headerlink" href="#bugs" title="Permalink to this headline">¶</a></h2>
+<p>To report bugs, please visit <<a class="reference external" href="http://llvm.org/bugs/">http://llvm.org/bugs/</a>>. Most bug reports should
+include preprocessed source files (use the <a class="reference internal" href="#cmdoption-E"><em class="xref std std-option">-E</em></a> option) and the full
+output of the compiler, along with information to reproduce.</p>
+</div>
+<div class="section" id="see-also">
+<h2>SEE ALSO<a class="headerlink" href="#see-also" title="Permalink to this headline">¶</a></h2>
+<p><em class="manpage">as(1)</em>, <em class="manpage">ld(1)</em></p>
+</div>
+</div>
+
+
+ </div>
+ <div class="bottomnav">
+
+ <p>
+ « <a href="index.html">Clang “man” pages</a>
+ ::
+ <a class="uplink" href="../index.html">Contents</a>
+ ::
+ <a href="../FAQ.html">Frequently Asked Questions (FAQ)</a> »
+ </p>
+
+ </div>
+
+ <div class="footer">
+ © Copyright 2007-2018, The Clang Team.
+ Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/6.0.1/tools/clang/docs/CommandGuide/index.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/6.0.1/tools/clang/docs/CommandGuide/index.html?rev=336152&view=auto
==============================================================================
--- www-releases/trunk/6.0.1/tools/clang/docs/CommandGuide/index.html (added)
+++ www-releases/trunk/6.0.1/tools/clang/docs/CommandGuide/index.html Mon Jul 2 16:21:43 2018
@@ -0,0 +1,91 @@
+
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+ <title>Clang âmanâ pages — Clang 6 documentation</title>
+
+ <link rel="stylesheet" href="../_static/haiku.css" type="text/css" />
+ <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
+ <link rel="stylesheet" href="../_static/print.css" type="text/css" />
+
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: '../',
+ VERSION: '6',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true
+ };
+ </script>
+ <script type="text/javascript" src="../_static/jquery.js"></script>
+ <script type="text/javascript" src="../_static/underscore.js"></script>
+ <script type="text/javascript" src="../_static/doctools.js"></script>
+ <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+ <script type="text/javascript" src="../_static/theme_extras.js"></script>
+ <link rel="top" title="Clang 6 documentation" href="../index.html" />
+ <link rel="next" title="clang - the Clang C, C++, and Objective-C compiler" href="clang.html" />
+ <link rel="prev" title="ThinLTO" href="../ThinLTO.html" />
+ </head>
+ <body>
+ <div class="header"><h1 class="heading"><a href="../index.html">
+ <span>Clang 6 documentation</span></a></h1>
+ <h2 class="heading"><span>Clang âmanâ pages</span></h2>
+ </div>
+ <div class="topnav">
+
+ <p>
+ « <a href="../ThinLTO.html">ThinLTO</a>
+ ::
+ <a class="uplink" href="../index.html">Contents</a>
+ ::
+ <a href="clang.html">clang - the Clang C, C++, and Objective-C compiler</a> »
+ </p>
+
+ </div>
+ <div class="content">
+
+
+ <div class="section" id="clang-man-pages">
+<h1>Clang “man” pages<a class="headerlink" href="#clang-man-pages" title="Permalink to this headline">¶</a></h1>
+<p>The following documents are command descriptions for all of the Clang tools.
+These pages describe how to use the Clang commands and what their options are.
+Note that these pages do not describe all of the options available for all
+tools. To get a complete listing, pass the <tt class="docutils literal"><span class="pre">--help</span></tt> (general options) or
+<tt class="docutils literal"><span class="pre">--help-hidden</span></tt> (general and debugging options) arguments to the tool you are
+interested in.</p>
+<div class="section" id="basic-commands">
+<h2>Basic Commands<a class="headerlink" href="#basic-commands" title="Permalink to this headline">¶</a></h2>
+<div class="toctree-wrapper compound">
+<ul>
+<li class="toctree-l1"><a class="reference internal" href="clang.html">clang - the Clang C, C++, and Objective-C compiler</a></li>
+</ul>
+</div>
+</div>
+</div>
+
+
+ </div>
+ <div class="bottomnav">
+
+ <p>
+ « <a href="../ThinLTO.html">ThinLTO</a>
+ ::
+ <a class="uplink" href="../index.html">Contents</a>
+ ::
+ <a href="clang.html">clang - the Clang C, C++, and Objective-C compiler</a> »
+ </p>
+
+ </div>
+
+ <div class="footer">
+ © Copyright 2007-2018, The Clang Team.
+ Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/6.0.1/tools/clang/docs/ControlFlowIntegrity.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/6.0.1/tools/clang/docs/ControlFlowIntegrity.html?rev=336152&view=auto
==============================================================================
--- www-releases/trunk/6.0.1/tools/clang/docs/ControlFlowIntegrity.html (added)
+++ www-releases/trunk/6.0.1/tools/clang/docs/ControlFlowIntegrity.html Mon Jul 2 16:21:43 2018
@@ -0,0 +1,347 @@
+
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+ <title>Control Flow Integrity — Clang 6 documentation</title>
+
+ <link rel="stylesheet" href="_static/haiku.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+ <link rel="stylesheet" href="_static/print.css" type="text/css" />
+
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: '',
+ VERSION: '6',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true
+ };
+ </script>
+ <script type="text/javascript" src="_static/jquery.js"></script>
+ <script type="text/javascript" src="_static/underscore.js"></script>
+ <script type="text/javascript" src="_static/doctools.js"></script>
+ <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+ <script type="text/javascript" src="_static/theme_extras.js"></script>
+ <link rel="top" title="Clang 6 documentation" href="index.html" />
+ <link rel="next" title="Control Flow Integrity Design Documentation" href="ControlFlowIntegrityDesign.html" />
+ <link rel="prev" title="Sanitizer special case list" href="SanitizerSpecialCaseList.html" />
+ </head>
+ <body>
+ <div class="header"><h1 class="heading"><a href="index.html">
+ <span>Clang 6 documentation</span></a></h1>
+ <h2 class="heading"><span>Control Flow Integrity</span></h2>
+ </div>
+ <div class="topnav">
+
+ <p>
+ « <a href="SanitizerSpecialCaseList.html">Sanitizer special case list</a>
+ ::
+ <a class="uplink" href="index.html">Contents</a>
+ ::
+ <a href="ControlFlowIntegrityDesign.html">Control Flow Integrity Design Documentation</a> »
+ </p>
+
+ </div>
+ <div class="content">
+
+
+ <div class="section" id="control-flow-integrity">
+<h1>Control Flow Integrity<a class="headerlink" href="#control-flow-integrity" title="Permalink to this headline">¶</a></h1>
+<div class="toctree-wrapper compound">
+</div>
+<div class="contents local topic" id="contents">
+<ul class="simple">
+<li><a class="reference internal" href="#introduction" id="id1">Introduction</a></li>
+<li><a class="reference internal" href="#available-schemes" id="id2">Available schemes</a></li>
+<li><a class="reference internal" href="#trapping-and-diagnostics" id="id3">Trapping and Diagnostics</a></li>
+<li><a class="reference internal" href="#forward-edge-cfi-for-virtual-calls" id="id4">Forward-Edge CFI for Virtual Calls</a><ul>
+<li><a class="reference internal" href="#performance" id="id5">Performance</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#bad-cast-checking" id="id6">Bad Cast Checking</a></li>
+<li><a class="reference internal" href="#non-virtual-member-function-call-checking" id="id7">Non-Virtual Member Function Call Checking</a><ul>
+<li><a class="reference internal" href="#strictness" id="id8">Strictness</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#indirect-function-call-checking" id="id9">Indirect Function Call Checking</a><ul>
+<li><a class="reference internal" href="#fsanitize-cfi-icall-generalize-pointers" id="id10"><tt class="docutils literal"><span class="pre">-fsanitize-cfi-icall-generalize-pointers</span></tt></a></li>
+<li><a class="reference internal" href="#fsanitize-cfi-icall-and-fsanitize-function" id="id11"><tt class="docutils literal"><span class="pre">-fsanitize=cfi-icall</span></tt> and <tt class="docutils literal"><span class="pre">-fsanitize=function</span></tt></a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#blacklist" id="id12">Blacklist</a></li>
+<li><a class="reference internal" href="#shared-library-support" id="id13">Shared library support</a></li>
+<li><a class="reference internal" href="#design" id="id14">Design</a></li>
+<li><a class="reference internal" href="#publications" id="id15">Publications</a></li>
+</ul>
+</div>
+<div class="section" id="introduction">
+<h2><a class="toc-backref" href="#id1">Introduction</a><a class="headerlink" href="#introduction" title="Permalink to this headline">¶</a></h2>
+<p>Clang includes an implementation of a number of control flow integrity (CFI)
+schemes, which are designed to abort the program upon detecting certain forms
+of undefined behavior that can potentially allow attackers to subvert the
+program’s control flow. These schemes have been optimized for performance,
+allowing developers to enable them in release builds.</p>
+<p>To enable Clang’s available CFI schemes, use the flag <tt class="docutils literal"><span class="pre">-fsanitize=cfi</span></tt>.
+You can also enable a subset of available <a class="reference internal" href="#cfi-schemes"><em>schemes</em></a>.
+As currently implemented, all schemes rely on link-time optimization (LTO);
+so it is required to specify <tt class="docutils literal"><span class="pre">-flto</span></tt>, and the linker used must support LTO,
+for example via the <a class="reference external" href="http://llvm.org/docs/GoldPlugin.html">gold plugin</a>.</p>
+<p>To allow the checks to be implemented efficiently, the program must
+be structured such that certain object files are compiled with CFI
+enabled, and are statically linked into the program. This may preclude
+the use of shared libraries in some cases.</p>
+<p>The compiler will only produce CFI checks for a class if it can infer hidden
+LTO visibility for that class. LTO visibility is a property of a class that
+is inferred from flags and attributes. For more details, see the documentation
+for <a class="reference internal" href="LTOVisibility.html"><em>LTO visibility</em></a>.</p>
+<p>The <tt class="docutils literal"><span class="pre">-fsanitize=cfi-{vcall,nvcall,derived-cast,unrelated-cast}</span></tt> flags
+require that a <tt class="docutils literal"><span class="pre">-fvisibility=</span></tt> flag also be specified. This is because the
+default visibility setting is <tt class="docutils literal"><span class="pre">-fvisibility=default</span></tt>, which would disable
+CFI checks for classes without visibility attributes. Most users will want
+to specify <tt class="docutils literal"><span class="pre">-fvisibility=hidden</span></tt>, which enables CFI checks for such classes.</p>
+<p>Experimental support for <a class="reference internal" href="#cfi-cross-dso"><em>cross-DSO control flow integrity</em></a> exists that does not require classes to have hidden LTO
+visibility. This cross-DSO support has unstable ABI at this time.</p>
+</div>
+<div class="section" id="available-schemes">
+<span id="cfi-schemes"></span><h2><a class="toc-backref" href="#id2">Available schemes</a><a class="headerlink" href="#available-schemes" title="Permalink to this headline">¶</a></h2>
+<p>Available schemes are:</p>
+<blockquote>
+<div><ul class="simple">
+<li><tt class="docutils literal"><span class="pre">-fsanitize=cfi-cast-strict</span></tt>: Enables <a class="reference internal" href="#cfi-strictness"><em>strict cast checks</em></a>.</li>
+<li><tt class="docutils literal"><span class="pre">-fsanitize=cfi-derived-cast</span></tt>: Base-to-derived cast to the wrong
+dynamic type.</li>
+<li><tt class="docutils literal"><span class="pre">-fsanitize=cfi-unrelated-cast</span></tt>: Cast from <tt class="docutils literal"><span class="pre">void*</span></tt> or another
+unrelated type to the wrong dynamic type.</li>
+<li><tt class="docutils literal"><span class="pre">-fsanitize=cfi-nvcall</span></tt>: Non-virtual call via an object whose vptr is of
+the wrong dynamic type.</li>
+<li><tt class="docutils literal"><span class="pre">-fsanitize=cfi-vcall</span></tt>: Virtual call via an object whose vptr is of the
+wrong dynamic type.</li>
+<li><tt class="docutils literal"><span class="pre">-fsanitize=cfi-icall</span></tt>: Indirect call of a function with wrong dynamic
+type.</li>
+</ul>
+</div></blockquote>
+<p>You can use <tt class="docutils literal"><span class="pre">-fsanitize=cfi</span></tt> to enable all the schemes and use
+<tt class="docutils literal"><span class="pre">-fno-sanitize</span></tt> flag to narrow down the set of schemes as desired.
+For example, you can build your program with
+<tt class="docutils literal"><span class="pre">-fsanitize=cfi</span> <span class="pre">-fno-sanitize=cfi-nvcall,cfi-icall</span></tt>
+to use all schemes except for non-virtual member function call and indirect call
+checking.</p>
+<p>Remember that you have to provide <tt class="docutils literal"><span class="pre">-flto</span></tt> if at least one CFI scheme is
+enabled.</p>
+</div>
+<div class="section" id="trapping-and-diagnostics">
+<h2><a class="toc-backref" href="#id3">Trapping and Diagnostics</a><a class="headerlink" href="#trapping-and-diagnostics" title="Permalink to this headline">¶</a></h2>
+<p>By default, CFI will abort the program immediately upon detecting a control
+flow integrity violation. You can use the <a class="reference internal" href="UsersManual.html#controlling-code-generation"><em>-fno-sanitize-trap=</em></a> flag to cause CFI to print a diagnostic
+similar to the one below before the program aborts.</p>
+<div class="highlight-console"><div class="highlight"><pre><span class="go">bad-cast.cpp:109:7: runtime error: control flow integrity check for type 'B' failed during base-to-derived cast (vtable address 0x000000425a50)</span>
+<span class="go">0x000000425a50: note: vtable is of type 'A'</span>
+<span class="go"> 00 00 00 00 f0 f1 41 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 20 5a 42 00</span>
+<span class="go"> ^</span>
+</pre></div>
+</div>
+<p>If diagnostics are enabled, you can also configure CFI to continue program
+execution instead of aborting by using the <a class="reference internal" href="UsersManual.html#controlling-code-generation"><em>-fsanitize-recover=</em></a> flag.</p>
+</div>
+<div class="section" id="forward-edge-cfi-for-virtual-calls">
+<h2><a class="toc-backref" href="#id4">Forward-Edge CFI for Virtual Calls</a><a class="headerlink" href="#forward-edge-cfi-for-virtual-calls" title="Permalink to this headline">¶</a></h2>
+<p>This scheme checks that virtual calls take place using a vptr of the correct
+dynamic type; that is, the dynamic type of the called object must be a
+derived class of the static type of the object used to make the call.
+This CFI scheme can be enabled on its own using <tt class="docutils literal"><span class="pre">-fsanitize=cfi-vcall</span></tt>.</p>
+<p>For this scheme to work, all translation units containing the definition
+of a virtual member function (whether inline or not), other than members
+of <a class="reference internal" href="#cfi-blacklist"><em>blacklisted</em></a> types, must be compiled with
+<tt class="docutils literal"><span class="pre">-fsanitize=cfi-vcall</span></tt> enabled and be statically linked into the program.</p>
+<div class="section" id="performance">
+<h3><a class="toc-backref" href="#id5">Performance</a><a class="headerlink" href="#performance" title="Permalink to this headline">¶</a></h3>
+<p>A performance overhead of less than 1% has been measured by running the
+Dromaeo benchmark suite against an instrumented version of the Chromium
+web browser. Another good performance benchmark for this mechanism is the
+virtual-call-heavy SPEC 2006 xalancbmk.</p>
+<p>Note that this scheme has not yet been optimized for binary size; an increase
+of up to 15% has been observed for Chromium.</p>
+</div>
+</div>
+<div class="section" id="bad-cast-checking">
+<h2><a class="toc-backref" href="#id6">Bad Cast Checking</a><a class="headerlink" href="#bad-cast-checking" title="Permalink to this headline">¶</a></h2>
+<p>This scheme checks that pointer casts are made to an object of the correct
+dynamic type; that is, the dynamic type of the object must be a derived class
+of the pointee type of the cast. The checks are currently only introduced
+where the class being casted to is a polymorphic class.</p>
+<p>Bad casts are not in themselves control flow integrity violations, but they
+can also create security vulnerabilities, and the implementation uses many
+of the same mechanisms.</p>
+<p>There are two types of bad cast that may be forbidden: bad casts
+from a base class to a derived class (which can be checked with
+<tt class="docutils literal"><span class="pre">-fsanitize=cfi-derived-cast</span></tt>), and bad casts from a pointer of
+type <tt class="docutils literal"><span class="pre">void*</span></tt> or another unrelated type (which can be checked with
+<tt class="docutils literal"><span class="pre">-fsanitize=cfi-unrelated-cast</span></tt>).</p>
+<p>The difference between these two types of casts is that the first is defined
+by the C++ standard to produce an undefined value, while the second is not
+in itself undefined behavior (it is well defined to cast the pointer back
+to its original type) unless the object is uninitialized and the cast is a
+<tt class="docutils literal"><span class="pre">static_cast</span></tt> (see C++14 [basic.life]p5).</p>
+<p>If a program as a matter of policy forbids the second type of cast, that
+restriction can normally be enforced. However it may in some cases be necessary
+for a function to perform a forbidden cast to conform with an external API
+(e.g. the <tt class="docutils literal"><span class="pre">allocate</span></tt> member function of a standard library allocator). Such
+functions may be <a class="reference internal" href="#cfi-blacklist"><em>blacklisted</em></a>.</p>
+<p>For this scheme to work, all translation units containing the definition
+of a virtual member function (whether inline or not), other than members
+of <a class="reference internal" href="#cfi-blacklist"><em>blacklisted</em></a> types, must be compiled with
+<tt class="docutils literal"><span class="pre">-fsanitize=cfi-derived-cast</span></tt> or <tt class="docutils literal"><span class="pre">-fsanitize=cfi-unrelated-cast</span></tt> enabled
+and be statically linked into the program.</p>
+</div>
+<div class="section" id="non-virtual-member-function-call-checking">
+<h2><a class="toc-backref" href="#id7">Non-Virtual Member Function Call Checking</a><a class="headerlink" href="#non-virtual-member-function-call-checking" title="Permalink to this headline">¶</a></h2>
+<p>This scheme checks that non-virtual calls take place using an object of
+the correct dynamic type; that is, the dynamic type of the called object
+must be a derived class of the static type of the object used to make the
+call. The checks are currently only introduced where the object is of a
+polymorphic class type. This CFI scheme can be enabled on its own using
+<tt class="docutils literal"><span class="pre">-fsanitize=cfi-nvcall</span></tt>.</p>
+<p>For this scheme to work, all translation units containing the definition
+of a virtual member function (whether inline or not), other than members
+of <a class="reference internal" href="#cfi-blacklist"><em>blacklisted</em></a> types, must be compiled with
+<tt class="docutils literal"><span class="pre">-fsanitize=cfi-nvcall</span></tt> enabled and be statically linked into the program.</p>
+<div class="section" id="strictness">
+<span id="cfi-strictness"></span><h3><a class="toc-backref" href="#id8">Strictness</a><a class="headerlink" href="#strictness" title="Permalink to this headline">¶</a></h3>
+<p>If a class has a single non-virtual base and does not introduce or override
+virtual member functions or fields other than an implicitly defined virtual
+destructor, it will have the same layout and virtual function semantics as
+its base. By default, casts to such classes are checked as if they were made
+to the least derived such class.</p>
+<p>Casting an instance of a base class to such a derived class is technically
+undefined behavior, but it is a relatively common hack for introducing
+member functions on class instances with specific properties that works under
+most compilers and should not have security implications, so we allow it by
+default. It can be disabled with <tt class="docutils literal"><span class="pre">-fsanitize=cfi-cast-strict</span></tt>.</p>
+</div>
+</div>
+<div class="section" id="indirect-function-call-checking">
+<h2><a class="toc-backref" href="#id9">Indirect Function Call Checking</a><a class="headerlink" href="#indirect-function-call-checking" title="Permalink to this headline">¶</a></h2>
+<p>This scheme checks that function calls take place using a function of the
+correct dynamic type; that is, the dynamic type of the function must match
+the static type used at the call. This CFI scheme can be enabled on its own
+using <tt class="docutils literal"><span class="pre">-fsanitize=cfi-icall</span></tt>.</p>
+<p>For this scheme to work, each indirect function call in the program, other
+than calls in <a class="reference internal" href="#cfi-blacklist"><em>blacklisted</em></a> functions, must call a
+function which was either compiled with <tt class="docutils literal"><span class="pre">-fsanitize=cfi-icall</span></tt> enabled,
+or whose address was taken by a function in a translation unit compiled with
+<tt class="docutils literal"><span class="pre">-fsanitize=cfi-icall</span></tt>.</p>
+<p>If a function in a translation unit compiled with <tt class="docutils literal"><span class="pre">-fsanitize=cfi-icall</span></tt>
+takes the address of a function not compiled with <tt class="docutils literal"><span class="pre">-fsanitize=cfi-icall</span></tt>,
+that address may differ from the address taken by a function in a translation
+unit not compiled with <tt class="docutils literal"><span class="pre">-fsanitize=cfi-icall</span></tt>. This is technically a
+violation of the C and C++ standards, but it should not affect most programs.</p>
+<p>Each translation unit compiled with <tt class="docutils literal"><span class="pre">-fsanitize=cfi-icall</span></tt> must be
+statically linked into the program or shared library, and calls across
+shared library boundaries are handled as if the callee was not compiled with
+<tt class="docutils literal"><span class="pre">-fsanitize=cfi-icall</span></tt>.</p>
+<p>This scheme is currently only supported on the x86 and x86_64 architectures.</p>
+<div class="section" id="fsanitize-cfi-icall-generalize-pointers">
+<h3><a class="toc-backref" href="#id10"><tt class="docutils literal"><span class="pre">-fsanitize-cfi-icall-generalize-pointers</span></tt></a><a class="headerlink" href="#fsanitize-cfi-icall-generalize-pointers" title="Permalink to this headline">¶</a></h3>
+<p>Mismatched pointer types are a common cause of cfi-icall check failures.
+Translation units compiled with the <tt class="docutils literal"><span class="pre">-fsanitize-cfi-icall-generalize-pointers</span></tt>
+flag relax pointer type checking for call sites in that translation unit,
+applied across all functions compiled with <tt class="docutils literal"><span class="pre">-fsanitize=cfi-icall</span></tt>.</p>
+<p>Specifically, pointers in return and argument types are treated as equivalent as
+long as the qualifiers for the type they point to match. For example, <tt class="docutils literal"><span class="pre">char*</span></tt>
+<tt class="docutils literal"><span class="pre">char**`,</span> <span class="pre">and</span> <span class="pre">``int*</span></tt> are considered equivalent types. However, <tt class="docutils literal"><span class="pre">char*</span></tt> and
+<tt class="docutils literal"><span class="pre">const</span> <span class="pre">char*</span></tt> are considered separate types.</p>
+<p><tt class="docutils literal"><span class="pre">-fsanitize-cfi-icall-generalize-pointers</span></tt> is not compatible with
+<tt class="docutils literal"><span class="pre">-fsanitize-cfi-cross-dso</span></tt>.</p>
+</div>
+<div class="section" id="fsanitize-cfi-icall-and-fsanitize-function">
+<h3><a class="toc-backref" href="#id11"><tt class="docutils literal"><span class="pre">-fsanitize=cfi-icall</span></tt> and <tt class="docutils literal"><span class="pre">-fsanitize=function</span></tt></a><a class="headerlink" href="#fsanitize-cfi-icall-and-fsanitize-function" title="Permalink to this headline">¶</a></h3>
+<p>This tool is similar to <tt class="docutils literal"><span class="pre">-fsanitize=function</span></tt> in that both tools check
+the types of function calls. However, the two tools occupy different points
+on the design space; <tt class="docutils literal"><span class="pre">-fsanitize=function</span></tt> is a developer tool designed
+to find bugs in local development builds, whereas <tt class="docutils literal"><span class="pre">-fsanitize=cfi-icall</span></tt>
+is a security hardening mechanism designed to be deployed in release builds.</p>
+<p><tt class="docutils literal"><span class="pre">-fsanitize=function</span></tt> has a higher space and time overhead due to a more
+complex type check at indirect call sites, as well as a need for run-time
+type information (RTTI), which may make it unsuitable for deployment. Because
+of the need for RTTI, <tt class="docutils literal"><span class="pre">-fsanitize=function</span></tt> can only be used with C++
+programs, whereas <tt class="docutils literal"><span class="pre">-fsanitize=cfi-icall</span></tt> can protect both C and C++ programs.</p>
+<p>On the other hand, <tt class="docutils literal"><span class="pre">-fsanitize=function</span></tt> conforms more closely with the C++
+standard and user expectations around interaction with shared libraries;
+the identity of function pointers is maintained, and calls across shared
+library boundaries are no different from calls within a single program or
+shared library.</p>
+</div>
+</div>
+<div class="section" id="blacklist">
+<span id="cfi-blacklist"></span><h2><a class="toc-backref" href="#id12">Blacklist</a><a class="headerlink" href="#blacklist" title="Permalink to this headline">¶</a></h2>
+<p>A <a class="reference internal" href="SanitizerSpecialCaseList.html"><em>Sanitizer special case list</em></a> can be used to relax CFI checks for certain
+source files, functions and types using the <tt class="docutils literal"><span class="pre">src</span></tt>, <tt class="docutils literal"><span class="pre">fun</span></tt> and <tt class="docutils literal"><span class="pre">type</span></tt>
+entity types. Specific CFI modes can be be specified using <tt class="docutils literal"><span class="pre">[section]</span></tt>
+headers.</p>
+<div class="highlight-bash"><div class="highlight"><pre><span class="c"># Suppress all CFI checking for code in a file.</span>
+src:bad_file.cpp
+src:bad_header.h
+<span class="c"># Ignore all functions with names containing MyFooBar.</span>
+fun:*MyFooBar*
+<span class="c"># Ignore all types in the standard library.</span>
+<span class="nb">type</span>:std::*
+<span class="c"># Disable only unrelated cast checks for this function</span>
+<span class="o">[</span>cfi-unrelated-cast<span class="o">]</span>
+fun:*UnrelatedCast*
+<span class="c"># Disable CFI call checks for this function without affecting cast checks</span>
+<span class="o">[</span>cfi-vcall|cfi-nvcall|cfi-icall<span class="o">]</span>
+fun:*BadCall*
+</pre></div>
+</div>
+</div>
+<div class="section" id="shared-library-support">
+<span id="cfi-cross-dso"></span><h2><a class="toc-backref" href="#id13">Shared library support</a><a class="headerlink" href="#shared-library-support" title="Permalink to this headline">¶</a></h2>
+<p>Use <strong>-f[no-]sanitize-cfi-cross-dso</strong> to enable the cross-DSO control
+flow integrity mode, which allows all CFI schemes listed above to
+apply across DSO boundaries. As in the regular CFI, each DSO must be
+built with <tt class="docutils literal"><span class="pre">-flto</span></tt>.</p>
+<p>Normally, CFI checks will only be performed for classes that have hidden LTO
+visibility. With this flag enabled, the compiler will emit cross-DSO CFI
+checks for all classes, except for those which appear in the CFI blacklist
+or which use a <tt class="docutils literal"><span class="pre">no_sanitize</span></tt> attribute.</p>
+</div>
+<div class="section" id="design">
+<h2><a class="toc-backref" href="#id14">Design</a><a class="headerlink" href="#design" title="Permalink to this headline">¶</a></h2>
+<p>Please refer to the <a class="reference internal" href="ControlFlowIntegrityDesign.html"><em>design document</em></a>.</p>
+</div>
+<div class="section" id="publications">
+<h2><a class="toc-backref" href="#id15">Publications</a><a class="headerlink" href="#publications" title="Permalink to this headline">¶</a></h2>
+<p><a class="reference external" href="http://research.microsoft.com/pubs/64250/ccs05.pdf">Control-Flow Integrity: Principles, Implementations, and Applications</a>.
+Martin Abadi, Mihai Budiu, Ãlfar Erlingsson, Jay Ligatti.</p>
+<p><a class="reference external" href="http://www.pcc.me.uk/~peter/acad/usenix14.pdf">Enforcing Forward-Edge Control-Flow Integrity in GCC & LLVM</a>.
+Caroline Tice, Tom Roeder, Peter Collingbourne, Stephen Checkoway,
+Ãlfar Erlingsson, Luis Lozano, Geoff Pike.</p>
+</div>
+</div>
+
+
+ </div>
+ <div class="bottomnav">
+
+ <p>
+ « <a href="SanitizerSpecialCaseList.html">Sanitizer special case list</a>
+ ::
+ <a class="uplink" href="index.html">Contents</a>
+ ::
+ <a href="ControlFlowIntegrityDesign.html">Control Flow Integrity Design Documentation</a> »
+ </p>
+
+ </div>
+
+ <div class="footer">
+ © Copyright 2007-2018, The Clang Team.
+ Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/6.0.1/tools/clang/docs/ControlFlowIntegrityDesign.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/6.0.1/tools/clang/docs/ControlFlowIntegrityDesign.html?rev=336152&view=auto
==============================================================================
--- www-releases/trunk/6.0.1/tools/clang/docs/ControlFlowIntegrityDesign.html (added)
+++ www-releases/trunk/6.0.1/tools/clang/docs/ControlFlowIntegrityDesign.html Mon Jul 2 16:21:43 2018
@@ -0,0 +1,963 @@
+
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+ <title>Control Flow Integrity Design Documentation — Clang 6 documentation</title>
+
+ <link rel="stylesheet" href="_static/haiku.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+ <link rel="stylesheet" href="_static/print.css" type="text/css" />
+
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: '',
+ VERSION: '6',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true
+ };
+ </script>
+ <script type="text/javascript" src="_static/jquery.js"></script>
+ <script type="text/javascript" src="_static/underscore.js"></script>
+ <script type="text/javascript" src="_static/doctools.js"></script>
+ <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+ <script type="text/javascript" src="_static/theme_extras.js"></script>
+ <link rel="top" title="Clang 6 documentation" href="index.html" />
+ <link rel="up" title="Control Flow Integrity" href="ControlFlowIntegrity.html" />
+ <link rel="next" title="LTO Visibility" href="LTOVisibility.html" />
+ <link rel="prev" title="Control Flow Integrity" href="ControlFlowIntegrity.html" />
+ </head>
+ <body>
+ <div class="header"><h1 class="heading"><a href="index.html">
+ <span>Clang 6 documentation</span></a></h1>
+ <h2 class="heading"><span>Control Flow Integrity Design Documentation</span></h2>
+ </div>
+ <div class="topnav">
+
+ <p>
+ « <a href="ControlFlowIntegrity.html">Control Flow Integrity</a>
+ ::
+ <a class="uplink" href="index.html">Contents</a>
+ ::
+ <a href="LTOVisibility.html">LTO Visibility</a> »
+ </p>
+
+ </div>
+ <div class="content">
+
+
+ <div class="section" id="control-flow-integrity-design-documentation">
+<h1>Control Flow Integrity Design Documentation<a class="headerlink" href="#control-flow-integrity-design-documentation" title="Permalink to this headline">¶</a></h1>
+<p>This page documents the design of the <a class="reference internal" href="ControlFlowIntegrity.html"><em>Control Flow Integrity</em></a> schemes
+supported by Clang.</p>
+<div class="section" id="forward-edge-cfi-for-virtual-calls">
+<h2>Forward-Edge CFI for Virtual Calls<a class="headerlink" href="#forward-edge-cfi-for-virtual-calls" title="Permalink to this headline">¶</a></h2>
+<p>This scheme works by allocating, for each static type used to make a virtual
+call, a region of read-only storage in the object file holding a bit vector
+that maps onto to the region of storage used for those virtual tables. Each
+set bit in the bit vector corresponds to the <a class="reference external" href="http://itanium-cxx-abi.github.io/cxx-abi/abi.html#vtable-general">address point</a> for a virtual
+table compatible with the static type for which the bit vector is being built.</p>
+<p>For example, consider the following three C++ classes:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">struct</span> <span class="n">A</span> <span class="p">{</span>
+ <span class="k">virtual</span> <span class="kt">void</span> <span class="n">f1</span><span class="p">();</span>
+ <span class="k">virtual</span> <span class="kt">void</span> <span class="n">f2</span><span class="p">();</span>
+ <span class="k">virtual</span> <span class="kt">void</span> <span class="n">f3</span><span class="p">();</span>
+<span class="p">};</span>
+
+<span class="k">struct</span> <span class="n">B</span> <span class="o">:</span> <span class="n">A</span> <span class="p">{</span>
+ <span class="k">virtual</span> <span class="kt">void</span> <span class="n">f1</span><span class="p">();</span>
+ <span class="k">virtual</span> <span class="kt">void</span> <span class="n">f2</span><span class="p">();</span>
+ <span class="k">virtual</span> <span class="kt">void</span> <span class="n">f3</span><span class="p">();</span>
+<span class="p">};</span>
+
+<span class="k">struct</span> <span class="n">C</span> <span class="o">:</span> <span class="n">A</span> <span class="p">{</span>
+ <span class="k">virtual</span> <span class="kt">void</span> <span class="n">f1</span><span class="p">();</span>
+ <span class="k">virtual</span> <span class="kt">void</span> <span class="n">f2</span><span class="p">();</span>
+ <span class="k">virtual</span> <span class="kt">void</span> <span class="n">f3</span><span class="p">();</span>
+<span class="p">};</span>
+</pre></div>
+</div>
+<p>The scheme will cause the virtual tables for A, B and C to be laid out
+consecutively:</p>
+<table border="1" class="docutils">
+<caption>Virtual Table Layout for A, B, C</caption>
+<colgroup>
+<col width="7%" />
+<col width="7%" />
+<col width="7%" />
+<col width="7%" />
+<col width="7%" />
+<col width="7%" />
+<col width="7%" />
+<col width="7%" />
+<col width="7%" />
+<col width="7%" />
+<col width="7%" />
+<col width="7%" />
+<col width="7%" />
+<col width="7%" />
+<col width="7%" />
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">0</th>
+<th class="head">1</th>
+<th class="head">2</th>
+<th class="head">3</th>
+<th class="head">4</th>
+<th class="head">5</th>
+<th class="head">6</th>
+<th class="head">7</th>
+<th class="head">8</th>
+<th class="head">9</th>
+<th class="head">10</th>
+<th class="head">11</th>
+<th class="head">12</th>
+<th class="head">13</th>
+<th class="head">14</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>A::offset-to-top</td>
+<td>&A::rtti</td>
+<td>&A::f1</td>
+<td>&A::f2</td>
+<td>&A::f3</td>
+<td>B::offset-to-top</td>
+<td>&B::rtti</td>
+<td>&B::f1</td>
+<td>&B::f2</td>
+<td>&B::f3</td>
+<td>C::offset-to-top</td>
+<td>&C::rtti</td>
+<td>&C::f1</td>
+<td>&C::f2</td>
+<td>&C::f3</td>
+</tr>
+</tbody>
+</table>
+<p>The bit vector for static types A, B and C will look like this:</p>
+<table border="1" class="docutils">
+<caption>Bit Vectors for A, B, C</caption>
+<colgroup>
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">Class</th>
+<th class="head">0</th>
+<th class="head">1</th>
+<th class="head">2</th>
+<th class="head">3</th>
+<th class="head">4</th>
+<th class="head">5</th>
+<th class="head">6</th>
+<th class="head">7</th>
+<th class="head">8</th>
+<th class="head">9</th>
+<th class="head">10</th>
+<th class="head">11</th>
+<th class="head">12</th>
+<th class="head">13</th>
+<th class="head">14</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>A</td>
+<td>0</td>
+<td>0</td>
+<td>1</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>1</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>1</td>
+<td>0</td>
+<td>0</td>
+</tr>
+<tr class="row-odd"><td>B</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>1</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+</tr>
+<tr class="row-even"><td>C</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>1</td>
+<td>0</td>
+<td>0</td>
+</tr>
+</tbody>
+</table>
+<p>Bit vectors are represented in the object file as byte arrays. By loading
+from indexed offsets into the byte array and applying a mask, a program can
+test bits from the bit set with a relatively short instruction sequence. Bit
+vectors may overlap so long as they use different bits. For the full details,
+see the <a class="reference external" href="http://llvm.org/docs/doxygen/html/structllvm_1_1ByteArrayBuilder.html">ByteArrayBuilder</a> class.</p>
+<p>In this case, assuming A is laid out at offset 0 in bit 0, B at offset 0 in
+bit 1 and C at offset 0 in bit 2, the byte array would look like this:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="kt">char</span> <span class="n">bits</span><span class="p">[]</span> <span class="o">=</span> <span class="p">{</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span> <span class="p">};</span>
+</pre></div>
+</div>
+<p>To emit a virtual call, the compiler will assemble code that checks that
+the object’s virtual table pointer is in-bounds and aligned and that the
+relevant bit is set in the bit vector.</p>
+<p>For example on x86 a typical virtual call may look like this:</p>
+<div class="highlight-none"><div class="highlight"><pre>ca7fbb: 48 8b 0f mov (%rdi),%rcx
+ca7fbe: 48 8d 15 c3 42 fb 07 lea 0x7fb42c3(%rip),%rdx
+ca7fc5: 48 89 c8 mov %rcx,%rax
+ca7fc8: 48 29 d0 sub %rdx,%rax
+ca7fcb: 48 c1 c0 3d rol $0x3d,%rax
+ca7fcf: 48 3d 7f 01 00 00 cmp $0x17f,%rax
+ca7fd5: 0f 87 36 05 00 00 ja ca8511
+ca7fdb: 48 8d 15 c0 0b f7 06 lea 0x6f70bc0(%rip),%rdx
+ca7fe2: f6 04 10 10 testb $0x10,(%rax,%rdx,1)
+ca7fe6: 0f 84 25 05 00 00 je ca8511
+ca7fec: ff 91 98 00 00 00 callq *0x98(%rcx)
+ [...]
+ca8511: 0f 0b ud2
+</pre></div>
+</div>
+<p>The compiler relies on co-operation from the linker in order to assemble
+the bit vectors for the whole program. It currently does this using LLVM’s
+<a class="reference external" href="http://llvm.org/docs/TypeMetadata.html">type metadata</a> mechanism together with link-time optimization.</p>
+<div class="section" id="optimizations">
+<h3>Optimizations<a class="headerlink" href="#optimizations" title="Permalink to this headline">¶</a></h3>
+<p>The scheme as described above is the fully general variant of the scheme.
+Most of the time we are able to apply one or more of the following
+optimizations to improve binary size or performance.</p>
+<p>In fact, if you try the above example with the current version of the
+compiler, you will probably find that it will not use the described virtual
+table layout or machine instructions. Some of the optimizations we are about
+to introduce cause the compiler to use a different layout or a different
+sequence of machine instructions.</p>
+<div class="section" id="stripping-leading-trailing-zeros-in-bit-vectors">
+<h4>Stripping Leading/Trailing Zeros in Bit Vectors<a class="headerlink" href="#stripping-leading-trailing-zeros-in-bit-vectors" title="Permalink to this headline">¶</a></h4>
+<p>If a bit vector contains leading or trailing zeros, we can strip them from
+the vector. The compiler will emit code to check if the pointer is in range
+of the region covered by ones, and perform the bit vector check using a
+truncated version of the bit vector. For example, the bit vectors for our
+example class hierarchy will be emitted like this:</p>
+<table border="1" class="docutils">
+<caption>Bit Vectors for A, B, C</caption>
+<colgroup>
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">Class</th>
+<th class="head">0</th>
+<th class="head">1</th>
+<th class="head">2</th>
+<th class="head">3</th>
+<th class="head">4</th>
+<th class="head">5</th>
+<th class="head">6</th>
+<th class="head">7</th>
+<th class="head">8</th>
+<th class="head">9</th>
+<th class="head">10</th>
+<th class="head">11</th>
+<th class="head">12</th>
+<th class="head">13</th>
+<th class="head">14</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>A</td>
+<td> </td>
+<td> </td>
+<td>1</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>1</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>1</td>
+<td> </td>
+<td> </td>
+</tr>
+<tr class="row-odd"><td>B</td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td>1</td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+</tr>
+<tr class="row-even"><td>C</td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td>1</td>
+<td> </td>
+<td> </td>
+</tr>
+</tbody>
+</table>
+</div>
+<div class="section" id="short-inline-bit-vectors">
+<h4>Short Inline Bit Vectors<a class="headerlink" href="#short-inline-bit-vectors" title="Permalink to this headline">¶</a></h4>
+<p>If the vector is sufficiently short, we can represent it as an inline constant
+on x86. This saves us a few instructions when reading the correct element
+of the bit vector.</p>
+<p>If the bit vector fits in 32 bits, the code looks like this:</p>
+<div class="highlight-none"><div class="highlight"><pre> dc2: 48 8b 03 mov (%rbx),%rax
+ dc5: 48 8d 15 14 1e 00 00 lea 0x1e14(%rip),%rdx
+ dcc: 48 89 c1 mov %rax,%rcx
+ dcf: 48 29 d1 sub %rdx,%rcx
+ dd2: 48 c1 c1 3d rol $0x3d,%rcx
+ dd6: 48 83 f9 03 cmp $0x3,%rcx
+ dda: 77 2f ja e0b <main+0x9b>
+ ddc: ba 09 00 00 00 mov $0x9,%edx
+ de1: 0f a3 ca bt %ecx,%edx
+ de4: 73 25 jae e0b <main+0x9b>
+ de6: 48 89 df mov %rbx,%rdi
+ de9: ff 10 callq *(%rax)
+[...]
+ e0b: 0f 0b ud2
+</pre></div>
+</div>
+<p>Or if the bit vector fits in 64 bits:</p>
+<div class="highlight-none"><div class="highlight"><pre>11a6: 48 8b 03 mov (%rbx),%rax
+11a9: 48 8d 15 d0 28 00 00 lea 0x28d0(%rip),%rdx
+11b0: 48 89 c1 mov %rax,%rcx
+11b3: 48 29 d1 sub %rdx,%rcx
+11b6: 48 c1 c1 3d rol $0x3d,%rcx
+11ba: 48 83 f9 2a cmp $0x2a,%rcx
+11be: 77 35 ja 11f5 <main+0xb5>
+11c0: 48 ba 09 00 00 00 00 movabs $0x40000000009,%rdx
+11c7: 04 00 00
+11ca: 48 0f a3 ca bt %rcx,%rdx
+11ce: 73 25 jae 11f5 <main+0xb5>
+11d0: 48 89 df mov %rbx,%rdi
+11d3: ff 10 callq *(%rax)
+[...]
+11f5: 0f 0b ud2
+</pre></div>
+</div>
+<p>If the bit vector consists of a single bit, there is only one possible
+virtual table, and the check can consist of a single equality comparison:</p>
+<div class="highlight-none"><div class="highlight"><pre>9a2: 48 8b 03 mov (%rbx),%rax
+9a5: 48 8d 0d a4 13 00 00 lea 0x13a4(%rip),%rcx
+9ac: 48 39 c8 cmp %rcx,%rax
+9af: 75 25 jne 9d6 <main+0x86>
+9b1: 48 89 df mov %rbx,%rdi
+9b4: ff 10 callq *(%rax)
+[...]
+9d6: 0f 0b ud2
+</pre></div>
+</div>
+</div>
+<div class="section" id="virtual-table-layout">
+<h4>Virtual Table Layout<a class="headerlink" href="#virtual-table-layout" title="Permalink to this headline">¶</a></h4>
+<p>The compiler lays out classes of disjoint hierarchies in separate regions
+of the object file. At worst, bit vectors in disjoint hierarchies only
+need to cover their disjoint hierarchy. But the closer that classes in
+sub-hierarchies are laid out to each other, the smaller the bit vectors for
+those sub-hierarchies need to be (see “Stripping Leading/Trailing Zeros in Bit
+Vectors” above). The <a class="reference external" href="http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Transforms/IPO/LowerTypeTests.h?view=markup">GlobalLayoutBuilder</a> class is responsible for laying
+out the globals efficiently to minimize the sizes of the underlying bitsets.</p>
+</div>
+<div class="section" id="alignment">
+<h4>Alignment<a class="headerlink" href="#alignment" title="Permalink to this headline">¶</a></h4>
+<p>If all gaps between address points in a particular bit vector are multiples
+of powers of 2, the compiler can compress the bit vector by strengthening
+the alignment requirements of the virtual table pointer. For example, given
+this class hierarchy:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span class="k">struct</span> <span class="n">A</span> <span class="p">{</span>
+ <span class="k">virtual</span> <span class="kt">void</span> <span class="n">f1</span><span class="p">();</span>
+ <span class="k">virtual</span> <span class="kt">void</span> <span class="n">f2</span><span class="p">();</span>
+<span class="p">};</span>
+
+<span class="k">struct</span> <span class="n">B</span> <span class="o">:</span> <span class="n">A</span> <span class="p">{</span>
+ <span class="k">virtual</span> <span class="kt">void</span> <span class="n">f1</span><span class="p">();</span>
+ <span class="k">virtual</span> <span class="kt">void</span> <span class="n">f2</span><span class="p">();</span>
+ <span class="k">virtual</span> <span class="kt">void</span> <span class="n">f3</span><span class="p">();</span>
+ <span class="k">virtual</span> <span class="kt">void</span> <span class="n">f4</span><span class="p">();</span>
+ <span class="k">virtual</span> <span class="kt">void</span> <span class="n">f5</span><span class="p">();</span>
+ <span class="k">virtual</span> <span class="kt">void</span> <span class="n">f6</span><span class="p">();</span>
+<span class="p">};</span>
+
+<span class="k">struct</span> <span class="n">C</span> <span class="o">:</span> <span class="n">A</span> <span class="p">{</span>
+ <span class="k">virtual</span> <span class="kt">void</span> <span class="n">f1</span><span class="p">();</span>
+ <span class="k">virtual</span> <span class="kt">void</span> <span class="n">f2</span><span class="p">();</span>
+<span class="p">};</span>
+</pre></div>
+</div>
+<p>The virtual tables will be laid out like this:</p>
+<table border="1" class="docutils">
+<caption>Virtual Table Layout for A, B, C</caption>
+<colgroup>
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">0</th>
+<th class="head">1</th>
+<th class="head">2</th>
+<th class="head">3</th>
+<th class="head">4</th>
+<th class="head">5</th>
+<th class="head">6</th>
+<th class="head">7</th>
+<th class="head">8</th>
+<th class="head">9</th>
+<th class="head">10</th>
+<th class="head">11</th>
+<th class="head">12</th>
+<th class="head">13</th>
+<th class="head">14</th>
+<th class="head">15</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>A::offset-to-top</td>
+<td>&A::rtti</td>
+<td>&A::f1</td>
+<td>&A::f2</td>
+<td>B::offset-to-top</td>
+<td>&B::rtti</td>
+<td>&B::f1</td>
+<td>&B::f2</td>
+<td>&B::f3</td>
+<td>&B::f4</td>
+<td>&B::f5</td>
+<td>&B::f6</td>
+<td>C::offset-to-top</td>
+<td>&C::rtti</td>
+<td>&C::f1</td>
+<td>&C::f2</td>
+</tr>
+</tbody>
+</table>
+<p>Notice that each address point for A is separated by 4 words. This lets us
+emit a compressed bit vector for A that looks like this:</p>
+<table border="1" class="docutils">
+<colgroup>
+<col width="25%" />
+<col width="25%" />
+<col width="25%" />
+<col width="25%" />
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">2</th>
+<th class="head">6</th>
+<th class="head">10</th>
+<th class="head">14</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>1</td>
+<td>1</td>
+<td>0</td>
+<td>1</td>
+</tr>
+</tbody>
+</table>
+<p>At call sites, the compiler will strengthen the alignment requirements by
+using a different rotate count. For example, on a 64-bit machine where the
+address points are 4-word aligned (as in A from our example), the <tt class="docutils literal"><span class="pre">rol</span></tt>
+instruction may look like this:</p>
+<div class="highlight-none"><div class="highlight"><pre>dd2: 48 c1 c1 3b rol $0x3b,%rcx
+</pre></div>
+</div>
+</div>
+<div class="section" id="padding-to-powers-of-2">
+<h4>Padding to Powers of 2<a class="headerlink" href="#padding-to-powers-of-2" title="Permalink to this headline">¶</a></h4>
+<p>Of course, this alignment scheme works best if the address points are
+in fact aligned correctly. To make this more likely to happen, we insert
+padding between virtual tables that in many cases aligns address points to
+a power of 2. Specifically, our padding aligns virtual tables to the next
+highest power of 2 bytes; because address points for specific base classes
+normally appear at fixed offsets within the virtual table, this normally
+has the effect of aligning the address points as well.</p>
+<p>This scheme introduces tradeoffs between decreased space overhead for
+instructions and bit vectors and increased overhead in the form of padding. We
+therefore limit the amount of padding so that we align to no more than 128
+bytes. This number was found experimentally to provide a good tradeoff.</p>
+</div>
+<div class="section" id="eliminating-bit-vector-checks-for-all-ones-bit-vectors">
+<h4>Eliminating Bit Vector Checks for All-Ones Bit Vectors<a class="headerlink" href="#eliminating-bit-vector-checks-for-all-ones-bit-vectors" title="Permalink to this headline">¶</a></h4>
+<p>If the bit vector is all ones, the bit vector check is redundant; we simply
+need to check that the address is in range and well aligned. This is more
+likely to occur if the virtual tables are padded.</p>
+</div>
+</div>
+</div>
+<div class="section" id="forward-edge-cfi-for-indirect-function-calls">
+<h2>Forward-Edge CFI for Indirect Function Calls<a class="headerlink" href="#forward-edge-cfi-for-indirect-function-calls" title="Permalink to this headline">¶</a></h2>
+<p>Under forward-edge CFI for indirect function calls, each unique function
+type has its own bit vector, and at each call site we need to check that the
+function pointer is a member of the function type’s bit vector. This scheme
+works in a similar way to forward-edge CFI for virtual calls, the distinction
+being that we need to build bit vectors of function entry points rather than
+of virtual tables.</p>
+<p>Unlike when re-arranging global variables, we cannot re-arrange functions
+in a particular order and base our calculations on the layout of the
+functions’ entry points, as we have no idea how large a particular function
+will end up being (the function sizes could even depend on how we arrange
+the functions). Instead, we build a jump table, which is a block of code
+consisting of one branch instruction for each of the functions in the bit
+set that branches to the target function, and redirect any taken function
+addresses to the corresponding jump table entry. In this way, the distance
+between function entry points is predictable and controllable. In the object
+file’s symbol table, the symbols for the target functions also refer to the
+jump table entries, so that addresses taken outside the module will pass
+any verification done inside the module.</p>
+<p>In more concrete terms, suppose we have three functions <tt class="docutils literal"><span class="pre">f</span></tt>, <tt class="docutils literal"><span class="pre">g</span></tt>,
+<tt class="docutils literal"><span class="pre">h</span></tt> which are all of the same type, and a function foo that returns their
+addresses:</p>
+<div class="highlight-none"><div class="highlight"><pre>f:
+mov 0, %eax
+ret
+
+g:
+mov 1, %eax
+ret
+
+h:
+mov 2, %eax
+ret
+
+foo:
+mov f, %eax
+mov g, %edx
+mov h, %ecx
+ret
+</pre></div>
+</div>
+<p>Our jump table will (conceptually) look like this:</p>
+<div class="highlight-none"><div class="highlight"><pre>f:
+jmp .Ltmp0 ; 5 bytes
+int3 ; 1 byte
+int3 ; 1 byte
+int3 ; 1 byte
+
+g:
+jmp .Ltmp1 ; 5 bytes
+int3 ; 1 byte
+int3 ; 1 byte
+int3 ; 1 byte
+
+h:
+jmp .Ltmp2 ; 5 bytes
+int3 ; 1 byte
+int3 ; 1 byte
+int3 ; 1 byte
+
+.Ltmp0:
+mov 0, %eax
+ret
+
+.Ltmp1:
+mov 1, %eax
+ret
+
+.Ltmp2:
+mov 2, %eax
+ret
+
+foo:
+mov f, %eax
+mov g, %edx
+mov h, %ecx
+ret
+</pre></div>
+</div>
+<p>Because the addresses of <tt class="docutils literal"><span class="pre">f</span></tt>, <tt class="docutils literal"><span class="pre">g</span></tt>, <tt class="docutils literal"><span class="pre">h</span></tt> are evenly spaced at a power of
+2, and function types do not overlap (unlike class types with base classes),
+we can normally apply the <a class="reference internal" href="#alignment">Alignment</a> and <a class="reference internal" href="#eliminating-bit-vector-checks-for-all-ones-bit-vectors">Eliminating Bit Vector Checks
+for All-Ones Bit Vectors</a> optimizations thus simplifying the check at each
+call site to a range and alignment check.</p>
+</div>
+<div class="section" id="shared-library-support">
+<h2>Shared library support<a class="headerlink" href="#shared-library-support" title="Permalink to this headline">¶</a></h2>
+<p><strong>EXPERIMENTAL</strong></p>
+<p>The basic CFI mode described above assumes that the application is a
+monolithic binary; at least that all possible virtual/indirect call
+targets and the entire class hierarchy are known at link time. The
+cross-DSO mode, enabled with <strong>-f[no-]sanitize-cfi-cross-dso</strong> relaxes
+this requirement by allowing virtual and indirect calls to cross the
+DSO boundary.</p>
+<p>Assuming the following setup: the binary consists of several
+instrumented and several uninstrumented DSOs. Some of them may be
+dlopen-ed/dlclose-d periodically, even frequently.</p>
+<blockquote>
+<div><ul>
+<li><p class="first">Calls made from uninstrumented DSOs are not checked and just work.</p>
+</li>
+<li><p class="first">Calls inside any instrumented DSO are fully protected.</p>
+</li>
+<li><dl class="first docutils">
+<dt>Calls between different instrumented DSOs are also protected, with</dt>
+<dd><p class="first last">a performance penalty (in addition to the monolithic CFI
+overhead).</p>
+</dd>
+</dl>
+</li>
+<li><dl class="first docutils">
+<dt>Calls from an instrumented DSO to an uninstrumented one are</dt>
+<dd><p class="first last">unchecked and just work, with performance penalty.</p>
+</dd>
+</dl>
+</li>
+<li><dl class="first docutils">
+<dt>Calls from an instrumented DSO outside of any known DSO are</dt>
+<dd><p class="first last">detected as CFI violations.</p>
+</dd>
+</dl>
+</li>
+</ul>
+</div></blockquote>
+<p>In the monolithic scheme a call site is instrumented as</p>
+<div class="highlight-none"><div class="highlight"><pre>if (!InlinedFastCheck(f))
+ abort();
+call *f
+</pre></div>
+</div>
+<p>In the cross-DSO scheme it becomes</p>
+<div class="highlight-none"><div class="highlight"><pre>if (!InlinedFastCheck(f))
+ __cfi_slowpath(CallSiteTypeId, f);
+call *f
+</pre></div>
+</div>
+<div class="section" id="callsitetypeid">
+<h3>CallSiteTypeId<a class="headerlink" href="#callsitetypeid" title="Permalink to this headline">¶</a></h3>
+<p><tt class="docutils literal"><span class="pre">CallSiteTypeId</span></tt> is a stable process-wide identifier of the
+call-site type. For a virtual call site, the type in question is the class
+type; for an indirect function call it is the function signature. The
+mapping from a type to an identifier is an ABI detail. In the current,
+experimental, implementation the identifier of type T is calculated as
+follows:</p>
+<blockquote>
+<div><ul class="simple">
+<li>Obtain the mangled name for “typeinfo name for T”.</li>
+<li>Calculate MD5 hash of the name as a string.</li>
+<li>Reinterpret the first 8 bytes of the hash as a little-endian
+64-bit integer.</li>
+</ul>
+</div></blockquote>
+<p>It is possible, but unlikely, that collisions in the
+<tt class="docutils literal"><span class="pre">CallSiteTypeId</span></tt> hashing will result in weaker CFI checks that would
+still be conservatively correct.</p>
+</div>
+<div class="section" id="cfi-check">
+<h3>CFI_Check<a class="headerlink" href="#cfi-check" title="Permalink to this headline">¶</a></h3>
+<p>In the general case, only the target DSO knows whether the call to
+function <tt class="docutils literal"><span class="pre">f</span></tt> with type <tt class="docutils literal"><span class="pre">CallSiteTypeId</span></tt> is valid or not. To
+export this information, every DSO implements</p>
+<div class="highlight-none"><div class="highlight"><pre>void __cfi_check(uint64 CallSiteTypeId, void *TargetAddr, void *DiagData)
+</pre></div>
+</div>
+<p>This function provides external modules with access to CFI checks for
+the targets inside this DSO. For each known <tt class="docutils literal"><span class="pre">CallSiteTypeId</span></tt>, this
+function performs an <tt class="docutils literal"><span class="pre">llvm.type.test</span></tt> with the corresponding type
+identifier. It reports an error if the type is unknown, or if the
+check fails. Depending on the values of compiler flags
+<tt class="docutils literal"><span class="pre">-fsanitize-trap</span></tt> and <tt class="docutils literal"><span class="pre">-fsanitize-recover</span></tt>, this function may
+print an error, abort and/or return to the caller. <tt class="docutils literal"><span class="pre">DiagData</span></tt> is an
+opaque pointer to the diagnostic information about the error, or
+<tt class="docutils literal"><span class="pre">null</span></tt> if the caller does not provide this information.</p>
+<p>The basic implementation is a large switch statement over all values
+of CallSiteTypeId supported by this DSO, and each case is similar to
+the InlinedFastCheck() in the basic CFI mode.</p>
+</div>
+<div class="section" id="cfi-shadow">
+<h3>CFI Shadow<a class="headerlink" href="#cfi-shadow" title="Permalink to this headline">¶</a></h3>
+<p>To route CFI checks to the target DSO’s __cfi_check function, a
+mapping from possible virtual / indirect call targets to the
+corresponding __cfi_check functions is maintained. This mapping is
+implemented as a sparse array of 2 bytes for every possible page (4096
+bytes) of memory. The table is kept readonly most of the time.</p>
+<p>There are 3 types of shadow values:</p>
+<blockquote>
+<div><ul class="simple">
+<li>Address in a CFI-instrumented DSO.</li>
+<li>Unchecked address (a âtrustedâ non-instrumented DSO). Encoded as
+value 0xFFFF.</li>
+<li>Invalid address (everything else). Encoded as value 0.</li>
+</ul>
+</div></blockquote>
+<p>For a CFI-instrumented DSO, a shadow value encodes the address of the
+__cfi_check function for all call targets in the corresponding memory
+page. If Addr is the target address, and V is the shadow value, then
+the address of __cfi_check is calculated as</p>
+<div class="highlight-none"><div class="highlight"><pre>__cfi_check = AlignUpTo(Addr, 4096) - (V + 1) * 4096
+</pre></div>
+</div>
+<p>This works as long as __cfi_check is aligned by 4096 bytes and located
+below any call targets in its DSO, but not more than 256MB apart from
+them.</p>
+</div>
+<div class="section" id="cfi-slowpath">
+<h3>CFI_SlowPath<a class="headerlink" href="#cfi-slowpath" title="Permalink to this headline">¶</a></h3>
+<p>The slow path check is implemented in a runtime support library as</p>
+<div class="highlight-none"><div class="highlight"><pre>void __cfi_slowpath(uint64 CallSiteTypeId, void *TargetAddr)
+void __cfi_slowpath_diag(uint64 CallSiteTypeId, void *TargetAddr, void *DiagData)
+</pre></div>
+</div>
+<p>These functions loads a shadow value for <tt class="docutils literal"><span class="pre">TargetAddr</span></tt>, finds the
+address of <tt class="docutils literal"><span class="pre">__cfi_check</span></tt> as described above and calls
+that. <tt class="docutils literal"><span class="pre">DiagData</span></tt> is an opaque pointer to diagnostic data which is
+passed verbatim to <tt class="docutils literal"><span class="pre">__cfi_check</span></tt>, and <tt class="docutils literal"><span class="pre">__cfi_slowpath</span></tt> passes
+<tt class="docutils literal"><span class="pre">nullptr</span></tt> instead.</p>
+<p>Compiler-RT library contains reference implementations of slowpath
+functions, but they have unresolvable issues with correctness and
+performance in the handling of dlopen(). It is recommended that
+platforms provide their own implementations, usually as part of libc
+or libdl.</p>
+</div>
+<div class="section" id="position-independent-executable-requirement">
+<h3>Position-independent executable requirement<a class="headerlink" href="#position-independent-executable-requirement" title="Permalink to this headline">¶</a></h3>
+<p>Cross-DSO CFI mode requires that the main executable is built as PIE.
+In non-PIE executables the address of an external function (taken from
+the main executable) is the address of that functionâs PLT record in
+the main executable. This would break the CFI checks.</p>
+</div>
+</div>
+<div class="section" id="backward-edge-cfi-for-return-statements-rcfi">
+<h2>Backward-edge CFI for return statements (RCFI)<a class="headerlink" href="#backward-edge-cfi-for-return-statements-rcfi" title="Permalink to this headline">¶</a></h2>
+<p>This section is a proposal. As of March 2017 it is not implemented.</p>
+<p>Backward-edge control flow (<cite>RET</cite> instructions) can be hijacked
+via overwriting the return address (<cite>RA</cite>) on stack.
+Various mitigation techniques (e.g. <a class="reference external" href="https://clang.llvm.org/docs/SafeStack.html">SafeStack</a>, <a class="reference external" href="http://xlab.tencent.com/en/2016/11/02/return-flow-guard">RFG</a>, <a class="reference external" href="https://software.intel.com/en-us/blogs/2016/06/09/intel-release-new-technology-specifications-protect-rop-attacks">Intel CET</a>)
+try to detect or prevent <cite>RA</cite> corruption on stack.</p>
+<p>RCFI enforces the expected control flow in several different ways described below.
+RCFI heavily relies on LTO.</p>
+<div class="section" id="leaf-functions">
+<h3>Leaf Functions<a class="headerlink" href="#leaf-functions" title="Permalink to this headline">¶</a></h3>
+<p>If <cite>f()</cite> is a leaf function (i.e. it has no calls
+except maybe no-return calls) it can be called using a special calling convention
+that stores <cite>RA</cite> in a dedicated register <cite>R</cite> before the <cite>CALL</cite> instruction.
+<cite>f()</cite> does not spill <cite>R</cite> and does not use the <cite>RET</cite> instruction,
+instead it uses the value in <cite>R</cite> to <cite>JMP</cite> to <cite>RA</cite>.</p>
+<p>This flavour of CFI is <em>precise</em>, i.e. the function is guaranteed to return
+to the point exactly following the call.</p>
+<p>An alternative approach is to
+copy <cite>RA</cite> from stack to <cite>R</cite> in the first instruction of <cite>f()</cite>,
+then <cite>JMP</cite> to <cite>R</cite>.
+This approach is simpler to implement (does not require changing the caller)
+but weaker (there is a small window when <cite>RA</cite> is actually stored on stack).</p>
+</div>
+<div class="section" id="functions-called-once">
+<h3>Functions called once<a class="headerlink" href="#functions-called-once" title="Permalink to this headline">¶</a></h3>
+<p>Suppose <cite>f()</cite> is called in just one place in the program
+(assuming we can verify this in LTO mode).
+In this case we can replace the <cite>RET</cite> instruction with a <cite>JMP</cite> instruction
+with the immediate constant for <cite>RA</cite>.
+This will <em>precisely</em> enforce the return control flow no matter what is stored on stack.</p>
+<p>Another variant is to compare <cite>RA</cite> on stack with the known constant and abort
+if they don’t match; then <cite>JMP</cite> to the known constant address.</p>
+</div>
+<div class="section" id="functions-called-in-a-small-number-of-call-sites">
+<h3>Functions called in a small number of call sites<a class="headerlink" href="#functions-called-in-a-small-number-of-call-sites" title="Permalink to this headline">¶</a></h3>
+<p>We may extend the above approach to cases where <cite>f()</cite>
+is called more than once (but still a small number of times).
+With LTO we know all possible values of <cite>RA</cite> and we check them
+one-by-one (or using binary search) against the value on stack.
+If the match is found, we <cite>JMP</cite> to the known constant address, otherwise abort.</p>
+<p>This protection is <em>near-precise</em>, i.e. it guarantees that the control flow will
+be transferred to one of the valid return addresses for this function,
+but not necessary to the point of the most recent <cite>CALL</cite>.</p>
+</div>
+<div class="section" id="general-case">
+<h3>General case<a class="headerlink" href="#general-case" title="Permalink to this headline">¶</a></h3>
+<p>For functions called multiple times a <em>return jump table</em> is constructed
+in the same manner as jump tables for indirect function calls (see above).
+The correct jump table entry (or it’s index) is passed by <cite>CALL</cite> to <cite>f()</cite>
+(as an extra argument) and then spilled to stack.
+The <cite>RET</cite> instruction is replaced with a load of the jump table entry,
+jump table range check, and <cite>JMP</cite> to the jump table entry.</p>
+<p>This protection is also <em>near-precise</em>.</p>
+</div>
+<div class="section" id="returns-from-functions-called-indirectly">
+<h3>Returns from functions called indirectly<a class="headerlink" href="#returns-from-functions-called-indirectly" title="Permalink to this headline">¶</a></h3>
+<p>If a function is called indirectly, the return jump table is constructed for the
+equivalence class of functions instead of a single function.</p>
+</div>
+<div class="section" id="cross-dso-calls">
+<h3>Cross-DSO calls<a class="headerlink" href="#cross-dso-calls" title="Permalink to this headline">¶</a></h3>
+<p>Consider two instrumented DSOs, <cite>A</cite> and <cite>B</cite>. <cite>A</cite> defines <cite>f()</cite> and <cite>B</cite> calls it.</p>
+<p>This case will be handled similarly to the cross-DSO scheme using the slow path callback.</p>
+</div>
+<div class="section" id="non-goals">
+<h3>Non-goals<a class="headerlink" href="#non-goals" title="Permalink to this headline">¶</a></h3>
+<dl class="docutils">
+<dt>RCFI does not protect <cite>RET</cite> instructions:</dt>
+<dd><ul class="first last simple">
+<li>in non-instrumented DSOs,</li>
+<li>in instrumented DSOs for functions that are called from non-instrumented DSOs,</li>
+<li>embedded into other instructions (e.g. <cite>0f4fc3 cmovg %ebx,%eax</cite>).</li>
+</ul>
+</dd>
+</dl>
+</div>
+</div>
+<div class="section" id="hardware-support">
+<h2>Hardware support<a class="headerlink" href="#hardware-support" title="Permalink to this headline">¶</a></h2>
+<p>We believe that the above design can be efficiently implemented in hardware.
+A single new instruction added to an ISA would allow to perform the forward-edge CFI check
+with fewer bytes per check (smaller code size overhead) and potentially more
+efficiently. The current software-only instrumentation requires at least
+32-bytes per check (on x86_64).
+A hardware instruction may probably be less than ~ 12 bytes.
+Such instruction would check that the argument pointer is in-bounds,
+and is properly aligned, and if the checks fail it will either trap (in monolithic scheme)
+or call the slow path function (cross-DSO scheme).
+The bit vector lookup is probably too complex for a hardware implementation.</p>
+<div class="highlight-none"><div class="highlight"><pre>// This instruction checks that 'Ptr'
+// * is aligned by (1 << kAlignment) and
+// * is inside [kRangeBeg, kRangeBeg+(kRangeSize<<kAlignment))
+// and if the check fails it jumps to the given target (slow path).
+//
+// 'Ptr' is a register, pointing to the virtual function table
+// or to the function which we need to check. We may require an explicit
+// fixed register to be used.
+// 'kAlignment' is a 4-bit constant.
+// 'kRangeSize' is a ~20-bit constant.
+// 'kRangeBeg' is a PC-relative constant (~28 bits)
+// pointing to the beginning of the allowed range for 'Ptr'.
+// 'kFailedCheckTarget': is a PC-relative constant (~28 bits)
+// representing the target to branch to when the check fails.
+// If kFailedCheckTarget==0, the process will trap
+// (monolithic binary scheme).
+// Otherwise it will jump to a handler that implements `CFI_SlowPath`
+// (cross-DSO scheme).
+CFI_Check(Ptr, kAlignment, kRangeSize, kRangeBeg, kFailedCheckTarget) {
+ if (Ptr < kRangeBeg ||
+ Ptr >= kRangeBeg + (kRangeSize << kAlignment) ||
+ Ptr & ((1 << kAlignment) - 1))
+ Jump(kFailedCheckTarget);
+}
+</pre></div>
+</div>
+<p>An alternative and more compact encoding would not use <cite>kFailedCheckTarget</cite>,
+and will trap on check failure instead.
+This will allow us to fit the instruction into <strong>8-9 bytes</strong>.
+The cross-DSO checks will be performed by a trap handler and
+performance-critical ones will have to be black-listed and checked using the
+software-only scheme.</p>
+<p>Note that such hardware extension would be complementary to checks
+at the callee side, such as e.g. <strong>Intel ENDBRANCH</strong>.
+Moreover, CFI would have two benefits over ENDBRANCH: a) precision and b)
+ability to protect against invalid casts between polymorphic types.</p>
+</div>
+</div>
+
+
+ </div>
+ <div class="bottomnav">
+
+ <p>
+ « <a href="ControlFlowIntegrity.html">Control Flow Integrity</a>
+ ::
+ <a class="uplink" href="index.html">Contents</a>
+ ::
+ <a href="LTOVisibility.html">LTO Visibility</a> »
+ </p>
+
+ </div>
+
+ <div class="footer">
+ © Copyright 2007-2018, The Clang Team.
+ Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/6.0.1/tools/clang/docs/CrossCompilation.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/6.0.1/tools/clang/docs/CrossCompilation.html?rev=336152&view=auto
==============================================================================
--- www-releases/trunk/6.0.1/tools/clang/docs/CrossCompilation.html (added)
+++ www-releases/trunk/6.0.1/tools/clang/docs/CrossCompilation.html Mon Jul 2 16:21:43 2018
@@ -0,0 +1,263 @@
+
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+ <title>Cross-compilation using Clang — Clang 6 documentation</title>
+
+ <link rel="stylesheet" href="_static/haiku.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+ <link rel="stylesheet" href="_static/print.css" type="text/css" />
+
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: '',
+ VERSION: '6',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true
+ };
+ </script>
+ <script type="text/javascript" src="_static/jquery.js"></script>
+ <script type="text/javascript" src="_static/underscore.js"></script>
+ <script type="text/javascript" src="_static/doctools.js"></script>
+ <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+ <script type="text/javascript" src="_static/theme_extras.js"></script>
+ <link rel="top" title="Clang 6 documentation" href="index.html" />
+ <link rel="next" title="Thread Safety Analysis" href="ThreadSafetyAnalysis.html" />
+ <link rel="prev" title="Diagnostic flags in Clang" href="DiagnosticsReference.html" />
+ </head>
+ <body>
+ <div class="header"><h1 class="heading"><a href="index.html">
+ <span>Clang 6 documentation</span></a></h1>
+ <h2 class="heading"><span>Cross-compilation using Clang</span></h2>
+ </div>
+ <div class="topnav">
+
+ <p>
+ « <a href="DiagnosticsReference.html">Diagnostic flags in Clang</a>
+ ::
+ <a class="uplink" href="index.html">Contents</a>
+ ::
+ <a href="ThreadSafetyAnalysis.html">Thread Safety Analysis</a> »
+ </p>
+
+ </div>
+ <div class="content">
+
+
+ <div class="section" id="cross-compilation-using-clang">
+<h1>Cross-compilation using Clang<a class="headerlink" href="#cross-compilation-using-clang" title="Permalink to this headline">¶</a></h1>
+<div class="section" id="introduction">
+<h2>Introduction<a class="headerlink" href="#introduction" title="Permalink to this headline">¶</a></h2>
+<p>This document will guide you in choosing the right Clang options
+for cross-compiling your code to a different architecture. It assumes you
+already know how to compile the code in question for the host architecture,
+and that you know how to choose additional include and library paths.</p>
+<p>However, this document is <em>not</em> a “how to” and won’t help you setting your
+build system or Makefiles, nor choosing the right CMake options, etc.
+Also, it does not cover all the possible options, nor does it contain
+specific examples for specific architectures. For a concrete example, the
+<a class="reference external" href="http://llvm.org/docs/HowToCrossCompileLLVM.html">instructions for cross-compiling LLVM itself</a> may be of interest.</p>
+<p>After reading this document, you should be familiar with the main issues
+related to cross-compilation, and what main compiler options Clang provides
+for performing cross-compilation.</p>
+</div>
+<div class="section" id="cross-compilation-issues">
+<h2>Cross compilation issues<a class="headerlink" href="#cross-compilation-issues" title="Permalink to this headline">¶</a></h2>
+<p>In GCC world, every host/target combination has its own set of binaries,
+headers, libraries, etc. So, it’s usually simple to download a package
+with all files in, unzip to a directory and point the build system to
+that compiler, that will know about its location and find all it needs to
+when compiling your code.</p>
+<p>On the other hand, Clang/LLVM is natively a cross-compiler, meaning that
+one set of programs can compile to all targets by setting the <tt class="docutils literal"><span class="pre">-target</span></tt>
+option. That makes it a lot easier for programmers wishing to compile to
+different platforms and architectures, and for compiler developers that
+only have to maintain one build system, and for OS distributions, that
+need only one set of main packages.</p>
+<p>But, as is true to any cross-compiler, and given the complexity of
+different architectures, OS’s and options, it’s not always easy finding
+the headers, libraries or binutils to generate target specific code.
+So you’ll need special options to help Clang understand what target
+you’re compiling to, where your tools are, etc.</p>
+<p>Another problem is that compilers come with standard libraries only (like
+<tt class="docutils literal"><span class="pre">compiler-rt</span></tt>, <tt class="docutils literal"><span class="pre">libcxx</span></tt>, <tt class="docutils literal"><span class="pre">libgcc</span></tt>, <tt class="docutils literal"><span class="pre">libm</span></tt>, etc), so you’ll have to
+find and make available to the build system, every other library required
+to build your software, that is specific to your target. It’s not enough to
+have your host’s libraries installed.</p>
+<p>Finally, not all toolchains are the same, and consequently, not every Clang
+option will work magically. Some options, like <tt class="docutils literal"><span class="pre">--sysroot</span></tt> (which
+effectively changes the logical root for headers and libraries), assume
+all your binaries and libraries are in the same directory, which may not
+true when your cross-compiler was installed by the distribution’s package
+management. So, for each specific case, you may use more than one
+option, and in most cases, you’ll end up setting include paths (<tt class="docutils literal"><span class="pre">-I</span></tt>) and
+library paths (<tt class="docutils literal"><span class="pre">-L</span></tt>) manually.</p>
+<dl class="docutils">
+<dt>To sum up, different toolchains can:</dt>
+<dd><ul class="first last simple">
+<li>be host/target specific or more flexible</li>
+<li>be in a single directory, or spread out across your system</li>
+<li>have different sets of libraries and headers by default</li>
+<li>need special options, which your build system won’t be able to figure
+out by itself</li>
+</ul>
+</dd>
+</dl>
+</div>
+<div class="section" id="general-cross-compilation-options-in-clang">
+<h2>General Cross-Compilation Options in Clang<a class="headerlink" href="#general-cross-compilation-options-in-clang" title="Permalink to this headline">¶</a></h2>
+<div class="section" id="target-triple">
+<h3>Target Triple<a class="headerlink" href="#target-triple" title="Permalink to this headline">¶</a></h3>
+<p>The basic option is to define the target architecture. For that, use
+<tt class="docutils literal"><span class="pre">-target</span> <span class="pre"><triple></span></tt>. If you don’t specify the target, CPU names won’t
+match (since Clang assumes the host triple), and the compilation will
+go ahead, creating code for the host platform, which will break later
+on when assembling or linking.</p>
+<dl class="docutils">
+<dt>The triple has the general format <tt class="docutils literal"><span class="pre"><arch><sub>-<vendor>-<sys>-<abi></span></tt>, where:</dt>
+<dd><ul class="first last simple">
+<li><tt class="docutils literal"><span class="pre">arch</span></tt> = <tt class="docutils literal"><span class="pre">x86_64</span></tt>, <tt class="docutils literal"><span class="pre">i386</span></tt>, <tt class="docutils literal"><span class="pre">arm</span></tt>, <tt class="docutils literal"><span class="pre">thumb</span></tt>, <tt class="docutils literal"><span class="pre">mips</span></tt>, etc.</li>
+<li><tt class="docutils literal"><span class="pre">sub</span></tt> = for ex. on ARM: <tt class="docutils literal"><span class="pre">v5</span></tt>, <tt class="docutils literal"><span class="pre">v6m</span></tt>, <tt class="docutils literal"><span class="pre">v7a</span></tt>, <tt class="docutils literal"><span class="pre">v7m</span></tt>, etc.</li>
+<li><tt class="docutils literal"><span class="pre">vendor</span></tt> = <tt class="docutils literal"><span class="pre">pc</span></tt>, <tt class="docutils literal"><span class="pre">apple</span></tt>, <tt class="docutils literal"><span class="pre">nvidia</span></tt>, <tt class="docutils literal"><span class="pre">ibm</span></tt>, etc.</li>
+<li><tt class="docutils literal"><span class="pre">sys</span></tt> = <tt class="docutils literal"><span class="pre">none</span></tt>, <tt class="docutils literal"><span class="pre">linux</span></tt>, <tt class="docutils literal"><span class="pre">win32</span></tt>, <tt class="docutils literal"><span class="pre">darwin</span></tt>, <tt class="docutils literal"><span class="pre">cuda</span></tt>, etc.</li>
+<li><tt class="docutils literal"><span class="pre">abi</span></tt> = <tt class="docutils literal"><span class="pre">eabi</span></tt>, <tt class="docutils literal"><span class="pre">gnu</span></tt>, <tt class="docutils literal"><span class="pre">android</span></tt>, <tt class="docutils literal"><span class="pre">macho</span></tt>, <tt class="docutils literal"><span class="pre">elf</span></tt>, etc.</li>
+</ul>
+</dd>
+</dl>
+<p>The sub-architecture options are available for their own architectures,
+of course, so “x86v7a” doesn’t make sense. The vendor needs to be
+specified only if there’s a relevant change, for instance between PC
+and Apple. Most of the time it can be omitted (and Unknown)
+will be assumed, which sets the defaults for the specified architecture.
+The system name is generally the OS (linux, darwin), but could be special
+like the bare-metal “none”.</p>
+<p>When a parameter is not important, it can be omitted, or you can
+choose <tt class="docutils literal"><span class="pre">unknown</span></tt> and the defaults will be used. If you choose a parameter
+that Clang doesn’t know, like <tt class="docutils literal"><span class="pre">blerg</span></tt>, it’ll ignore and assume
+<tt class="docutils literal"><span class="pre">unknown</span></tt>, which is not always desired, so be careful.</p>
+<p>Finally, the ABI option is something that will pick default CPU/FPU,
+define the specific behaviour of your code (PCS, extensions),
+and also choose the correct library calls, etc.</p>
+</div>
+<div class="section" id="cpu-fpu-abi">
+<h3>CPU, FPU, ABI<a class="headerlink" href="#cpu-fpu-abi" title="Permalink to this headline">¶</a></h3>
+<p>Once your target is specified, it’s time to pick the hardware you’ll
+be compiling to. For every architecture, a default set of CPU/FPU/ABI
+will be chosen, so you’ll almost always have to change it via flags.</p>
+<dl class="docutils">
+<dt>Typical flags include:</dt>
+<dd><ul class="first last simple">
+<li><tt class="docutils literal"><span class="pre">-mcpu=<cpu-name></span></tt>, like x86-64, swift, cortex-a15</li>
+<li><tt class="docutils literal"><span class="pre">-mfpu=<fpu-name></span></tt>, like SSE3, NEON, controlling the FP unit available</li>
+<li><tt class="docutils literal"><span class="pre">-mfloat-abi=<fabi></span></tt>, like soft, hard, controlling which registers
+to use for floating-point</li>
+</ul>
+</dd>
+</dl>
+<p>The default is normally the common denominator, so that Clang doesn’t
+generate code that breaks. But that also means you won’t get the best
+code for your specific hardware, which may mean orders of magnitude
+slower than you expect.</p>
+<p>For example, if your target is <tt class="docutils literal"><span class="pre">arm-none-eabi</span></tt>, the default CPU will
+be <tt class="docutils literal"><span class="pre">arm7tdmi</span></tt> using soft float, which is extremely slow on modern cores,
+whereas if your triple is <tt class="docutils literal"><span class="pre">armv7a-none-eabi</span></tt>, it’ll be Cortex-A8 with
+NEON, but still using soft-float, which is much better, but still not
+great.</p>
+</div>
+<div class="section" id="toolchain-options">
+<h3>Toolchain Options<a class="headerlink" href="#toolchain-options" title="Permalink to this headline">¶</a></h3>
+<p>There are three main options to control access to your cross-compiler:
+<tt class="docutils literal"><span class="pre">--sysroot</span></tt>, <tt class="docutils literal"><span class="pre">-I</span></tt>, and <tt class="docutils literal"><span class="pre">-L</span></tt>. The two last ones are well known,
+but they’re particularly important for additional libraries
+and headers that are specific to your target.</p>
+<p>There are two main ways to have a cross-compiler:</p>
+<ol class="arabic">
+<li><p class="first">When you have extracted your cross-compiler from a zip file into
+a directory, you have to use <tt class="docutils literal"><span class="pre">--sysroot=<path></span></tt>. The path is the
+root directory where you have unpacked your file, and Clang will
+look for the directories <tt class="docutils literal"><span class="pre">bin</span></tt>, <tt class="docutils literal"><span class="pre">lib</span></tt>, <tt class="docutils literal"><span class="pre">include</span></tt> in there.</p>
+<p>In this case, your setup should be pretty much done (if no
+additional headers or libraries are needed), as Clang will find
+all binaries it needs (assembler, linker, etc) in there.</p>
+</li>
+<li><p class="first">When you have installed via a package manager (modern Linux
+distributions have cross-compiler packages available), make
+sure the target triple you set is <em>also</em> the prefix of your
+cross-compiler toolchain.</p>
+<p>In this case, Clang will find the other binaries (assembler,
+linker), but not always where the target headers and libraries
+are. People add system-specific clues to Clang often, but as
+things change, it’s more likely that it won’t find than the
+other way around.</p>
+<p>So, here, you’ll be a lot safer if you specify the include/library
+directories manually (via <tt class="docutils literal"><span class="pre">-I</span></tt> and <tt class="docutils literal"><span class="pre">-L</span></tt>).</p>
+</li>
+</ol>
+</div>
+</div>
+<div class="section" id="target-specific-libraries">
+<h2>Target-Specific Libraries<a class="headerlink" href="#target-specific-libraries" title="Permalink to this headline">¶</a></h2>
+<p>All libraries that you compile as part of your build will be
+cross-compiled to your target, and your build system will probably
+find them in the right place. But all dependencies that are
+normally checked against (like <tt class="docutils literal"><span class="pre">libxml</span></tt> or <tt class="docutils literal"><span class="pre">libz</span></tt> etc) will match
+against the host platform, not the target.</p>
+<p>So, if the build system is not aware that you want to cross-compile
+your code, it will get every dependency wrong, and your compilation
+will fail during build time, not configure time.</p>
+<p>Also, finding the libraries for your target are not as easy
+as for your host machine. There aren’t many cross-libraries available
+as packages to most OS’s, so you’ll have to either cross-compile them
+from source, or download the package for your target platform,
+extract the libraries and headers, put them in specific directories
+and add <tt class="docutils literal"><span class="pre">-I</span></tt> and <tt class="docutils literal"><span class="pre">-L</span></tt> pointing to them.</p>
+<p>Also, some libraries have different dependencies on different targets,
+so configuration tools to find dependencies in the host can get the
+list wrong for the target platform. This means that the configuration
+of your build can get things wrong when setting their own library
+paths, and you’ll have to augment it via additional flags (configure,
+Make, CMake, etc).</p>
+<div class="section" id="multilibs">
+<h3>Multilibs<a class="headerlink" href="#multilibs" title="Permalink to this headline">¶</a></h3>
+<p>When you want to cross-compile to more than one configuration, for
+example hard-float-ARM and soft-float-ARM, you’ll have to have multiple
+copies of your libraries and (possibly) headers.</p>
+<p>Some Linux distributions have support for Multilib, which handle that
+for you in an easier way, but if you’re not careful and, for instance,
+forget to specify <tt class="docutils literal"><span class="pre">-ccc-gcc-name</span> <span class="pre">armv7l-linux-gnueabihf-gcc</span></tt> (which
+uses hard-float), Clang will pick the <tt class="docutils literal"><span class="pre">armv7l-linux-gnueabi-ld</span></tt>
+(which uses soft-float) and linker errors will happen.</p>
+<p>The same is true if you’re compiling for different ABIs, like <tt class="docutils literal"><span class="pre">gnueabi</span></tt>
+and <tt class="docutils literal"><span class="pre">androideabi</span></tt>, and might even link and run, but produce run-time
+errors, which are much harder to track down and fix.</p>
+</div>
+</div>
+</div>
+
+
+ </div>
+ <div class="bottomnav">
+
+ <p>
+ « <a href="DiagnosticsReference.html">Diagnostic flags in Clang</a>
+ ::
+ <a class="uplink" href="index.html">Contents</a>
+ ::
+ <a href="ThreadSafetyAnalysis.html">Thread Safety Analysis</a> »
+ </p>
+
+ </div>
+
+ <div class="footer">
+ © Copyright 2007-2018, The Clang Team.
+ Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
+ </div>
+ </body>
+</html>
\ No newline at end of file
More information about the llvm-commits
mailing list