[www-releases] r342530 - 7.0.0 files
Hans Wennborg via llvm-commits
llvm-commits at lists.llvm.org
Wed Sep 19 02:40:15 PDT 2018
Added: www-releases/trunk/7.0.0/tools/clang/docs/AutomaticReferenceCounting.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/7.0.0/tools/clang/docs/AutomaticReferenceCounting.html?rev=342530&view=auto
==============================================================================
--- www-releases/trunk/7.0.0/tools/clang/docs/AutomaticReferenceCounting.html (added)
+++ www-releases/trunk/7.0.0/tools/clang/docs/AutomaticReferenceCounting.html Wed Sep 19 02:40:08 2018
@@ -0,0 +1,2119 @@
+
+<!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 7 documentation</title>
+ <link rel="stylesheet" href="_static/haiku.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: './',
+ VERSION: '7',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true,
+ SOURCELINK_SUFFIX: '.txt'
+ };
+ </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="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+ <link rel="index" title="Index" href="genindex.html" />
+ <link rel="search" title="Search" href="search.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" role="banner"><h1 class="heading"><a href="index.html">
+ <span>Clang 7 documentation</span></a></h1>
+ <h2 class="heading"><span>Objective-C Automatic Reference Counting (ARC)</span></h2>
+ </div>
+ <div class="topnav" role="navigation" aria-label="top navigation">
+
+ <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 <code class="docutils literal"><span class="pre">__autoreleasing</span></code> 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 <code class="docutils literal"><span class="pre">init</span></code></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"><code class="docutils literal"><span class="pre">dealloc</span></code></a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#autoreleasepool" id="id47"><code class="docutils literal"><span class="pre">@autoreleasepool</span></code></a></li>
+<li><a class="reference internal" href="#self" id="id48"><code class="docutils literal"><span class="pre">self</span></code></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"><code class="docutils literal"><span class="pre">id</span> <span class="pre">objc_autorelease(id</span> <span class="pre">value);</span></code></a></li>
+<li><a class="reference internal" href="#void-objc-autoreleasepoolpop-void-pool" id="id57"><code class="docutils literal"><span class="pre">void</span> <span class="pre">objc_autoreleasePoolPop(void</span> <span class="pre">*pool);</span></code></a></li>
+<li><a class="reference internal" href="#void-objc-autoreleasepoolpush-void" id="id58"><code class="docutils literal"><span class="pre">void</span> <span class="pre">*objc_autoreleasePoolPush(void);</span></code></a></li>
+<li><a class="reference internal" href="#arc-runtime-objc-autoreleasereturnvalue" id="id59"><code class="docutils literal"><span class="pre">id</span> <span class="pre">objc_autoreleaseReturnValue(id</span> <span class="pre">value);</span></code></a></li>
+<li><a class="reference internal" href="#void-objc-copyweak-id-dest-id-src" id="id60"><code 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></code></a></li>
+<li><a class="reference internal" href="#void-objc-destroyweak-id-object" id="id61"><code class="docutils literal"><span class="pre">void</span> <span class="pre">objc_destroyWeak(id</span> <span class="pre">*object);</span></code></a></li>
+<li><a class="reference internal" href="#arc-runtime-objc-initweak" id="id62"><code 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></code></a></li>
+<li><a class="reference internal" href="#arc-runtime-objc-loadweak" id="id63"><code class="docutils literal"><span class="pre">id</span> <span class="pre">objc_loadWeak(id</span> <span class="pre">*object);</span></code></a></li>
+<li><a class="reference internal" href="#arc-runtime-objc-loadweakretained" id="id64"><code class="docutils literal"><span class="pre">id</span> <span class="pre">objc_loadWeakRetained(id</span> <span class="pre">*object);</span></code></a></li>
+<li><a class="reference internal" href="#void-objc-moveweak-id-dest-id-src" id="id65"><code 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></code></a></li>
+<li><a class="reference internal" href="#void-objc-release-id-value" id="id66"><code class="docutils literal"><span class="pre">void</span> <span class="pre">objc_release(id</span> <span class="pre">value);</span></code></a></li>
+<li><a class="reference internal" href="#arc-runtime-objc-retain" id="id67"><code class="docutils literal"><span class="pre">id</span> <span class="pre">objc_retain(id</span> <span class="pre">value);</span></code></a></li>
+<li><a class="reference internal" href="#arc-runtime-objc-retainautorelease" id="id68"><code class="docutils literal"><span class="pre">id</span> <span class="pre">objc_retainAutorelease(id</span> <span class="pre">value);</span></code></a></li>
+<li><a class="reference internal" href="#arc-runtime-objc-retainautoreleasereturnvalue" id="id69"><code class="docutils literal"><span class="pre">id</span> <span class="pre">objc_retainAutoreleaseReturnValue(id</span> <span class="pre">value);</span></code></a></li>
+<li><a class="reference internal" href="#arc-runtime-objc-retainautoreleasedreturnvalue" id="id70"><code class="docutils literal"><span class="pre">id</span> <span class="pre">objc_retainAutoreleasedReturnValue(id</span> <span class="pre">value);</span></code></a></li>
+<li><a class="reference internal" href="#arc-runtime-objc-retainblock" id="id71"><code class="docutils literal"><span class="pre">id</span> <span class="pre">objc_retainBlock(id</span> <span class="pre">value);</span></code></a></li>
+<li><a class="reference internal" href="#arc-runtime-objc-storestrong" id="id72"><code 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></code></a></li>
+<li><a class="reference internal" href="#arc-runtime-objc-storeweak" id="id73"><code 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></code></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 <code class="docutils literal"><span class="pre">Block_copy</span></code> 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
+<code class="docutils literal"><span class="pre">Block_release</span></code>, 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, <code class="docutils literal"><span class="pre">id</span></code> and
+<code class="docutils literal"><span class="pre">Class</span></code>; <code class="docutils literal"><span class="pre">id</span></code> 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
+<code class="docutils literal"><span class="pre">Class</span></code>.</p>
+<p>A class declaration (<code class="docutils literal"><span class="pre">@interface</span></code>) 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 <code class="docutils literal"><span class="pre">foo:bar:baz:</span></code>, 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></span><span class="p">[</span><span class="n">receiver</span> <span class="nl">foo</span><span class="p">:</span> <span class="n">fooArg</span> <span class="nl">bar</span><span class="p">:</span> <span class="n">barArg</span> <span class="nl">baz</span><span class="p">:</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 <code class="docutils literal"><span class="pre">super</span></code>, 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 <code class="docutils literal"><span class="pre">@interface</span></code>, but
+those defined in a separate <code class="docutils literal"><span class="pre">@implementation</span></code> declaration; however, when
+compiling a call, typechecking is done based on the methods declared in the
+<code class="docutils literal"><span class="pre">@interface</span></code>.</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 <code class="docutils literal"><span class="pre">@interface</span></code> to be split across multiple files; however,
+there is still a primary implementation file which must see the
+<code class="docutils literal"><span class="pre">@interface</span></code>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 <code class="docutils literal"><span class="pre">@implementation</span></code> 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: <code class="docutils literal"><span class="pre">retain</span></code>
+increases the objectâs reference count by 1, whereas <code class="docutils literal"><span class="pre">release</span></code> decreases it
+by 1 and calls the instance method <code class="docutils literal"><span class="pre">dealloc</span></code> 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 <code class="docutils literal"><span class="pre">release</span></code> on later; an object can be
+added to this pool by calling <code class="docutils literal"><span class="pre">autorelease</span></code> on it.</p>
+<p>Block pointers may be converted to type <code class="docutils literal"><span class="pre">id</span></code>; 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 <code class="docutils literal"><span class="pre">retain</span></code> by adjusting the reference count, not by calling
+<code class="docutils literal"><span class="pre">Block_copy</span></code>.</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> <code class="docutils literal"><span class="pre">extern</span> <span class="pre">"BCPL"</span></code> 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 <code class="docutils literal"><span class="pre">-fobjc-arc</span></code>. It may
+also be explicitly disabled with the compiler flag <code class="docutils literal"><span class="pre">-fno-objc-arc</span></code>. The last
+of these two flags appearing on the compile line âwinsâ.</p>
+<p>If ARC is enabled, <code class="docutils literal"><span class="pre">__has_feature(objc_arc)</span></code> will expand to 1 in the
+preprocessor. For more information about <code class="docutils literal"><span class="pre">__has_feature</span></code>, see the
+<a class="reference internal" href="LanguageExtensions.html#langext-has-feature-has-extension"><span class="std std-ref">language extensions</span></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 (<code class="docutils literal"><span class="pre">^</span></code>) declarator sigil to a
+function type)</li>
+<li>Objective-C object pointers (<code class="docutils literal"><span class="pre">id</span></code>, <code class="docutils literal"><span class="pre">Class</span></code>, <code class="docutils literal"><span class="pre">NSFoo*</span></code>, etc.)</li>
+<li>typedefs marked with <code class="docutils literal"><span class="pre">__attribute__((NSObject))</span></code></li>
+</ul>
+<p>Other pointer types, such as <code class="docutils literal"><span class="pre">int*</span></code> and <code class="docutils literal"><span class="pre">CFStringRef</span></code>, 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
+<code class="docutils literal"><span class="pre">int*</span></code> might be a pointer to a <code class="docutils literal"><span class="pre">malloc</span></code>â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 <code class="docutils literal"><span class="pre">__attribute__((NSObject))</span></code> 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
+<code class="docutils literal"><span class="pre">__typeof</span></code> 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
+<code class="docutils literal"><span class="pre">null</span></code> then it must actually be a pointer to a block object, and if it has
+<code class="docutils literal"><span class="pre">Class</span></code> 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><code class="docutils literal"><span class="pre">retain</span></code>, taking no arguments and returning a pointer to the object.</li>
+<li><code class="docutils literal"><span class="pre">release</span></code>, taking no arguments and returning <code class="docutils literal"><span class="pre">void</span></code>.</li>
+<li><code class="docutils literal"><span class="pre">autorelease</span></code>, 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 <code class="docutils literal"><span class="pre">retain</span></code>, 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
+<code class="docutils literal"><span class="pre">retain</span></code> followed by a send of <code class="docutils literal"><span class="pre">release</span></code> to the same object, with no
+intervening <code class="docutils literal"><span class="pre">release</span></code> 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 <code class="docutils literal"><span class="pre">release</span></code> that is not
+preceded by a send of <code class="docutils literal"><span class="pre">retain</span></code> to the same object.</p>
+<p>The behavior of <code class="docutils literal"><span class="pre">autorelease</span></code> must be equivalent to sending <code class="docutils literal"><span class="pre">release</span></code> 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 <code class="docutils literal"><span class="pre">null</span></code> 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"><span class="std std-ref">optimization rules</span></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"><span class="std std-ref">ownership</span></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 <code class="docutils literal"><span class="pre">ns_consumed</span></code> attribute to
+the parameter declaration, like so:</p>
+<div class="highlight-objc"><div class="highlight"><pre><span></span><span class="kt">void</span> <span class="nf">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="p">-</span> <span class="p">(</span><span class="kt">void</span><span class="p">)</span> <span class="nf">foo:</span> <span class="p">(</span><span class="kt">id</span><span class="p">)</span> <span class="nv">__attribute</span><span class="p">((</span><span class="n">ns_consumed</span><span class="p">))</span> <span class="nv">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 <code class="docutils literal"><span class="pre">self</span></code> parameter to <code class="docutils literal"><span class="pre">init</span></code>, 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 <code class="docutils literal"><span class="pre">self</span></code> parameter of a method may be marked as consumed by adding
+<code class="docutils literal"><span class="pre">__attribute__((ns_consumes_self))</span></code> to the method declaration. Methods in
+the <code class="docutils literal"><span class="pre">init</span></code> <a class="reference internal" href="#arc-method-families"><span class="std std-ref">family</span></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
+<code class="docutils literal"><span class="pre">ns_consumed</span></code> 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 <code class="docutils literal"><span class="pre">ns_consumed</span></code> 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
+<code class="docutils literal"><span class="pre">ns_consumed</span></code> 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
+<code class="docutils literal"><span class="pre">ns_returns_retained</span></code> attribute to the function or method declaration, like
+so:</p>
+<div class="highlight-objc"><div class="highlight"><pre><span></span><span class="kt">id</span> <span class="nf">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="p">-</span> <span class="p">(</span><span class="kt">id</span><span class="p">)</span> <span class="nf">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 <code class="docutils literal"><span class="pre">init</span></code>,
+<code class="docutils literal"><span class="pre">alloc</span></code>, <code class="docutils literal"><span class="pre">new</span></code>, and <code class="docutils literal"><span class="pre">copy</span></code> 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 <code class="docutils literal"><span class="pre">alloc</span></code>, <code class="docutils literal"><span class="pre">copy</span></code>, <code class="docutils literal"><span class="pre">init</span></code>, <code class="docutils literal"><span class="pre">mutableCopy</span></code>, and <code class="docutils literal"><span class="pre">new</span></code>
+<a class="reference internal" href="#arc-method-families"><span class="std std-ref">families</span></a> are implicitly marked
+<code class="docutils literal"><span class="pre">__attribute__((ns_returns_retained))</span></code>. This may be suppressed by explicitly
+marking the method <code class="docutils literal"><span class="pre">__attribute__((ns_returns_not_retained))</span></code>.</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 <code class="docutils literal"><span class="pre">autorelease</span></code>, 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
+<code class="docutils literal"><span class="pre">__attribute__((ns_returns_autoreleased))</span></code> 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><code class="docutils literal"><span class="pre">(__bridge</span> <span class="pre">T)</span> <span class="pre">op</span></code> casts the operand to the destination type <code class="docutils literal"><span class="pre">T</span></code>. If
+<code class="docutils literal"><span class="pre">T</span></code> is a retainable object pointer type, then <code class="docutils literal"><span class="pre">op</span></code> must have a
+non-retainable pointer type. If <code class="docutils literal"><span class="pre">T</span></code> is a non-retainable pointer type,
+then <code class="docutils literal"><span class="pre">op</span></code> 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><code class="docutils literal"><span class="pre">(__bridge_retained</span> <span class="pre">T)</span> <span class="pre">op</span></code> 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><code class="docutils literal"><span class="pre">(__bridge_transfer</span> <span class="pre">T)</span> <span class="pre">op</span></code> 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"><span class="std std-ref">conversion of retainable
+object pointers</span></a>.</p>
+<p>Using a <code class="docutils literal"><span class="pre">__bridge_retained</span></code> or <code class="docutils literal"><span class="pre">__bridge_transfer</span></code> 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 <code class="docutils literal"><span class="pre">void*</span></code>. As an exception, cast to <code class="docutils literal"><span class="pre">intptr_t</span></code> is
+allowed because such casts are not transferring ownership. The <a class="reference internal" href="#arc-objects-operands-casts"><span class="std std-ref">bridged
+casts</span></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 <code class="docutils literal"><span class="pre">const</span></code> system global variable of <a class="reference internal" href="#arc-misc-c-retainable"><span class="std std-ref">C retainable pointer
+type</span></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"><span class="std std-ref">C
+retainable pointer type</span></a> and it is:</p>
+<ul class="simple">
+<li>a direct call to a function, and either that function has the
+<code class="docutils literal"><span class="pre">cf_returns_not_retained</span></code> attribute or it is an <a class="reference internal" href="#arc-misc-c-retainable-audit"><span class="std std-ref">audited</span></a> function that does not have the
+<code class="docutils literal"><span class="pre">cf_returns_retained</span></code> attribute and does not follow the create/copy naming
+convention,</li>
+<li>a message send, and the declared method either has the
+<code class="docutils literal"><span class="pre">cf_returns_not_retained</span></code> attribute or it has neither the
+<code class="docutils literal"><span class="pre">cf_returns_retained</span></code> attribute nor a <a class="reference internal" href="#arc-method-families"><span class="std std-ref">selector family</span></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> <code class="docutils literal"><span class="pre">const</span></code>
+<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"><span class="std std-ref">C
+retainable pointer type</span></a> and it is:</p>
+<ul class="simple">
+<li>a message send, and the declared method either has the
+<code class="docutils literal"><span class="pre">cf_returns_retained</span></code> attribute, or it does not have the
+<code class="docutils literal"><span class="pre">cf_returns_not_retained</span></code> attribute but it does have a <a class="reference internal" href="#arc-method-families"><span class="std std-ref">selector
+family</span></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
+<code class="docutils literal"><span class="pre">__bridge_transfer</span></code> cast. If the cast operand is known unretained or known
+retain-agnostic, the conversion is treated as a <code class="docutils literal"><span class="pre">__bridge</span></code> 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 <code class="docutils literal"><span class="pre">__bridge_transfer</span></code> casts. The worry is
+that some code patterns â for example, creating a CF value, assigning it
+to an ObjC-typed local, and then calling <code class="docutils literal"><span class="pre">CFRelease</span></code> when done â are a
+bit too likely to be accidentally accepted, leading to mysterious behavior.</p>
+<p class="last">For loads from <code class="docutils literal"><span class="pre">const</span></code> global variables of <a class="reference internal" href="#arc-misc-c-retainable"><span class="std std-ref">C retainable pointer type</span></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"><span class="std std-ref">C retainable pointer type</span></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 <code class="docutils literal"><span class="pre">cf_consumed</span></code> attribute, or</li>
+<li>to initialize a parameter in a direct call to an
+<a class="reference internal" href="#arc-misc-c-retainable-audit"><span class="std std-ref">audited</span></a> function where the parameter is
+not marked with the <code class="docutils literal"><span class="pre">cf_consumed</span></code> 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 <code class="docutils literal"><span class="pre">Release</span></code> 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"><span class="std std-ref">inference rules</span></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"><span class="std std-ref">inference of __strong for template type
+arguments</span></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><code class="docutils literal"><span class="pre">__autoreleasing</span></code></li>
+<li><code class="docutils literal"><span class="pre">__strong</span></code></li>
+<li><code class="docutils literal"><span class="pre">__unsafe_unretained</span></code></li>
+<li><code class="docutils literal"><span class="pre">__weak</span></code></li>
+</ul>
+<p>A type is <span class="arc-term">nontrivially ownership-qualified</span> if it is qualified with
+<code class="docutils literal"><span class="pre">__autoreleasing</span></code>, <code class="docutils literal"><span class="pre">__strong</span></code>, or <code class="docutils literal"><span class="pre">__weak</span></code>.</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 <code class="docutils literal"><span class="pre">const</span></code> and <code class="docutils literal"><span class="pre">volatile</span></code> 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, <code class="docutils literal"><span class="pre">__strong</span></code>
+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
+<code class="docutils literal"><span class="pre">__autoreleasing</span></code> ownership.</p>
+<ul class="simple">
+<li><code class="docutils literal"><span class="pre">assign</span></code> implies <code class="docutils literal"><span class="pre">__unsafe_unretained</span></code> ownership.</li>
+<li><code class="docutils literal"><span class="pre">copy</span></code> implies <code class="docutils literal"><span class="pre">__strong</span></code> ownership, as well as the usual behavior of
+copy semantics on the setter.</li>
+<li><code class="docutils literal"><span class="pre">retain</span></code> implies <code class="docutils literal"><span class="pre">__strong</span></code> ownership.</li>
+<li><code class="docutils literal"><span class="pre">strong</span></code> implies <code class="docutils literal"><span class="pre">__strong</span></code> ownership.</li>
+<li><code class="docutils literal"><span class="pre">unsafe_unretained</span></code> implies <code class="docutils literal"><span class="pre">__unsafe_unretained</span></code> ownership.</li>
+<li><code class="docutils literal"><span class="pre">weak</span></code> implies <code class="docutils literal"><span class="pre">__weak</span></code> ownership.</li>
+</ul>
+<p>With the exception of <code class="docutils literal"><span class="pre">weak</span></code>, 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
+<code class="docutils literal"><span class="pre">@synthesize</span></code> 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> <code class="docutils literal"><span class="pre">strong</span></code>. 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 <code class="docutils literal"><span class="pre">strong</span></code> by default is safe and consistent with the generic ARC rule
+about <a class="reference internal" href="#arc-ownership-inference-variables"><span class="std std-ref">inferring ownership</span></a>. It is,
+unfortunately, inconsistent with the non-ARC rule which states that such
+properties are implicitly <code class="docutils literal"><span class="pre">assign</span></code>. 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 <code class="docutils literal"><span class="pre">__attribute__((NSObject))</span></code> 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 <code class="docutils literal"><span class="pre">assign</span></code>. 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 <code class="docutils literal"><span class="pre">void*</span></code> 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 <code class="docutils literal"><span class="pre">__weak</span></code> 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 <code class="docutils literal"><span class="pre">__strong</span></code> 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 <code class="docutils literal"><span class="pre">__weak</span></code> 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 <code class="docutils literal"><span class="pre">__unsafe_unretained</span></code> objects, the new pointee is stored into the
+lvalue using primitive semantics.</li>
+<li>For <code class="docutils literal"><span class="pre">__autoreleasing</span></code> 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 <code class="docutils literal"><span class="pre">__unsafe_unretained</span></code>.</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 <code class="docutils literal"><span class="pre">__block</span></code> variables
+and rvalue references in C++. For <code class="docutils literal"><span class="pre">__strong</span></code> 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 <code class="docutils literal"><span class="pre">__weak</span></code>
+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 <code class="docutils literal"><span class="pre">__weak</span></code> 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 <code class="docutils literal"><span class="pre">retain</span></code>, <code class="docutils literal"><span class="pre">release</span></code>, 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
+<code class="docutils literal"><span class="pre">objc_arc_weak_reference_unavailable</span></code> 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 <code class="docutils literal"><span class="pre">T</span></code> where
+<code class="docutils literal"><span class="pre">T</span></code> or one of its superclasses has the <code class="docutils literal"><span class="pre">objc_arc_weak_reference_unavailable</span></code>
+attribute. A program is ill-formed if it applies the <code class="docutils literal"><span class="pre">__weak</span></code> 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 <code class="docutils literal"><span class="pre">__autoreleasing</span></code> 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 <code class="docutils literal"><span class="pre">__autoreleasing</span></code> object of
+non-automatic storage duration. A program is ill-formed if it captures an
+<code class="docutils literal"><span class="pre">__autoreleasing</span></code> 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
+<code class="docutils literal"><span class="pre">__autoreleasing</span></code> 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 <code class="docutils literal"><span class="pre">T*</span></code> is converted,
+explicitly or implicitly, to the type <code class="docutils literal"><span class="pre">U*</span></code>, where <code class="docutils literal"><span class="pre">T</span></code> and <code class="docutils literal"><span class="pre">U</span></code> have
+different ownership qualification, unless:</p>
+<ul class="simple">
+<li><code class="docutils literal"><span class="pre">T</span></code> is qualified with <code class="docutils literal"><span class="pre">__strong</span></code>, <code class="docutils literal"><span class="pre">__autoreleasing</span></code>, or
+<code class="docutils literal"><span class="pre">__unsafe_unretained</span></code>, and <code class="docutils literal"><span class="pre">U</span></code> is qualified with both <code class="docutils literal"><span class="pre">const</span></code> and
+<code class="docutils literal"><span class="pre">__unsafe_unretained</span></code>; or</li>
+<li>either <code class="docutils literal"><span class="pre">T</span></code> or <code class="docutils literal"><span class="pre">U</span></code> is <code class="docutils literal"><span class="pre">cv</span> <span class="pre">void</span></code>, where <code class="docutils literal"><span class="pre">cv</span></code> is an optional sequence
+of non-ownership qualifiers; or</li>
+<li>the conversion is requested with a <code class="docutils literal"><span class="pre">reinterpret_cast</span></code> in Objective-C++; or</li>
+<li>the conversion is a well-formed <a class="reference internal" href="#arc-ownership-restrictions-pass-by-writeback"><span class="std std-ref">pass-by-writeback</span></a>.</li>
+</ul>
+<p>The analogous rule applies to <code class="docutils literal"><span class="pre">T&</span></code> and <code class="docutils literal"><span class="pre">U&</span></code> 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
+<code class="docutils literal"><span class="pre">const</span> <span class="pre">__unsafe_unretained</span></code> 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 <code class="docutils literal"><span class="pre">void*</span></code> is useful for allocating
+memory or otherwise escaping the type system, but use it carefully.
+<code class="docutils literal"><span class="pre">reinterpret_cast</span></code> 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-<code class="docutils literal"><span class="pre">__weak</span></code> object
+may be read through an <code class="docutils literal"><span class="pre">__unsafe_unretained</span></code> lvalue.</p>
+<p>It is undefined behavior if the storage of a <code class="docutils literal"><span class="pre">__strong</span></code> or <code class="docutils literal"><span class="pre">__weak</span></code>
+object is not properly initialized before the first managed operation
+is performed on the object, or if the storage of such an object is freed
+or reused before the object has been properly deinitialized. Storage for
+a <code class="docutils literal"><span class="pre">__strong</span></code> or <code class="docutils literal"><span class="pre">__weak</span></code> object may be properly initialized by filling
+it with the representation of a null pointer, e.g. by acquiring the memory
+with <code class="docutils literal"><span class="pre">calloc</span></code> or using <code class="docutils literal"><span class="pre">bzero</span></code> to zero it out. A <code class="docutils literal"><span class="pre">__strong</span></code> or
+<code class="docutils literal"><span class="pre">__weak</span></code> object may be properly deinitialized by assigning a null pointer
+into it. A <code class="docutils literal"><span class="pre">__strong</span></code> object may also be properly initialized
+by copying into it (e.g. with <code class="docutils literal"><span class="pre">memcpy</span></code>) the representation of a
+different <code class="docutils literal"><span class="pre">__strong</span></code> object whose storage has been properly initialized;
+doing this properly deinitializes the source object and causes its storage
+to no longer be properly initialized. A <code class="docutils literal"><span class="pre">__weak</span></code> object may not be
+representation-copied in this way.</p>
+<p>These requirements are followed automatically for objects whose
+initialization and deinitialization are under the control of ARC:</p>
+<ul class="simple">
+<li>objects of static, automatic, and temporary storage duration</li>
+<li>instance variables of Objective-C objects</li>
+<li>elements of arrays where the array objectâs initialization and
+deinitialization are under the control of ARC</li>
+<li>fields of Objective-C struct types where the struct objectâs
+initialization and deinitialization are under the control of ARC</li>
+<li>non-static data members of Objective-C++ non-union class types</li>
+<li>Objective-C++ objects and arrays of dynamic storage duration created
+with the <code class="docutils literal"><span class="pre">new</span></code> or <code class="docutils literal"><span class="pre">new[]</span></code> operators and destroyed with the
+corresponding <code class="docutils literal"><span class="pre">delete</span></code> or <code class="docutils literal"><span class="pre">delete[]</span></code> operator</li>
+</ul>
+<p>They are not followed automatically for these objects:</p>
+<ul class="simple">
+<li>objects of dynamic storage duration created in other memory, such as
+that returned by <code class="docutils literal"><span class="pre">malloc</span></code></li>
+<li>union members</li>
+</ul>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">ARC must perform special operations when initializing an object and
+when destroying it. In many common situations, ARC knows when an
+object is created and when it is destroyed and can ensure that these
+operations are performed correctly. Otherwise, however, ARC requires
+programmer cooperation to establish its initialization invariants
+because it is infeasible for ARC to dynamically infer whether they
+are intact. For example, there is no syntactic difference in C between
+an assignment that is intended by the programmer to initialize a variable
+and one that is intended to replace the existing value stored there,
+but ARC must perform one operation or the other. ARC chooses to always
+assume that objects are initialized (except when it is in charge of
+initializing them) because the only workable alternative would be to
+ban all code patterns that could potentially be used to access
+uninitialized memory, and that would be too limiting. In practice,
+this is rarely a problem because programmers do not generally need to
+work with objects for which the requirements are not handled
+automatically.</p>
+</div>
+<p>Note that dynamically-allocated Objective-C++ arrays of
+nontrivially-ownership-qualified type are not ABI-compatible with non-ARC
+code because the non-ARC code will consider the element type to be POD.
+Such arrays that are <code class="docutils literal"><span class="pre">new[]</span></code>âd in ARC translation units cannot be
+<code class="docutils literal"><span class="pre">delete[]</span></code>â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 <code class="docutils literal"><span class="pre">T</span> <span class="pre">__autoreleasing</span> <span class="pre">*</span></code> has type
+<code class="docutils literal"><span class="pre">U</span> <span class="pre">oq</span> <span class="pre">*</span></code>, where <code class="docutils literal"><span class="pre">oq</span></code> 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><code class="docutils literal"><span class="pre">oq</span></code> is <code class="docutils literal"><span class="pre">__strong</span></code> or <code class="docutils literal"><span class="pre">__weak</span></code>, and</li>
+<li>it would be legal to initialize a <code class="docutils literal"><span class="pre">T</span> <span class="pre">__strong</span> <span class="pre">*</span></code> with a <code class="docutils literal"><span class="pre">U</span> <span class="pre">__strong</span> <span class="pre">*</span></code>.</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><code class="docutils literal"><span class="pre">&var</span></code>, where <code class="docutils literal"><span class="pre">var</span></code> 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 <code class="docutils literal"><span class="pre">p</span></code> of type <code class="docutils literal"><span class="pre">U</span> <span class="pre">oq</span> <span class="pre">*</span></code>.</li>
+<li>If <code class="docutils literal"><span class="pre">p</span></code> 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 <code class="docutils literal"><span class="pre">T</span> <span class="pre">__autoreleasing</span></code> is created and
+initialized to a null pointer.</li>
+<li>If the parameter is not an Objective-C method parameter marked <code class="docutils literal"><span class="pre">out</span></code>,
+then <code class="docutils literal"><span class="pre">*p</span></code> 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 <code class="docutils literal"><span class="pre">*p</span></code>.</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 <code class="docutils literal"><span class="pre">__autoreleasing</span></code> rather than <code class="docutils literal"><span class="pre">__strong</span></code>. 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
+<code class="docutils literal"><span class="pre">__autoreleasing</span></code> 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 <code class="docutils literal"><span class="pre">void*</span></code> or an <code class="docutils literal"><span class="pre">__unsafe_unretained</span></code> 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
+<code class="docutils literal"><span class="pre">__strong</span></code> qualification.</p>
+<p>As a special case, if the objectâs base type is <code class="docutils literal"><span class="pre">Class</span></code> (possibly
+protocol-qualified), the type is adjusted to have <code class="docutils literal"><span class="pre">__unsafe_unretained</span></code>
+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 <code class="docutils literal"><span class="pre">T*</span></code>, where <code class="docutils literal"><span class="pre">T</span></code> is an
+ownership-unqualified retainable object pointer type, then:</p>
+<ul class="simple">
+<li>if <code class="docutils literal"><span class="pre">T</span></code> is <code class="docutils literal"><span class="pre">const</span></code>-qualified or <code class="docutils literal"><span class="pre">Class</span></code>, then it is implicitly
+qualified with <code class="docutils literal"><span class="pre">__unsafe_unretained</span></code>;</li>
+<li>otherwise, it is implicitly qualified with <code class="docutils literal"><span class="pre">__autoreleasing</span></code>.</li>
+</ul>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last"><code class="docutils literal"><span class="pre">__autoreleasing</span></code> exists mostly for this case, the Cocoa convention for
+out-parameters. Since a pointer to <code class="docutils literal"><span class="pre">const</span></code> 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
+<code class="docutils literal"><span class="pre">__autoreleasing</span></code> 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 <code class="docutils literal"><span class="pre">__strong</span></code> 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"><code class="docutils literal"><span class="pre">__strong</span></code> is a useful default for containers (e.g., <code class="docutils literal"><span class="pre">std::vector<id></span></code>),
+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 <code class="docutils literal"><span class="pre">objc_method_family</span></code> attribute placing it in that family; or if
+not that,</li>
+<li>it does not have an <code class="docutils literal"><span class="pre">objc_method_family</span></code> 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, <code class="docutils literal"><span class="pre">_perform:with:</span></code> and
+<code class="docutils literal"><span class="pre">performWith:</span></code> would fall into the <code class="docutils literal"><span class="pre">perform</span></code> family (if we recognized one),
+but <code class="docutils literal"><span class="pre">performing:with</span></code> would not.</p>
+<p>The families and their added restrictions are:</p>
+<ul>
+<li><p class="first"><code class="docutils literal"><span class="pre">alloc</span></code> methods must return a retainable object pointer type.</p>
+</li>
+<li><p class="first"><code class="docutils literal"><span class="pre">copy</span></code> methods must return a retainable object pointer type.</p>
+</li>
+<li><p class="first"><code class="docutils literal"><span class="pre">mutableCopy</span></code> methods must return a retainable object pointer type.</p>
+</li>
+<li><p class="first"><code class="docutils literal"><span class="pre">new</span></code> methods must return a retainable object pointer type.</p>
+</li>
+<li><p class="first"><code class="docutils literal"><span class="pre">init</span></code> 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 <code class="docutils literal"><span class="pre">init</span></code> method whose return type is neither <code class="docutils literal"><span class="pre">id</span></code> 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 <code class="docutils literal"><span class="pre">init</span></code>-like selectors
+which nonetheless donât follow the <code class="docutils literal"><span class="pre">init</span></code> conventions. Typically these
+are either accidental naming collisions or helper methods called during
+initialization. Because of the peculiar retain/release behavior of
+<code class="docutils literal"><span class="pre">init</span></code> methods, itâs very important not to treat these methods as
+<code class="docutils literal"><span class="pre">init</span></code> 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 <code class="docutils literal"><span class="pre">init</span></code> family.</p>
+<p class="last">Note that a method with an <code class="docutils literal"><span class="pre">init</span></code>-family selector which returns a
+non-Objective-C type (e.g. <code class="docutils literal"><span class="pre">void</span></code>) is perfectly well-formed; it simply
+isnât in the <code class="docutils literal"><span class="pre">init</span></code> 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 <code class="docutils literal"><span class="pre">objc_method_family</span></code> attribute to
+precisely control which method family it belongs to. If a method in an
+<code class="docutils literal"><span class="pre">@implementation</span></code> does not have this attribute, but there is a method
+declared in the corresponding <code class="docutils literal"><span class="pre">@interface</span></code> that does, then the attribute is
+copied to the declaration in the <code class="docutils literal"><span class="pre">@implementation</span></code>. The attribute is
+available outside of ARC, and may be tested for with the preprocessor query
+<code class="docutils literal"><span class="pre">__has_attribute(objc_method_family)</span></code>.</p>
+<p>The attribute is spelled
+<code class="docutils literal"><span class="pre">__attribute__((objc_method_family(</span></code> <em>family</em> <code class="docutils literal"><span class="pre">)))</span></code>. If <em>family</em> is
+<code class="docutils literal"><span class="pre">none</span></code>, 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
+<code class="docutils literal"><span class="pre">alloc</span></code>, <code class="docutils literal"><span class="pre">copy</span></code>, <code class="docutils literal"><span class="pre">init</span></code>, <code class="docutils literal"><span class="pre">mutableCopy</span></code>, or <code class="docutils literal"><span class="pre">new</span></code>, 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
+<code class="docutils literal"><span class="pre">ns_returns_retained</span></code>, this attribute allows the user to communicate
+semantic intent, which is of use both to ARC (which, e.g., treats calls to
+<code class="docutils literal"><span class="pre">init</span></code> 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 <code class="docutils literal"><span class="pre">alloc</span></code>, <code class="docutils literal"><span class="pre">copy</span></code>, <code class="docutils literal"><span class="pre">mutableCopy</span></code>, and <code class="docutils literal"><span class="pre">new</span></code> families â
+that is, methods in all the currently-defined families except <code class="docutils literal"><span class="pre">init</span></code> â
+implicitly <a class="reference internal" href="#arc-object-operands-retained-return-values"><span class="std std-ref">return a retained object</span></a> as if they were annotated with
+the <code class="docutils literal"><span class="pre">ns_returns_retained</span></code> attribute. This can be overridden by annotating
+the method with either of the <code class="docutils literal"><span class="pre">ns_returns_autoreleased</span></code> or
+<code class="docutils literal"><span class="pre">ns_returns_not_retained</span></code> attributes.</p>
+<p>Properties also follow same naming rules as methods. This means that those in
+the <code class="docutils literal"><span class="pre">alloc</span></code>, <code class="docutils literal"><span class="pre">copy</span></code>, <code class="docutils literal"><span class="pre">mutableCopy</span></code>, and <code class="docutils literal"><span class="pre">new</span></code> families provide access
+to <a class="reference internal" href="#arc-object-operands-retained-return-values"><span class="std std-ref">retained objects</span></a>. This
+can be overridden by annotating the property with <code class="docutils literal"><span class="pre">ns_returns_not_retained</span></code>
+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 <code class="docutils literal"><span class="pre">init</span></code></a><a class="headerlink" href="#semantics-of-init" title="Permalink to this headline">¶</a></h4>
+<p>Methods in the <code class="docutils literal"><span class="pre">init</span></code> family implicitly <a class="reference internal" href="#arc-objects-operands-consumed"><span class="std std-ref">consume</span></a> their <code class="docutils literal"><span class="pre">self</span></code> parameter and <a class="reference internal" href="#arc-object-operands-retained-return-values"><span class="std std-ref">return a
+retained object</span></a>. Neither of
+these properties can be altered through attributes.</p>
+<p>A call to an <code class="docutils literal"><span class="pre">init</span></code> method with a receiver that is either <code class="docutils literal"><span class="pre">self</span></code> (possibly
+parenthesized or casted) or <code class="docutils literal"><span class="pre">super</span></code> 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
+<code class="docutils literal"><span class="pre">init</span></code> method, and excluding blocks within such methods.</p>
+<p>As an exception to the <a class="reference internal" href="#arc-misc-self"><span class="std std-ref">usual rule</span></a>, the variable <code class="docutils literal"><span class="pre">self</span></code>
+is mutable in an <code class="docutils literal"><span class="pre">init</span></code> method and has the usual semantics for a <code class="docutils literal"><span class="pre">__strong</span></code>
+variable. However, it is undefined behavior and the program is ill-formed, no
+diagnostic required, if an <code class="docutils literal"><span class="pre">init</span></code> method attempts to use the previous value
+of <code class="docutils literal"><span class="pre">self</span></code> after the completion of a delegate init call. It is conventional,
+but not required, for an <code class="docutils literal"><span class="pre">init</span></code> method to return <code class="docutils literal"><span class="pre">self</span></code>.</p>
+<p>It is undefined behavior for a program to cause two or more calls to <code class="docutils literal"><span class="pre">init</span></code>
+methods on the same object, except that each <code class="docutils literal"><span class="pre">init</span></code> 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 <code class="docutils literal"><span class="pre">alloc</span></code> and <code class="docutils literal"><span class="pre">new</span></code> method families</li>
+<li>instance methods in the <code class="docutils literal"><span class="pre">init</span></code> family</li>
+<li>the instance method <code class="docutils literal"><span class="pre">self</span></code></li>
+<li>outside of ARC, the instance methods <code class="docutils literal"><span class="pre">retain</span></code> and <code class="docutils literal"><span class="pre">autorelease</span></code></li>
+</ul>
+<p>If the formal result type of such a method is <code class="docutils literal"><span class="pre">id</span></code> or protocol-qualified
+<code class="docutils literal"><span class="pre">id</span></code>, 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 <code class="docutils literal"><span class="pre">T</span></code>, the message
+send expression has type <code class="docutils literal"><span class="pre">T*</span></code>; otherwise</li>
+<li>if it is an instance method, and the receiver has type <code class="docutils literal"><span class="pre">T</span></code>, the message
+send expression has type <code class="docutils literal"><span class="pre">T</span></code>; 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 <code class="docutils literal"><span class="pre">retain</span></code> and
+<code class="docutils literal"><span class="pre">release</span></code> 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"><span class="std std-ref">restrictions</span></a> on
+the implementation of <code class="docutils literal"><span class="pre">retain</span></code> and <code class="docutils literal"><span class="pre">release</span></code>.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p>Specifically, ARC is sometimes permitted to optimize <code class="docutils literal"><span class="pre">release</span></code>
+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 <code class="docutils literal"><span class="pre">retain</span></code>/<code class="docutils literal"><span class="pre">release</span></code> pairs. For
+example, consider the following code:</p>
+<div class="highlight-objc"><div class="highlight"><pre><span></span><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 <code class="docutils literal"><span class="pre">x</span></code>, then we would not be able to eliminate this retain
+and release unless we could prove that the message send could not
+modify <code class="docutils literal"><span class="pre">_ivar</span></code> (or deallocate <code class="docutils literal"><span class="pre">self</span></code>). 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 <code class="docutils literal"><span class="pre">__strong</span></code> 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 <code class="docutils literal"><span class="pre">X</span></code> to be deallocated at a
+time <code class="docutils literal"><span class="pre">T</span></code> in a computation history if:</p>
+<ul class="simple">
+<li><code class="docutils literal"><span class="pre">X</span></code> is the value stored in a <code class="docutils literal"><span class="pre">__strong</span></code> object <code class="docutils literal"><span class="pre">S</span></code> with
+<a class="reference internal" href="#arc-optimization-precise"><span class="std std-ref">precise lifetime semantics</span></a>, or</li>
+<li><code class="docutils literal"><span class="pre">X</span></code> is the value stored in a <code class="docutils literal"><span class="pre">__strong</span></code> object <code class="docutils literal"><span class="pre">S</span></code> with
+imprecise lifetime semantics and, at some point after <code class="docutils literal"><span class="pre">T</span></code> but
+before the next store to <code class="docutils literal"><span class="pre">S</span></code>, the computation history features a
+load from <code class="docutils literal"><span class="pre">S</span></code> and in some way depends on the value loaded, or</li>
+<li><code class="docutils literal"><span class="pre">X</span></code> is a value described as being released at the end of the
+current full-expression and, at some point after <code class="docutils literal"><span class="pre">T</span></code> 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
+<code class="docutils literal"><span class="pre">__strong</span></code> 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 <code class="docutils literal"><span class="pre">P</span></code> if it:</p>
+<ul class="simple">
+<li>performs a pointer comparison with <code class="docutils literal"><span class="pre">P</span></code>,</li>
+<li>loads from <code class="docutils literal"><span class="pre">P</span></code>,</li>
+<li>stores to <code class="docutils literal"><span class="pre">P</span></code>,</li>
+<li>depends on a pointer value <code class="docutils literal"><span class="pre">Q</span></code> derived via pointer arithmetic
+from <code class="docutils literal"><span class="pre">P</span></code> (including an instance-variable or field access), or</li>
+<li>depends on a pointer value <code class="docutils literal"><span class="pre">Q</span></code> loaded from <code class="docutils literal"><span class="pre">P</span></code>.</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 <code class="docutils literal"><span class="pre">P</span></code>. 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 <code 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></code>, ARC must not
+move the release of <code class="docutils literal"><span class="pre">p</span></code> to between the load of <code class="docutils literal"><span class="pre">p->ivar</span></code> and the
+retain of that value for storing into <code class="docutils literal"><span class="pre">x</span></code>.</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 <code class="docutils literal"><span class="pre">X</span></code>
+has been deallocated by the time of an observable side-effect, then
+ARC must cause <code class="docutils literal"><span class="pre">X</span></code> 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 <code class="docutils literal"><span class="pre">__strong</span></code> 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 <code class="docutils literal"><span class="pre">objc_precise_lifetime</span></code> 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
+<code class="docutils literal"><span class="pre">@selector</span></code> expression for any of the following selectors:</p>
+<ul class="simple">
+<li><code class="docutils literal"><span class="pre">autorelease</span></code></li>
+<li><code class="docutils literal"><span class="pre">release</span></code></li>
+<li><code class="docutils literal"><span class="pre">retain</span></code></li>
+<li><code class="docutils literal"><span class="pre">retainCount</span></code></li>
+</ul>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p><code class="docutils literal"><span class="pre">retainCount</span></code> 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"><span class="std std-ref">semantics</span></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"><code class="docutils literal"><span class="pre">dealloc</span></code></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 <code class="docutils literal"><span class="pre">@selector</span></code>
+expression for the selector <code class="docutils literal"><span class="pre">dealloc</span></code>.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">There are no legitimate reasons to call <code class="docutils literal"><span class="pre">dealloc</span></code> directly.</p>
+</div>
+<p>A class may provide a method definition for an instance method named
+<code class="docutils literal"><span class="pre">dealloc</span></code>. This method will be called after the final <code class="docutils literal"><span class="pre">release</span></code> of the
+object but before it is deallocated or any of its instance variables are
+destroyed. The superclassâs implementation of <code class="docutils literal"><span class="pre">dealloc</span></code> 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 <code class="docutils literal"><span class="pre">dealloc</span></code> method, such as freeing
+non-retainable resources. Failing to call <code class="docutils literal"><span class="pre">[super</span> <span class="pre">dealloc]</span></code> in such a
+method is nearly always a bug. Sometimes, the object is simply trying to
+prevent itself from being destroyed, but <code class="docutils literal"><span class="pre">dealloc</span></code> 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
+<code class="docutils literal"><span class="pre">free</span></code>; for now, this can only be supported with a <code class="docutils literal"><span class="pre">dealloc</span></code>
+implementation outside of ARC. Such an implementation must be very careful
+to do all the other work that <code class="docutils literal"><span class="pre">NSObject</span></code>âs <code class="docutils literal"><span class="pre">dealloc</span></code> 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 <code class="docutils literal"><span class="pre">dealloc</span></code> 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 <code class="docutils literal"><span class="pre">[super</span> <span class="pre">dealloc]</span></code>. 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
+<code class="docutils literal"><span class="pre">dealloc</span></code>, 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 <code class="docutils literal"><span class="pre">dealloc</span></code>; a more
+holistic solution is to move semantically important side-effects out of
+<code class="docutils literal"><span class="pre">dealloc</span></code> 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"><code class="docutils literal"><span class="pre">@autoreleasepool</span></code></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 <code class="docutils literal"><span class="pre">@autoreleasepool</span></code> 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 <code class="docutils literal"><span class="pre">return</span></code> or
+<code class="docutils literal"><span class="pre">break</span></code>), 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><code class="docutils literal"><span class="pre">@autoreleasepool</span></code> may be used in non-ARC translation units, with equivalent
+semantics.</p>
+<p>A program is ill-formed if it refers to the <code class="docutils literal"><span class="pre">NSAutoreleasePool</span></code> 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"><code class="docutils literal"><span class="pre">self</span></code></a><a class="headerlink" href="#self" title="Permalink to this headline">¶</a></h3>
+<p>The <code class="docutils literal"><span class="pre">self</span></code> 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 <code class="docutils literal"><span class="pre">self</span></code> is implicitly
+<code class="docutils literal"><span class="pre">const</span></code> unless the method is in the <a class="reference internal" href="#arc-family-semantics-init"><span class="std std-ref">init family</span></a>. Further, <code class="docutils literal"><span class="pre">self</span></code> is <strong>always</strong> implicitly
+<code class="docutils literal"><span class="pre">const</span></code> within a class method.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">The cost of retaining <code class="docutils literal"><span class="pre">self</span></code> 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 <code class="docutils literal"><span class="pre">__unsafe_unretained</span></code>), 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 <code class="docutils literal"><span class="pre">const</span> <span class="pre">__strong</span></code> 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 <code class="docutils literal"><span class="pre">__strong</span></code>, 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 <code class="docutils literal"><span class="pre">const</span></code> 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"><span class="std std-ref">inference</span></a> rules apply equally to
+<code class="docutils literal"><span class="pre">__block</span></code> variables, which is a shift in semantics from non-ARC, where
+<code class="docutils literal"><span class="pre">__block</span></code> variables did not implicitly retain during capture.</p>
+<p><code class="docutils literal"><span class="pre">__block</span></code> 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 <code class="docutils literal"><span class="pre">__strong</span></code>
+parameter variable or reading a <code class="docutils literal"><span class="pre">__weak</span></code> variable, whenever these semantics
+call for retaining a value of block-pointer type, it has the effect of a
+<code class="docutils literal"><span class="pre">Block_copy</span></code>. 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 <code class="docutils literal"><span class="pre">__strong</span></code> 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 <code class="docutils literal"><span class="pre">-fobjc-arc-exceptions</span></code> in order to
+enable these, or with the option <code class="docutils literal"><span class="pre">-fno-objc-arc-exceptions</span></code> 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++, <code class="docutils literal"><span class="pre">-fobjc-arc-exceptions</span></code> 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 <code class="docutils literal"><span class="pre">__weak</span></code> 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 <code class="docutils literal"><span class="pre">__weak</span></code> 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 <code class="docutils literal"><span class="pre">objc_returns_inner_pointer</span></code> 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 <code class="docutils literal"><span class="pre">strchr</span></code>). 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 <code class="docutils literal"><span class="pre">__strong</span></code> object with <a class="reference internal" href="#arc-optimization-precise"><span class="std std-ref">precise lifetime semantics</span></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) <code class="docutils literal"><span class="pre">void</span></code> or a pointer to a (possibly qualifier) <code class="docutils literal"><span class="pre">struct</span></code>
+or <code class="docutils literal"><span class="pre">class</span></code> 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 <code class="docutils literal"><span class="pre">cf_audited_transfer</span></code> 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 <code class="docutils literal"><span class="pre">cf_consumed</span></code> attribute, and</li>
+<li>A result of C retainable pointer type is assumed to not be returned retained
+unless the function is either marked <code class="docutils literal"><span class="pre">cf_returns_retained</span></code> or it follows
+the create/copy naming convention and is not marked
+<code class="docutils literal"><span class="pre">cf_returns_not_retained</span></code>.</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, <code class="docutils literal"><span class="pre">cf_unknown_transfer</span></code>, 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 <code class="docutils literal"><span class="pre">cf_audited_transfer</span></code> and <code class="docutils literal"><span class="pre">cf_unknown_transfer</span></code>.</p>
+<p>A pragma is provided to facilitate the mass annotation of interfaces:</p>
+<div class="highlight-objc"><div class="highlight"><pre><span></span><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 <code class="docutils literal"><span class="pre">cf_audited_transfer</span></code> attribute unless they otherwise have
+the <code class="docutils literal"><span class="pre">cf_unknown_transfer</span></code> 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
+<code class="docutils literal"><span class="pre">__has_feature(arc_cf_code_audited)</span></code>.</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 <code class="docutils literal"><span class="pre">__weak</span></code> object is inadequately
+aligned for an object of type <code class="docutils literal"><span class="pre">id</span></code>. The other qualifiers may be used on
+explicitly under-aligned memory.</p>
+<p>The runtime tracks <code class="docutils literal"><span class="pre">__weak</span></code> objects which holds non-null values. It is
+undefined behavior to direct modify a <code class="docutils literal"><span class="pre">__weak</span></code> object which is being tracked
+by the runtime except through an
+<a class="reference internal" href="#arc-runtime-objc-storeweak"><span class="std std-ref">objc_storeWeak</span></a>,
+<a class="reference internal" href="#arc-runtime-objc-destroyweak"><span class="std std-ref">objc_destroyWeak</span></a>, or
+<a class="reference internal" href="#arc-runtime-objc-moveweak"><span class="std std-ref">objc_moveWeak</span></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"><code class="docutils literal"><span class="pre">id</span> <span class="pre">objc_autorelease(id</span> <span class="pre">value);</span></code></a><a class="headerlink" href="#arc-runtime-objc-autorelease" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <code class="docutils literal"><span class="pre">value</span></code> is null or a pointer to a valid object.</p>
+<p>If <code class="docutils literal"><span class="pre">value</span></code> 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
+<code class="docutils literal"><span class="pre">autorelease</span></code> message.</p>
+<p>Always returns <code class="docutils literal"><span class="pre">value</span></code>.</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"><code class="docutils literal"><span class="pre">void</span> <span class="pre">objc_autoreleasePoolPop(void</span> <span class="pre">*pool);</span></code></a><a class="headerlink" href="#void-objc-autoreleasepoolpop-void-pool" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <code class="docutils literal"><span class="pre">pool</span></code> is the result of a previous call to
+<a class="reference internal" href="#arc-runtime-objc-autoreleasepoolpush"><span class="std std-ref">objc_autoreleasePoolPush</span></a> on the
+current thread, where neither <code class="docutils literal"><span class="pre">pool</span></code> 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 <code class="docutils literal"><span class="pre">pool</span></code>.</p>
+</div>
+<div class="section" id="void-objc-autoreleasepoolpush-void">
+<span id="arc-runtime-objc-autoreleasepoolpush"></span><h3><a class="toc-backref" href="#id58"><code class="docutils literal"><span class="pre">void</span> <span class="pre">*objc_autoreleasePoolPush(void);</span></code></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"><code class="docutils literal"><span class="pre">id</span> <span class="pre">objc_autoreleaseReturnValue(id</span> <span class="pre">value);</span></code></a><a class="headerlink" href="#arc-runtime-objc-autoreleasereturnvalue" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <code class="docutils literal"><span class="pre">value</span></code> is null or a pointer to a valid object.</p>
+<p>If <code class="docutils literal"><span class="pre">value</span></code> 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"><span class="std std-ref">objc_retainAutoreleasedReturnValue</span></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 <code class="docutils literal"><span class="pre">value</span></code>.</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"><code 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></code></a><a class="headerlink" href="#void-objc-copyweak-id-dest-id-src" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <code class="docutils literal"><span class="pre">src</span></code> is a valid pointer which either contains a null pointer
+or has been registered as a <code class="docutils literal"><span class="pre">__weak</span></code> object. <code class="docutils literal"><span class="pre">dest</span></code> is a valid pointer
+which has not been registered as a <code class="docutils literal"><span class="pre">__weak</span></code> object.</p>
+<p><code class="docutils literal"><span class="pre">dest</span></code> is initialized to be equivalent to <code class="docutils literal"><span class="pre">src</span></code>, potentially registering it
+with the runtime. Equivalent to the following code:</p>
+<div class="highlight-objc"><div class="highlight"><pre><span></span><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 <code class="docutils literal"><span class="pre">objc_storeWeak</span></code> on <code class="docutils literal"><span class="pre">src</span></code>.</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"><code class="docutils literal"><span class="pre">void</span> <span class="pre">objc_destroyWeak(id</span> <span class="pre">*object);</span></code></a><a class="headerlink" href="#void-objc-destroyweak-id-object" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <code class="docutils literal"><span class="pre">object</span></code> is a valid pointer which either contains a null
+pointer or has been registered as a <code class="docutils literal"><span class="pre">__weak</span></code> object.</p>
+<p><code class="docutils literal"><span class="pre">object</span></code> is unregistered as a weak object, if it ever was. The current value
+of <code class="docutils literal"><span class="pre">object</span></code> is left unspecified; otherwise, equivalent to the following code:</p>
+<div class="highlight-objc"><div class="highlight"><pre><span></span><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 <code class="docutils literal"><span class="pre">objc_storeWeak</span></code> on
+<code class="docutils literal"><span class="pre">object</span></code>.</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"><code 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></code></a><a class="headerlink" href="#arc-runtime-objc-initweak" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <code class="docutils literal"><span class="pre">object</span></code> is a valid pointer which has not been registered as
+a <code class="docutils literal"><span class="pre">__weak</span></code> object. <code class="docutils literal"><span class="pre">value</span></code> is null or a pointer to a valid object.</p>
+<p>If <code class="docutils literal"><span class="pre">value</span></code> is a null pointer or the object to which it points has begun
+deallocation, <code class="docutils literal"><span class="pre">object</span></code> is zero-initialized. Otherwise, <code class="docutils literal"><span class="pre">object</span></code> is
+registered as a <code class="docutils literal"><span class="pre">__weak</span></code> object pointing to <code class="docutils literal"><span class="pre">value</span></code>. Equivalent to the
+following code:</p>
+<div class="highlight-objc"><div class="highlight"><pre><span></span><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 <code class="docutils literal"><span class="pre">object</span></code> after the call.</p>
+<p>Does not need to be atomic with respect to calls to <code class="docutils literal"><span class="pre">objc_storeWeak</span></code> on
+<code class="docutils literal"><span class="pre">object</span></code>.</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"><code class="docutils literal"><span class="pre">id</span> <span class="pre">objc_loadWeak(id</span> <span class="pre">*object);</span></code></a><a class="headerlink" href="#arc-runtime-objc-loadweak" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <code class="docutils literal"><span class="pre">object</span></code> is a valid pointer which either contains a null
+pointer or has been registered as a <code class="docutils literal"><span class="pre">__weak</span></code> object.</p>
+<p>If <code class="docutils literal"><span class="pre">object</span></code> is registered as a <code class="docutils literal"><span class="pre">__weak</span></code> object, and the last value stored
+into <code class="docutils literal"><span class="pre">object</span></code> 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></span><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 <code class="docutils literal"><span class="pre">objc_storeWeak</span></code> on <code class="docutils literal"><span class="pre">object</span></code>.</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"><code class="docutils literal"><span class="pre">id</span> <span class="pre">objc_loadWeakRetained(id</span> <span class="pre">*object);</span></code></a><a class="headerlink" href="#arc-runtime-objc-loadweakretained" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <code class="docutils literal"><span class="pre">object</span></code> is a valid pointer which either contains a null
+pointer or has been registered as a <code class="docutils literal"><span class="pre">__weak</span></code> object.</p>
+<p>If <code class="docutils literal"><span class="pre">object</span></code> is registered as a <code class="docutils literal"><span class="pre">__weak</span></code> object, and the last value stored
+into <code class="docutils literal"><span class="pre">object</span></code> 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 <code class="docutils literal"><span class="pre">objc_storeWeak</span></code> on <code class="docutils literal"><span class="pre">object</span></code>.</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"><code 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></code></a><a class="headerlink" href="#void-objc-moveweak-id-dest-id-src" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <code class="docutils literal"><span class="pre">src</span></code> is a valid pointer which either contains a null pointer
+or has been registered as a <code class="docutils literal"><span class="pre">__weak</span></code> object. <code class="docutils literal"><span class="pre">dest</span></code> is a valid pointer
+which has not been registered as a <code class="docutils literal"><span class="pre">__weak</span></code> object.</p>
+<p><code class="docutils literal"><span class="pre">dest</span></code> is initialized to be equivalent to <code class="docutils literal"><span class="pre">src</span></code>, potentially registering it
+with the runtime. <code class="docutils literal"><span class="pre">src</span></code> 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"><span class="std std-ref">objc_copyWeak</span></a>, or it may be left as null.</p>
+<p>Must be atomic with respect to calls to <code class="docutils literal"><span class="pre">objc_storeWeak</span></code> on <code class="docutils literal"><span class="pre">src</span></code>.</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"><code class="docutils literal"><span class="pre">void</span> <span class="pre">objc_release(id</span> <span class="pre">value);</span></code></a><a class="headerlink" href="#void-objc-release-id-value" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <code class="docutils literal"><span class="pre">value</span></code> is null or a pointer to a valid object.</p>
+<p>If <code class="docutils literal"><span class="pre">value</span></code> is null, this call has no effect. Otherwise, it performs a
+release operation exactly as if the object had been sent the <code class="docutils literal"><span class="pre">release</span></code>
+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"><code class="docutils literal"><span class="pre">id</span> <span class="pre">objc_retain(id</span> <span class="pre">value);</span></code></a><a class="headerlink" href="#arc-runtime-objc-retain" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <code class="docutils literal"><span class="pre">value</span></code> is null or a pointer to a valid object.</p>
+<p>If <code class="docutils literal"><span class="pre">value</span></code> is null, this call has no effect. Otherwise, it performs a retain
+operation exactly as if the object had been sent the <code class="docutils literal"><span class="pre">retain</span></code> message.</p>
+<p>Always returns <code class="docutils literal"><span class="pre">value</span></code>.</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"><code class="docutils literal"><span class="pre">id</span> <span class="pre">objc_retainAutorelease(id</span> <span class="pre">value);</span></code></a><a class="headerlink" href="#arc-runtime-objc-retainautorelease" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <code class="docutils literal"><span class="pre">value</span></code> is null or a pointer to a valid object.</p>
+<p>If <code class="docutils literal"><span class="pre">value</span></code> 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></span><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 <code class="docutils literal"><span class="pre">value</span></code>.</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"><code class="docutils literal"><span class="pre">id</span> <span class="pre">objc_retainAutoreleaseReturnValue(id</span> <span class="pre">value);</span></code></a><a class="headerlink" href="#arc-runtime-objc-retainautoreleasereturnvalue" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <code class="docutils literal"><span class="pre">value</span></code> is null or a pointer to a valid object.</p>
+<p>If <code class="docutils literal"><span class="pre">value</span></code> 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"><span class="std std-ref">objc_autoreleaseReturnValue</span></a>.
+Equivalent to the following code:</p>
+<div class="highlight-objc"><div class="highlight"><pre><span></span><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 <code class="docutils literal"><span class="pre">value</span></code>.</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"><code class="docutils literal"><span class="pre">id</span> <span class="pre">objc_retainAutoreleasedReturnValue(id</span> <span class="pre">value);</span></code></a><a class="headerlink" href="#arc-runtime-objc-retainautoreleasedreturnvalue" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <code class="docutils literal"><span class="pre">value</span></code> is null or a pointer to a valid object.</p>
+<p>If <code class="docutils literal"><span class="pre">value</span></code> 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"><span class="std std-ref">objc_autoreleaseReturnValue</span></a> on
+<code class="docutils literal"><span class="pre">value</span></code> 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"><span class="std std-ref">objc_retain</span></a>.</p>
+<p>Always returns <code class="docutils literal"><span class="pre">value</span></code>.</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"><code class="docutils literal"><span class="pre">id</span> <span class="pre">objc_retainBlock(id</span> <span class="pre">value);</span></code></a><a class="headerlink" href="#arc-runtime-objc-retainblock" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <code class="docutils literal"><span class="pre">value</span></code> is null or a pointer to a valid block object.</p>
+<p>If <code class="docutils literal"><span class="pre">value</span></code> is null, this call has no effect. Otherwise, if the block pointed
+to by <code class="docutils literal"><span class="pre">value</span></code> 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 <code class="docutils literal"><span class="pre">retain</span></code> 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"><code 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></code></a><a class="headerlink" href="#arc-runtime-objc-storestrong" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <code class="docutils literal"><span class="pre">object</span></code> is a valid pointer to a <code class="docutils literal"><span class="pre">__strong</span></code> object which is
+adequately aligned for a pointer. <code class="docutils literal"><span class="pre">value</span></code> is null or a pointer to a valid
+object.</p>
+<p>Performs the complete sequence for assigning to a <code class="docutils literal"><span class="pre">__strong</span></code> 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></span><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="k">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="k">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 <code class="docutils literal"><span class="pre">__strong</span></code> object of block type is an
+invalid argument to this function. Rather it implies that an <code class="docutils literal"><span class="pre">objc_retain</span></code>
+and not an <code class="docutils literal"><span class="pre">objc_retainBlock</span></code> 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"><code 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></code></a><a class="headerlink" href="#arc-runtime-objc-storeweak" title="Permalink to this headline">¶</a></h3>
+<p><em>Precondition:</em> <code class="docutils literal"><span class="pre">object</span></code> is a valid pointer which either contains a null
+pointer or has been registered as a <code class="docutils literal"><span class="pre">__weak</span></code> object. <code class="docutils literal"><span class="pre">value</span></code> is null or a
+pointer to a valid object.</p>
+<p>If <code class="docutils literal"><span class="pre">value</span></code> is a null pointer or the object to which it points has begun
+deallocation, <code class="docutils literal"><span class="pre">object</span></code> is assigned null and unregistered as a <code class="docutils literal"><span class="pre">__weak</span></code>
+object. Otherwise, <code class="docutils literal"><span class="pre">object</span></code> is registered as a <code class="docutils literal"><span class="pre">__weak</span></code> object or has its
+registration updated to point to <code class="docutils literal"><span class="pre">value</span></code>.</p>
+<p>Returns the value of <code class="docutils literal"><span class="pre">object</span></code> after the call.</p>
+</div>
+</div>
+</div>
+
+
+ </div>
+ <div class="bottomnav" role="navigation" aria-label="bottom navigation">
+
+ <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" role="contentinfo">
+ © Copyright 2007-2018, The Clang Team.
+ Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.6.4.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/7.0.0/tools/clang/docs/Block-ABI-Apple.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/7.0.0/tools/clang/docs/Block-ABI-Apple.html?rev=342530&view=auto
==============================================================================
--- www-releases/trunk/7.0.0/tools/clang/docs/Block-ABI-Apple.html (added)
+++ www-releases/trunk/7.0.0/tools/clang/docs/Block-ABI-Apple.html Wed Sep 19 02:40:08 2018
@@ -0,0 +1,915 @@
+
+<!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 7 documentation</title>
+ <link rel="stylesheet" href="_static/haiku.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: './',
+ VERSION: '7',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true,
+ SOURCELINK_SUFFIX: '.txt'
+ };
+ </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="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+ <link rel="index" title="Index" href="genindex.html" />
+ <link rel="search" title="Search" href="search.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" role="banner"><h1 class="heading"><a href="index.html">
+ <span>Clang 7 documentation</span></a></h1>
+ <h2 class="heading"><span>Block Implementation Specification</span></h2>
+ </div>
+ <div class="topnav" role="navigation" aria-label="top navigation">
+
+ <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 <code class="docutils literal"><span class="pre">const</span></code> copy variables</a></li>
+<li><a class="reference internal" href="#imported-const-copy-of-block-reference" id="id5">Imported <code class="docutils literal"><span class="pre">const</span></code> copy of <code class="docutils literal"><span class="pre">Block</span></code> reference</a><ul>
+<li><a class="reference internal" href="#importing-attribute-nsobject-variables" id="id6">Importing <code class="docutils literal"><span class="pre">__attribute__((NSObject))</span></code> variables</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#imported-block-marked-variables" id="id7">Imported <code class="docutils literal"><span class="pre">__block</span></code> marked variables</a><ul>
+<li><a class="reference internal" href="#layout-of-block-marked-variables" id="id8">Layout of <code class="docutils literal"><span class="pre">__block</span></code> marked variables</a></li>
+<li><a class="reference internal" href="#access-to-block-variables-from-within-its-lexical-scope" id="id9">Access to <code class="docutils literal"><span class="pre">__block</span></code> variables from within its lexical scope</a></li>
+<li><a class="reference internal" href="#importing-block-variables-into-blocks" id="id10">Importing <code class="docutils literal"><span class="pre">__block</span></code> variables into <code class="docutils literal"><span class="pre">Blocks</span></code></a></li>
+<li><a class="reference internal" href="#importing-attribute-nsobject-block-variables" id="id11">Importing <code class="docutils literal"><span class="pre">__attribute__((NSObject))</span></code> <code class="docutils literal"><span class="pre">__block</span></code> variables</a></li>
+<li><a class="reference internal" href="#block-escapes" id="id12"><code class="docutils literal"><span class="pre">__block</span></code> 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 <code class="docutils literal"><span class="pre">Blocks</span></code></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"><code class="docutils literal"><span class="pre">Blocks</span></code> as Objects</a></li>
+<li><a class="reference internal" href="#weak-block-support" id="id17"><code class="docutils literal"><span class="pre">__weak</span> <span class="pre">__block</span></code> 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 <code class="docutils literal"><span class="pre">NULL</span></code> <code class="docutils literal"><span class="pre">isa</span></code> field to <code class="docutils literal"><span class="pre">__block</span></code> storage.</li>
+<li>2008/10/1 - revise block layout to use a <code class="docutils literal"><span class="pre">static</span></code> 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 <code class="docutils literal"><span class="pre">_Block_object_assign</span></code> and
+<code class="docutils literal"><span class="pre">_Block_object_dispose</span></code> 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 <code class="docutils literal"><span class="pre">__weak</span></code> 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 <code class="docutils literal"><span class="pre">Blocks</span></code> consist of their layout and the runtime functions required
+by the compiler. A <code class="docutils literal"><span class="pre">Block</span></code> consists of a structure of the following form:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></span><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></span><span class="k">enum</span> <span class="p">{</span>
+ <span class="c1">// Set to true on blocks that have captures (and thus are not true</span>
+ <span class="c1">// global blocks) but are known not to escape for various other</span>
+ <span class="c1">// reasons. For backward compatiblity with old runtimes, whenever</span>
+ <span class="c1">// BLOCK_IS_NOESCAPE is set, BLOCK_IS_GLOBAL is set too. Copying a</span>
+ <span class="c1">// non-escaping block returns the original block and releasing such a</span>
+ <span class="c1">// block is a no-op, which is exactly how global blocks are handled.</span>
+ <span class="n">BLOCK_IS_NOESCAPE</span> <span class="o">=</span> <span class="p">(</span><span class="mi">1</span> <span class="o"><<</span> <span class="mi">23</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></span><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="o">:</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="o">:</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="o">:</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="o">:</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><code class="docutils literal"><span class="pre">Block</span></code> literals may occur within functions where the structure is created in
+stack local memory. They may also appear as initialization expressions for
+<code class="docutils literal"><span class="pre">Block</span></code> variables of global or <code class="docutils literal"><span class="pre">static</span></code> local variables.</p>
+<p>When a <code class="docutils literal"><span class="pre">Block</span></code> literal expression is evaluated the stack based structure is
+initialized as follows:</p>
+<ol class="arabic simple">
+<li>A <code class="docutils literal"><span class="pre">static</span></code> descriptor structure is declared and initialized as follows:</li>
+</ol>
+<blockquote>
+<div><p>a. The <code class="docutils literal"><span class="pre">invoke</span></code> function pointer is set to a function that takes the
+<code class="docutils literal"><span class="pre">Block</span></code> structure as its first argument and the rest of the arguments (if
+any) to the <code class="docutils literal"><span class="pre">Block</span></code> and executes the <code class="docutils literal"><span class="pre">Block</span></code> compound statement.</p>
+<p>b. The <code class="docutils literal"><span class="pre">size</span></code> field is set to the size of the following <code class="docutils literal"><span class="pre">Block</span></code> literal
+structure.</p>
+<p>c. The <code class="docutils literal"><span class="pre">copy_helper</span></code> and <code class="docutils literal"><span class="pre">dispose_helper</span></code> function pointers are set to
+respective helper functions if they are required by the <code class="docutils literal"><span class="pre">Block</span></code> literal.</p>
+</div></blockquote>
+<ol class="arabic" start="2">
+<li><p class="first">A stack (or global) <code class="docutils literal"><span class="pre">Block</span></code> literal data structure is created and
+initialized as follows:</p>
+<p>a. The <code class="docutils literal"><span class="pre">isa</span></code> field is set to the address of the external
+<code class="docutils literal"><span class="pre">_NSConcreteStackBlock</span></code>, which is a block of uninitialized memory supplied
+in <code class="docutils literal"><span class="pre">libSystem</span></code>, or <code class="docutils literal"><span class="pre">_NSConcreteGlobalBlock</span></code> if this is a static or file
+level <code class="docutils literal"><span class="pre">Block</span></code> literal.</p>
+<p>b. The <code class="docutils literal"><span class="pre">flags</span></code> field is set to zero unless there are variables imported
+into the <code class="docutils literal"><span class="pre">Block</span></code> that need helper functions for program level
+<code class="docutils literal"><span class="pre">Block_copy()</span></code> and <code class="docutils literal"><span class="pre">Block_release()</span></code> operations, in which case the
+(1<<25) flags bit is set.</p>
+</li>
+</ol>
+<p>As an example, the <code class="docutils literal"><span class="pre">Block</span></code> literal expression:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></span><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></span><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 <code class="docutils literal"><span class="pre">Block</span></code> literal itself appears:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></span><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 <code class="docutils literal"><span class="pre">Block</span></code> imports other <code class="docutils literal"><span class="pre">Block</span></code> references, <code class="docutils literal"><span class="pre">const</span></code> copies of other
+variables, and variables marked <code class="docutils literal"><span class="pre">__block</span></code>. In Objective-C, variables may
+additionally be objects.</p>
+<p>When a <code class="docutils literal"><span class="pre">Block</span></code> literal expression is used as the initial value of a global
+or <code class="docutils literal"><span class="pre">static</span></code> local variable, it is initialized as follows:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></span><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 <code class="docutils literal"><span class="pre">flags</span></code> field, and otherwise it is the same as for
+stack based <code class="docutils literal"><span class="pre">Block</span></code> literals. This is an optimization that can be used for
+any <code class="docutils literal"><span class="pre">Block</span></code> literal that imports no <code class="docutils literal"><span class="pre">const</span></code> or <code class="docutils literal"><span class="pre">__block</span></code> 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 <code class="docutils literal"><span class="pre">auto</span></code> storage class are imported as <code class="docutils literal"><span class="pre">const</span></code> copies. Variables
+of <code class="docutils literal"><span class="pre">__block</span></code> 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 <code class="docutils literal"><span class="pre">const</span></code> 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 <code class="docutils literal"><span class="pre">__block</span></code> are imported as
+<code class="docutils literal"><span class="pre">const</span></code> copies.</p>
+<p>The simplest example is that of importing a variable of type <code class="docutils literal"><span class="pre">int</span></code>:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></span><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></span><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></span><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 <code class="docutils literal"><span class="pre">const</span></code> 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 <code class="docutils literal"><span class="pre">const</span></code> copy of <code class="docutils literal"><span class="pre">Block</span></code> 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 <code class="docutils literal"><span class="pre">Block</span></code> itself is imported. In this case both a
+<code class="docutils literal"><span class="pre">copy_helper</span></code> function and a <code class="docutils literal"><span class="pre">dispose_helper</span></code> function are needed. The
+<code class="docutils literal"><span class="pre">copy_helper</span></code> 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 <code class="docutils literal"><span class="pre">Block</span></code>. The
+runtime functions are all described in <a class="reference internal" href="#runtimehelperfunctions"><span class="std std-ref">Runtime Helper Functions</span></a>.</p>
+<p>A quick example:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></span><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 <code class="docutils literal"><span class="pre">Block</span></code> is used:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></span><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 <code class="docutils literal"><span class="pre">__attribute__((NSObject))</span></code> variables</a><a class="headerlink" href="#importing-attribute-nsobject-variables" title="Permalink to this headline">¶</a></h4>
+<p>GCC introduces <code class="docutils literal"><span class="pre">__attribute__((NSObject))</span></code> 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. <code class="docutils literal"><span class="pre">CFStringRef</span></code>, <code class="docutils literal"><span class="pre">CFArrayRef</span></code>,
+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
+<code class="docutils literal"><span class="pre">_Block_object_assign</span></code> runtime helper function and in the dispose helper the
+<code class="docutils literal"><span class="pre">_Block_object_dispose</span></code> runtime helper function should be called.</p>
+<p>For example, <code class="docutils literal"><span class="pre">Block</span></code> foo in the following:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></span><span class="k">struct</span> <span class="n">Opaque</span> <span class="o">*</span><span class="nf">__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></span><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 <code class="docutils literal"><span class="pre">__block</span></code> 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 <code class="docutils literal"><span class="pre">__block</span></code> 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 <code class="docutils literal"><span class="pre">__block</span></code> in a specialized
+structure of the form:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></span><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 <code class="docutils literal"><span class="pre">Block_copy()</span></code>
+and <code class="docutils literal"><span class="pre">Block_release()</span></code> are performed upon a referencing <code class="docutils literal"><span class="pre">Block</span></code>. At the âCâ
+level only variables that are of type <code class="docutils literal"><span class="pre">Block</span></code> or ones that have
+<code class="docutils literal"><span class="pre">__attribute__((NSObject))</span></code> 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></span><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 <code class="docutils literal"><span class="pre">forwarding</span></code> pointer is set to the beginning of its enclosing
+structure.</p>
+<p>b. The <code class="docutils literal"><span class="pre">size</span></code> field is initialized to the total size of the enclosing
+structure.</p>
+<p>c. The <code class="docutils literal"><span class="pre">flags</span></code> 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 <code class="docutils literal"><span class="pre">isa</span></code> field is set to <code class="docutils literal"><span class="pre">NULL</span></code>.</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 <code class="docutils literal"><span class="pre">__block</span></code> 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 <code class="docutils literal"><span class="pre">copy_helper</span></code> operation the
+compiler must rewrite access to such a variable to be indirect through the
+structures <code class="docutils literal"><span class="pre">forwarding</span></code> pointer. For example:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></span><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></span><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 <code class="docutils literal"><span class="pre">Block</span></code> reference variable being marked <code class="docutils literal"><span class="pre">__block</span></code> the
+helper code generated must use the <code class="docutils literal"><span class="pre">_Block_object_assign</span></code> and
+<code class="docutils literal"><span class="pre">_Block_object_dispose</span></code> routines supplied by the runtime to make the
+copies. For example:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></span><span class="n">__block</span> <span class="nf">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></span><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></span><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 <code class="docutils literal"><span class="pre">__block</span></code> variables into <code class="docutils literal"><span class="pre">Blocks</span></code></a><a class="headerlink" href="#importing-block-variables-into-blocks" title="Permalink to this headline">¶</a></h4>
+<p>A <code class="docutils literal"><span class="pre">Block</span></code> that uses a <code class="docutils literal"><span class="pre">__block</span></code> variable in its compound statement body must
+import the variable and emit <code class="docutils literal"><span class="pre">copy_helper</span></code> and <code class="docutils literal"><span class="pre">dispose_helper</span></code> helper
+functions that, in turn, call back into the runtime to actually copy or release
+the <code class="docutils literal"><span class="pre">byref</span></code> data block using the functions <code class="docutils literal"><span class="pre">_Block_object_assign</span></code> and
+<code class="docutils literal"><span class="pre">_Block_object_dispose</span></code>.</p>
+<p>For example:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></span><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></span><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></span><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 <code class="docutils literal"><span class="pre">__attribute__((NSObject))</span></code> <code class="docutils literal"><span class="pre">__block</span></code> variables</a><a class="headerlink" href="#importing-attribute-nsobject-block-variables" title="Permalink to this headline">¶</a></h4>
+<p>A <code class="docutils literal"><span class="pre">__block</span></code> variable that is also marked <code class="docutils literal"><span class="pre">__attribute__((NSObject))</span></code> should
+have <code class="docutils literal"><span class="pre">byref_keep</span></code> and <code class="docutils literal"><span class="pre">byref_dispose</span></code> helper functions that use
+<code class="docutils literal"><span class="pre">_Block_object_assign</span></code> and <code class="docutils literal"><span class="pre">_Block_object_dispose</span></code>.</p>
+</div>
+<div class="section" id="block-escapes">
+<h4><a class="toc-backref" href="#id12"><code class="docutils literal"><span class="pre">__block</span></code> escapes</a><a class="headerlink" href="#block-escapes" title="Permalink to this headline">¶</a></h4>
+<p>Because <code class="docutils literal"><span class="pre">Blocks</span></code> referencing <code class="docutils literal"><span class="pre">__block</span></code> variables may have <code class="docutils literal"><span class="pre">Block_copy()</span></code>
+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
+<code class="docutils literal"><span class="pre">__block</span></code> variables at all escapes or terminations of their scope. The call
+should be:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></span><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><code class="docutils literal"><span class="pre">Blocks</span></code> may contain <code class="docutils literal"><span class="pre">Block</span></code> literal expressions. Any variables used within
+inner blocks are imported into all enclosing <code class="docutils literal"><span class="pre">Block</span></code> scopes even if the
+variables are not used. This includes <code class="docutils literal"><span class="pre">const</span></code> imports as well as <code class="docutils literal"><span class="pre">__block</span></code>
+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 <code class="docutils literal"><span class="pre">Blocks</span></code></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 <code class="docutils literal"><span class="pre">__attribute__((NSObject))</span></code> variables; all
+<code class="docutils literal"><span class="pre">copy_helper</span></code>, <code class="docutils literal"><span class="pre">dispose_helper</span></code>, <code class="docutils literal"><span class="pre">byref_keep</span></code>, and <code class="docutils literal"><span class="pre">byref_dispose</span></code>
+helper functions should use <code class="docutils literal"><span class="pre">_Block_object_assign</span></code> and
+<code class="docutils literal"><span class="pre">_Block_object_dispose</span></code>. There should be no code generated that uses
+<code class="docutils literal"><span class="pre">*-retain</span></code> or <code class="docutils literal"><span class="pre">*-release</span></code> methods.</p>
+</div>
+<div class="section" id="blocks-as-objects">
+<h3><a class="toc-backref" href="#id16"><code class="docutils literal"><span class="pre">Blocks</span></code> as Objects</a><a class="headerlink" href="#blocks-as-objects" title="Permalink to this headline">¶</a></h3>
+<p>The compiler will treat <code class="docutils literal"><span class="pre">Blocks</span></code> 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"><code class="docutils literal"><span class="pre">__weak</span> <span class="pre">__block</span></code> Support</a><a class="headerlink" href="#weak-block-support" title="Permalink to this headline">¶</a></h3>
+<p>Objective-C (and Objective-C++) support the <code class="docutils literal"><span class="pre">__weak</span></code> attribute on <code class="docutils literal"><span class="pre">__block</span></code>
+variables. Under normal circumstances the compiler uses the Objective-C runtime
+helper support functions <code class="docutils literal"><span class="pre">objc_assign_weak</span></code> and <code class="docutils literal"><span class="pre">objc_read_weak</span></code>. Both
+should continue to be used for all reads and writes of <code class="docutils literal"><span class="pre">__weak</span> <span class="pre">__block</span></code>
+variables:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></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_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 <code class="docutils literal"><span class="pre">__weak</span></code> variable is stored in a <code class="docutils literal"><span class="pre">_block_byref_foo</span></code> structure and the
+<code class="docutils literal"><span class="pre">Block</span></code> has copy and dispose helpers for this structure that call:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></span><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></span><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 <code class="docutils literal"><span class="pre">block_byref</span></code> copy support helpers distinguish between whether
+the <code class="docutils literal"><span class="pre">__block</span></code> variable is a <code class="docutils literal"><span class="pre">Block</span></code> or not and should either call:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></span><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></span><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 <code class="docutils literal"><span class="pre">Block</span></code>.</p>
+<p>A full example follows:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></span><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></span><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 <code class="docutils literal"><span class="pre">byref</span></code> part and:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></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_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></span><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 <code class="docutils literal"><span class="pre">const</span></code> 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
+<code class="docutils literal"><span class="pre">Block_copy()</span></code> 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 <code class="docutils literal"><span class="pre">const</span></code> constructed copies, and similarly
+should call the destructor in the destroy routine.</p>
+<p>As an example, suppose a C++ class <code class="docutils literal"><span class="pre">FOO</span></code> existed with a copy constructor.
+Within a code block a stack version of a <code class="docutils literal"><span class="pre">FOO</span></code> object is declared and used
+within a <code class="docutils literal"><span class="pre">Block</span></code> literal expression:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><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></span><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="nf">__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="nf">__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="nf">__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></span><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 <code class="docutils literal"><span class="pre">__block</span></code> storage start out on the stack in a
+<code class="docutils literal"><span class="pre">block_byref</span></code> data structure as do other variables. Such objects (if not
+<code class="docutils literal"><span class="pre">const</span></code> objects) must support a regular copy constructor. The <code class="docutils literal"><span class="pre">block_byref</span></code>
+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 <code class="docutils literal"><span class="pre">block_byref</span></code> 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
+<code class="docutils literal"><span class="pre">block_byref</span></code> heap data structure. For example,</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><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 <code class="docutils literal"><span class="pre">blockStorageFoo</span></code> object:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><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></span><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></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_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="nf">_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
+<code class="docutils literal"><span class="pre">FOO</span></code>.</p>
+<p>To support member variable and function access the compiler will synthesize a
+<code class="docutils literal"><span class="pre">const</span></code> pointer to a block version of the <code class="docutils literal"><span class="pre">this</span></code> 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
+<code class="docutils literal"><span class="pre">/usr/local/include/Block_private.h</span></code>. To summarize their use, a <code class="docutils literal"><span class="pre">Block</span></code>
+requires copy/dispose helpers if it imports any block variables, <code class="docutils literal"><span class="pre">__block</span></code>
+storage variables, <code class="docutils literal"><span class="pre">__attribute__((NSObject))</span></code> variables, or C++ <code class="docutils literal"><span class="pre">const</span></code>
+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></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">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></span><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 <code class="docutils literal"><span class="pre"><apropos></span></code> is:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></span><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 <code class="docutils literal"><span class="pre">const</span></code> copied C++ objects.</p>
+<p>The <code class="docutils literal"><span class="pre">block_byref</span></code> data structure similarly requires copy/dispose helpers for
+block variables, <code class="docutils literal"><span class="pre">__attribute__((NSObject))</span></code> variables, or C++ <code class="docutils literal"><span class="pre">const</span></code>
+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 <code class="docutils literal"><span class="pre">__weak</span></code> as an attribute on <code class="docutils literal"><span class="pre">__block</span></code> variables, and
+this causes the addition of <code class="docutils literal"><span class="pre">BLOCK_FIELD_IS_WEAK</span></code> orred onto the
+<code class="docutils literal"><span class="pre">BLOCK_FIELD_IS_BYREF</span></code> flag when copying the <code class="docutils literal"><span class="pre">block_byref</span></code> structure in the
+<code class="docutils literal"><span class="pre">Block</span></code> copy helper, and onto the <code class="docutils literal"><span class="pre">BLOCK_FIELD_<apropos></span></code> field within the
+<code class="docutils literal"><span class="pre">block_byref</span></code> 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></span><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="nf">_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="nf">_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" role="navigation" aria-label="bottom navigation">
+
+ <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" role="contentinfo">
+ © Copyright 2007-2018, The Clang Team.
+ Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.6.4.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/7.0.0/tools/clang/docs/BlockLanguageSpec.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/7.0.0/tools/clang/docs/BlockLanguageSpec.html?rev=342530&view=auto
==============================================================================
--- www-releases/trunk/7.0.0/tools/clang/docs/BlockLanguageSpec.html (added)
+++ www-releases/trunk/7.0.0/tools/clang/docs/BlockLanguageSpec.html Wed Sep 19 02:40:08 2018
@@ -0,0 +1,370 @@
+
+<!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 7 documentation</title>
+ <link rel="stylesheet" href="_static/haiku.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: './',
+ VERSION: '7',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true,
+ SOURCELINK_SUFFIX: '.txt'
+ };
+ </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="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+ <link rel="index" title="Index" href="genindex.html" />
+ <link rel="search" title="Search" href="search.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" role="banner"><h1 class="heading"><a href="index.html">
+ <span>Clang 7 documentation</span></a></h1>
+ <h2 class="heading"><span>Language Specification for Blocks</span></h2>
+ </div>
+ <div class="topnav" role="navigation" aria-label="top navigation">
+
+ <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 <code class="docutils literal"><span class="pre">__block</span></code> 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, <code class="docutils literal"><span class="pre">__block</span></code> syntax</li>
+<li>2008/8/13 â revised, Block globals</li>
+<li>2008/8/21 â revised, C++ elaboration</li>
+<li>2008/11/1 â revised, <code class="docutils literal"><span class="pre">__weak</span></code> support</li>
+<li>2009/1/12 â revised, explicit return types</li>
+<li>2009/2/10 â revised, <code class="docutils literal"><span class="pre">__block</span></code> 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></span><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 <code class="docutils literal"><span class="pre">^</span></code> for <code class="docutils literal"><span class="pre">*</span></code>. The following are
+valid Block variable declarations:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></span><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 <code class="docutils literal"><span class="pre">...</span></code> 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 <code class="docutils literal"><span class="pre">*</span></code>, 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 <code class="docutils literal"><span class="pre">^</span></code> token as a unary
+operator.</p>
+<div class="highlight-c"><div class="highlight"><pre><span></span><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 <code class="docutils literal"><span class="pre">^</span></code> as a Block reference
+(pointer) where <code class="docutils literal"><span class="pre">*</span></code> is allowed as a function reference (pointer).</p>
+<p>The following Block literal:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></span><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 <code class="docutils literal"><span class="pre">(</span> <span class="pre">void</span> <span class="pre">)</span></code>,
+the <code class="docutils literal"><span class="pre">(</span> <span class="pre">void</span> <span class="pre">)</span></code> argument list may also be omitted.</p>
+<p>So:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></span><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></span><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></span><span class="k">typedef</span> <span class="nf">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></span><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></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="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></span><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></span><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></span><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="nl">x</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>
+</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 <code class="docutils literal"><span class="pre">Block_copy()</span></code> is styled as a function that takes
+an arbitrary Block reference and returns a Block reference of the same
+type. The release operation, <code class="docutils literal"><span class="pre">Block_release()</span></code>, 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 <code class="docutils literal"><span class="pre">__block</span></code> 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 <code class="docutils literal"><span class="pre">__block</span></code> storage
+qualifier is mutually exclusive to the existing local storage
+qualifiers auto, register, and static. [testme] Variables qualified by
+<code class="docutils literal"><span class="pre">__block</span></code> 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 <code class="docutils literal"><span class="pre">__block</span></code> variable is a Block one must assume
+that the <code class="docutils literal"><span class="pre">__block</span></code> 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 <code class="docutils literal"><span class="pre">Block_copy</span></code> operation). Despite this
+there is no provision to do a <code class="docutils literal"><span class="pre">Block_copy</span></code> or a <code class="docutils literal"><span class="pre">Block_release</span></code> 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 <code class="docutils literal"><span class="pre">__weak</span></code> 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 <code class="docutils literal"><span class="pre">__block</span></code> storage type are assumed to hold
+normal pointers with no provision for retain and release messages.</p>
+<p>Foundation defines (and supplies) <code class="docutils literal"><span class="pre">-copy</span></code> and <code class="docutils literal"><span class="pre">-release</span></code> methods for
+Blocks.</p>
+<p>In the Objective-C and Objective-C++ languages, we allow the
+<code class="docutils literal"><span class="pre">__weak</span></code> specifier for <code class="docutils literal"><span class="pre">__block</span></code> 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 <code class="docutils literal"><span class="pre">__weak</span></code> variable is set to
+nil when the object it references is collected, as long as the
+<code class="docutils literal"><span class="pre">__block</span></code> variable resides in the heap (either by default or via
+<code class="docutils literal"><span class="pre">Block_copy()</span></code>). The initial Apple implementation does in fact
+start <code class="docutils literal"><span class="pre">__block</span></code> variables on the stack and migrate them to the heap
+only as a result of a <code class="docutils literal"><span class="pre">Block_copy()</span></code> operation.</p>
+<p>It is a runtime error to attempt to assign a reference to a
+stack-based Block into any storage marked <code class="docutils literal"><span class="pre">__weak</span></code>, including
+<code class="docutils literal"><span class="pre">__weak</span></code> <code class="docutils literal"><span class="pre">__block</span></code> 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></span><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></span><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 <code class="docutils literal"><span class="pre">Block_copy()</span></code> 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 <code class="docutils literal"><span class="pre">__block</span></code> 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 <code class="docutils literal"><span class="pre">Block_copy()</span></code> operation. When copied
+from the stack, <code class="docutils literal"><span class="pre">__block</span></code> variables are copied using their normal
+qualification (i.e. without adding const). In C++11, <code class="docutils literal"><span class="pre">__block</span></code>
+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 <code class="docutils literal"><span class="pre">this</span></code>, as well as references to non-static members of
+any enclosing class, are evaluated by capturing <code class="docutils literal"><span class="pre">this</span></code> 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" role="navigation" aria-label="bottom navigation">
+
+ <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" role="contentinfo">
+ © Copyright 2007-2018, The Clang Team.
+ Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.6.4.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/7.0.0/tools/clang/docs/ClangCheck.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/7.0.0/tools/clang/docs/ClangCheck.html?rev=342530&view=auto
==============================================================================
--- www-releases/trunk/7.0.0/tools/clang/docs/ClangCheck.html (added)
+++ www-releases/trunk/7.0.0/tools/clang/docs/ClangCheck.html Wed Sep 19 02:40:08 2018
@@ -0,0 +1,102 @@
+
+<!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 7 documentation</title>
+ <link rel="stylesheet" href="_static/haiku.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: './',
+ VERSION: '7',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true,
+ SOURCELINK_SUFFIX: '.txt'
+ };
+ </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="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+ <link rel="index" title="Index" href="genindex.html" />
+ <link rel="search" title="Search" href="search.html" />
+ <link rel="next" title="ClangFormat" href="ClangFormat.html" />
+ <link rel="prev" title="Overview" href="ClangTools.html" />
+ </head>
+ <body>
+ <div class="header" role="banner"><h1 class="heading"><a href="index.html">
+ <span>Clang 7 documentation</span></a></h1>
+ <h2 class="heading"><span>ClangCheck</span></h2>
+ </div>
+ <div class="topnav" role="navigation" aria-label="top navigation">
+
+ <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"><span class="doc">LibTooling</span></a> which can be used to
+do basic error checking and AST dumping.</p>
+<div class="highlight-console"><div class="highlight"><pre><span></span><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"><span class="doc">How To Setup Clang Tooling For LLVM</span></a>.</p>
+</div>
+
+
+ </div>
+ <div class="bottomnav" role="navigation" aria-label="bottom navigation">
+
+ <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" role="contentinfo">
+ © Copyright 2007-2018, The Clang Team.
+ Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.6.4.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/7.0.0/tools/clang/docs/ClangCommandLineReference.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/7.0.0/tools/clang/docs/ClangCommandLineReference.html?rev=342530&view=auto
==============================================================================
--- www-releases/trunk/7.0.0/tools/clang/docs/ClangCommandLineReference.html (added)
+++ www-releases/trunk/7.0.0/tools/clang/docs/ClangCommandLineReference.html Wed Sep 19 02:40:08 2018
@@ -0,0 +1,5448 @@
+
+<!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 7 documentation</title>
+ <link rel="stylesheet" href="_static/haiku.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: './',
+ VERSION: '7',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true,
+ SOURCELINK_SUFFIX: '.txt'
+ };
+ </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="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+ <link rel="index" title="Index" href="genindex.html" />
+ <link rel="search" title="Search" href="search.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" role="banner"><h1 class="heading"><a href="index.html">
+ <span>Clang 7 documentation</span></a></h1>
+ <h2 class="heading"><span>Clang command line argument reference</span></h2>
+ </div>
+ <div class="topnav" role="navigation" aria-label="top navigation">
+
+ <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="id4">Introduction</a></li>
+<li><a class="reference internal" href="#actions" id="id5">Actions</a></li>
+<li><a class="reference internal" href="#compilation-flags" id="id6">Compilation flags</a><ul>
+<li><a class="reference internal" href="#preprocessor-flags" id="id7">Preprocessor flags</a><ul>
+<li><a class="reference internal" href="#include-path-management" id="id8">Include path management</a></li>
+<li><a class="reference internal" href="#dependency-file-generation" id="id9">Dependency file generation</a></li>
+<li><a class="reference internal" href="#dumping-preprocessor-state" id="id10">Dumping preprocessor state</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#diagnostic-flags" id="id11">Diagnostic flags</a></li>
+<li><a class="reference internal" href="#target-independent-compilation-options" id="id12">Target-independent compilation options</a><ul>
+<li><a class="reference internal" href="#opencl-flags" id="id13">OpenCL flags</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#target-dependent-compilation-options" id="id14">Target-dependent compilation options</a><ul>
+<li><a class="reference internal" href="#aarch64" id="id15">AARCH64</a></li>
+<li><a class="reference internal" href="#amdgpu" id="id16">AMDGPU</a></li>
+<li><a class="reference internal" href="#arm" id="id17">ARM</a></li>
+<li><a class="reference internal" href="#hexagon" id="id18">Hexagon</a></li>
+<li><a class="reference internal" href="#id1" id="id19">Hexagon</a></li>
+<li><a class="reference internal" href="#mips" id="id20">MIPS</a></li>
+<li><a class="reference internal" href="#powerpc" id="id21">PowerPC</a></li>
+<li><a class="reference internal" href="#webassembly" id="id22">WebAssembly</a></li>
+<li><a class="reference internal" href="#x86" id="id23">X86</a></li>
+<li><a class="reference internal" href="#riscv" id="id24">RISCV</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#optimization-level" id="id25">Optimization level</a></li>
+<li><a class="reference internal" href="#debug-information-generation" id="id26">Debug information generation</a><ul>
+<li><a class="reference internal" href="#kind-and-level-of-debug-information" id="id27">Kind and level of debug information</a><ul>
+<li><a class="reference internal" href="#debug-level" id="id28">Debug level</a></li>
+<li><a class="reference internal" href="#debugger-to-tune-debug-information-for" id="id29">Debugger to tune debug information for</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#debug-information-flags" id="id30">Debug information flags</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#static-analyzer-flags" id="id31">Static analyzer flags</a></li>
+<li><a class="reference internal" href="#fortran-compilation-flags" id="id32">Fortran compilation flags</a></li>
+<li><a class="reference internal" href="#linker-flags" id="id33">Linker flags</a></li>
+</ul>
+</div>
+<div class="section" id="introduction">
+<h2><a class="toc-backref" href="#id4">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 <code class="docutils literal"><span class="pre">clang</span></code> and <code class="docutils literal"><span class="pre">clang++</span></code> drivers.</p>
+<dl class="option">
+<dt id="cmdoption-clang-b-dir">
+<code class="descname">-B<dir></code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--prefix</code><code class="descclassname"> <arg></code><code class="descclassname">, </code><code class="descname">--prefix</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-b-dir" 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-arg">
+<code class="descname">-F<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-f-arg" 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">
+<code class="descname">-ObjC</code><code class="descclassname"></code><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">
+<code class="descname">-ObjC++</code><code class="descclassname"></code><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-qn">
+<code class="descname">-Qn</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-ident</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-qn" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Do not emit metadata containing compiler name and version</p>
+<dl class="option">
+<dt id="cmdoption-clang-qunused-arguments">
+<code class="descname">-Qunused-arguments</code><code class="descclassname"></code><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-qy">
+<code class="descname">-Qy</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fident</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-qy" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Emit metadata containing compiler name and version</p>
+<dl class="option">
+<dt id="cmdoption-clang-wa-arg-arg2">
+<code class="descname">-Wa,<arg>,<arg2>...</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-wa-arg-arg2" 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">
+<code class="descname">-Wlarge-by-value-copy</code><code class="descclassname">=<arg></code><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-arg1">
+<code class="descname">-Xarch_<arg1></code><code class="descclassname"> <arg2></code><a class="headerlink" href="#cmdoption-clang-xarch-arg1" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-xcuda-fatbinary">
+<code class="descname">-Xcuda-fatbinary</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-Xcuda-ptxas</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-Xopenmp-target</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-Xopenmp-target</code><code class="descclassname">=<triple> <arg></code><a class="headerlink" href="#cmdoption-clang1-xopenmp-target" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Pass <arg> to the target offloading toolchain identified by <triple>.</p>
+<dl class="option">
+<dt id="cmdoption-clang-z-arg">
+<code class="descname">-Z<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-z-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-a-arg">
+<code class="descname">-a<arg></code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--profile-blocks</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-a-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-all-load">
+<code class="descname">-all_load</code><code class="descclassname"></code><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">
+<code class="descname">-allowable_client</code><code class="descclassname"> <arg></code><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">
+<code class="descname">--analyze</code><code class="descclassname"></code><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">
+<code class="descname">--analyze-auto</code><code class="descclassname"></code><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">
+<code class="descname">--analyzer-no-default-checks</code><code class="descclassname"></code><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-arg">
+<code class="descname">--analyzer-output<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-analyzer-output-arg" 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">
+<code class="descname">-ansi</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--ansi</code><code class="descclassname"></code><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">
+<code class="descname">-arch</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-arch_errors_fatal</code><code class="descclassname"></code><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">
+<code class="descname">-arch_only</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-arcmt-migrate-emit-errors</code><code class="descclassname"></code><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">
+<code class="descname">-arcmt-migrate-report-output</code><code class="descclassname"> <arg></code><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">
+<code class="descname">--autocomplete</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-bind_at_load</code><code class="descclassname"></code><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">
+<code class="descname">-bundle</code><code class="descclassname"></code><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">
+<code class="descname">-bundle_loader</code><code class="descclassname"> <arg></code><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-cfguard">
+<code class="descname">-cfguard</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-cfguard" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Emit tables required for Windows Control Flow Guard.</p>
+<dl class="option">
+<dt id="cmdoption-clang-client-name-arg">
+<code class="descname">-client_name<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-client-name-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-compatibility-version-arg">
+<code class="descname">-compatibility_version<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-compatibility-version-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-config">
+<code class="descname">--config</code><code class="descclassname"> <arg></code><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">
+<code class="descname">--constant-cfstrings</code><code class="descclassname"></code><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">
+<code class="descname">-coverage</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--coverage</code><code class="descclassname"></code><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">
+<code class="descname">--cuda-compile-host-device</code><code class="descclassname"></code><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">
+<code class="descname">--cuda-device-only</code><code class="descclassname"></code><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">
+<code class="descname">--cuda-gpu-arch</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">--no-cuda-gpu-arch</code><code class="descclassname">=<arg></code><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">
+<code class="descname">--cuda-host-only</code><code class="descclassname"></code><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-include-ptx">
+<code class="descname">--cuda-include-ptx</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">--no-cuda-include-ptx</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-cuda-include-ptx" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Include PTX for the follwing GPU architecture (e.g. sm_35) or âallâ. May be specified more than once.</p>
+<dl class="option">
+<dt id="cmdoption-clang-cuda-noopt-device-debug">
+<code class="descname">--cuda-noopt-device-debug</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--no-cuda-noopt-device-debug</code><code class="descclassname"></code><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-arg">
+<code class="descname">-current_version<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-current-version-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-dead-strip">
+<code class="descname">-dead_strip</code><code class="descclassname"></code><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">
+<code class="descname">-dependency-dot</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-dependency-file</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-dumpmachine</code><code class="descclassname"></code><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">
+<code class="descname">-dumpversion</code><code class="descclassname"></code><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">
+<code class="descname">--dyld-prefix</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">--dyld-prefix</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-dylib_file</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-dylinker</code><code class="descclassname"></code><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-arg">
+<code class="descname">-dylinker_install_name<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang1-dylinker-install-name-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-dynamic">
+<code class="descname">-dynamic</code><code class="descclassname"></code><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">
+<code class="descname">-dynamiclib</code><code class="descclassname"></code><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">
+<code class="descname">-emit-ast</code><code class="descclassname"></code><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">
+<code class="descname">-exported_symbols_list</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-faligned-new</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fcuda-approx-transcendentals</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-cuda-approx-transcendentals</code><code class="descclassname"></code><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">
+<code class="descname">-fcuda-flush-denormals-to-zero</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-cuda-flush-denormals-to-zero</code><code class="descclassname"></code><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-fcuda-rdc">
+<code class="descname">-fcuda-rdc</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-cuda-rdc</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-fcuda-rdc" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate relocatable device code, also known as separate compilation mode.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fcuda-short-ptr">
+<code class="descname">-fcuda-short-ptr</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-cuda-short-ptr</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-fcuda-short-ptr" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use 32-bit pointers for accessing const/local/shared address spaces.</p>
+<dl class="option">
+<dt id="cmdoption-clang-ffixed-r19">
+<code class="descname">-ffixed-r19</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-ffixed-r19" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Reserve register r19 (Hexagon only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-fheinous-gnu-extensions">
+<code class="descname">-fheinous-gnu-extensions</code><code class="descclassname"></code><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">
+<code class="descname">-flat_namespace</code><code class="descclassname"></code><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">
+<code class="descname">-fopenmp-targets</code><code class="descclassname">=<arg1>,<arg2>...</code><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">
+<code class="descname">-force_cpusubtype_ALL</code><code class="descclassname"></code><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">
+<code class="descname">-force_flat_namespace</code><code class="descclassname"></code><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">
+<code class="descname">-force_load</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-framework</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-frtlib-add-rpath</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-rtlib-add-rpath</code><code class="descclassname"></code><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">
+<code class="descname">--gcc-toolchain</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">-gcc-toolchain</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-gcodeview</code><code class="descclassname"></code><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-arg">
+<code class="descname">-headerpad_max_install_names<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-headerpad-max-install-names-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-help">
+<code class="descname">-help</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--help</code><code class="descclassname"></code><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">
+<code class="descname">--help-hidden</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-help-hidden" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Display help for hidden options</p>
+<dl class="option">
+<dt id="cmdoption-clang-hip-link">
+<code class="descname">--hip-link</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-hip-link" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Link clang-offload-bundler bundles for HIP</p>
+<dl class="option">
+<dt id="cmdoption-clang-image-base">
+<code class="descname">-image_base</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-index-header-map</code><code class="descclassname"></code><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">
+<code class="descname">-init</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-install_name</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-keep_private_externs</code><code class="descclassname"></code><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">
+<code class="descname">-lazy_framework</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-lazy_library</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-mbig-endian</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-EB</code><code class="descclassname"></code><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">
+<code class="descname">--migrate</code><code class="descclassname"></code><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">
+<code class="descname">-mios-simulator-version-min</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">-miphonesimulator-version-min</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-mlinker-version</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-mlittle-endian</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-EL</code><code class="descclassname"></code><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">
+<code class="descname">-mllvm</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-module-dependency-dir</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-mtvos-simulator-version-min</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">-mappletvsimulator-version-min</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-multi_module</code><code class="descclassname"></code><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">
+<code class="descname">-multiply_defined</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-multiply_defined_unused</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-mwatchos-simulator-version-min</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">-mwatchsimulator-version-min</code><code class="descclassname">=<arg></code><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">
+<code class="descname">--no-cuda-version-check</code><code class="descclassname"></code><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">
+<code class="descname">-no-integrated-cpp</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--no-integrated-cpp</code><code class="descclassname"></code><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">
+<code class="descname">-no_dead_strip_inits_and_terms</code><code class="descclassname"></code><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">
+<code class="descname">-nobuiltininc</code><code class="descclassname"></code><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">
+<code class="descname">-nocudainc</code><code class="descclassname"></code><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">
+<code class="descname">-nocudalib</code><code class="descclassname"></code><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">
+<code class="descname">-nodefaultlibs</code><code class="descclassname"></code><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">
+<code class="descname">-nofixprebinding</code><code class="descclassname"></code><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">
+<code class="descname">-nolibc</code><code class="descclassname"></code><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">
+<code class="descname">-nomultidefs</code><code class="descclassname"></code><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">
+<code class="descname">-nopie</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-no-pie</code><code class="descclassname"></code><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">
+<code class="descname">-noprebind</code><code class="descclassname"></code><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">
+<code class="descname">-noseglinkedit</code><code class="descclassname"></code><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">
+<code class="descname">-nostartfiles</code><code class="descclassname"></code><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">
+<code class="descname">-nostdinc</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--no-standard-includes</code><code class="descclassname"></code><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">
+<code class="descname">-nostdinc++</code><code class="descclassname"></code><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">
+<code class="descname">-nostdlib</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--no-standard-libraries</code><code class="descclassname"></code><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">
+<code class="descname">-nostdlib++</code><code class="descclassname"></code><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">
+<code class="descname">-nostdlibinc</code><code class="descclassname"></code><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-file">
+<code class="descname">-o<file></code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--output</code><code class="descclassname"> <arg></code><code class="descclassname">, </code><code class="descname">--output</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-o-file" 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">
+<code class="descname">-objcmt-atomic-property</code><code class="descclassname"></code><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">
+<code class="descname">-objcmt-migrate-all</code><code class="descclassname"></code><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">
+<code class="descname">-objcmt-migrate-annotation</code><code class="descclassname"></code><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">
+<code class="descname">-objcmt-migrate-designated-init</code><code class="descclassname"></code><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">
+<code class="descname">-objcmt-migrate-instancetype</code><code class="descclassname"></code><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">
+<code class="descname">-objcmt-migrate-literals</code><code class="descclassname"></code><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">
+<code class="descname">-objcmt-migrate-ns-macros</code><code class="descclassname"></code><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">
+<code class="descname">-objcmt-migrate-property</code><code class="descclassname"></code><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">
+<code class="descname">-objcmt-migrate-property-dot-syntax</code><code class="descclassname"></code><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">
+<code class="descname">-objcmt-migrate-protocol-conformance</code><code class="descclassname"></code><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">
+<code class="descname">-objcmt-migrate-readonly-property</code><code class="descclassname"></code><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">
+<code class="descname">-objcmt-migrate-readwrite-property</code><code class="descclassname"></code><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">
+<code class="descname">-objcmt-migrate-subscripting</code><code class="descclassname"></code><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">
+<code class="descname">-objcmt-ns-nonatomic-iosonly</code><code class="descclassname"></code><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">
+<code class="descname">-objcmt-returns-innerpointer-property</code><code class="descclassname"></code><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">
+<code class="descname">-objcmt-whitelist-dir-path</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">-objcmt-white-list-dir-path</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-object</code><code class="descclassname"></code><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">
+<code class="descname">-p</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--profile</code><code class="descclassname"></code><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-arg">
+<code class="descname">-pagezero_size<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-pagezero-size-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-pg">
+<code class="descname">-pg</code><code class="descclassname"></code><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">
+<code class="descname">-pie</code><code class="descclassname"></code><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">
+<code class="descname">-pipe</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--pipe</code><code class="descclassname"></code><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">
+<code class="descname">-prebind</code><code class="descclassname"></code><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">
+<code class="descname">-prebind_all_twolevel_modules</code><code class="descclassname"></code><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">
+<code class="descname">-preload</code><code class="descclassname"></code><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">
+<code class="descname">--print-diagnostic-categories</code><code class="descclassname"></code><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">
+<code class="descname">-print-file-name</code><code class="descclassname">=<file></code><code class="descclassname">, </code><code class="descname">--print-file-name</code><code class="descclassname">=<file></code><code class="descclassname">, </code><code class="descname">--print-file-name</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-print-ivar-layout</code><code class="descclassname"></code><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">
+<code class="descname">-print-libgcc-file-name</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--print-libgcc-file-name</code><code class="descclassname"></code><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">
+<code class="descname">-print-multi-directory</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--print-multi-directory</code><code class="descclassname"></code><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">
+<code class="descname">-print-multi-lib</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--print-multi-lib</code><code class="descclassname"></code><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">
+<code class="descname">-print-prog-name</code><code class="descclassname">=<name></code><code class="descclassname">, </code><code class="descname">--print-prog-name</code><code class="descclassname">=<name></code><code class="descclassname">, </code><code class="descname">--print-prog-name</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-print-resource-dir</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--print-resource-dir</code><code class="descclassname"></code><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">
+<code class="descname">-print-search-dirs</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--print-search-dirs</code><code class="descclassname"></code><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">
+<code class="descname">-private_bundle</code><code class="descclassname"></code><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">
+<code class="descname">-pthread</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-no-pthread</code><code class="descclassname"></code><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">
+<code class="descname">-pthreads</code><code class="descclassname"></code><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">
+<code class="descname">-rdynamic</code><code class="descclassname"></code><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">
+<code class="descname">-read_only_relocs</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-relocatable-pch</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--relocatable-pch</code><code class="descclassname"></code><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">
+<code class="descname">-remap</code><code class="descclassname"></code><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">
+<code class="descname">-rewrite-legacy-objc</code><code class="descclassname"></code><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">
+<code class="descname">-rtlib</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">--rtlib</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">--rtlib</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-save-stats</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">--save-stats</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">-save-stats</code><code class="descclassname"> (equivalent to -save-stats=cwd)</code><code class="descclassname">, </code><code class="descname">--save-stats</code><code class="descclassname"> (equivalent to -save-stats=cwd)</code><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">
+<code class="descname">-save-temps</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">--save-temps</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">-save-temps</code><code class="descclassname"> (equivalent to -save-temps=cwd)</code><code class="descclassname">, </code><code class="descname">--save-temps</code><code class="descclassname"> (equivalent to -save-temps=cwd)</code><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">
+<code class="descname">-sectalign</code><code class="descclassname"> <arg1> <arg2> <arg3></code><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">
+<code class="descname">-sectcreate</code><code class="descclassname"> <arg1> <arg2> <arg3></code><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">
+<code class="descname">-sectobjectsymbols</code><code class="descclassname"> <arg1> <arg2></code><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">
+<code class="descname">-sectorder</code><code class="descclassname"> <arg1> <arg2> <arg3></code><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-arg">
+<code class="descname">-seg1addr<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-seg1addr-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-seg-addr-table">
+<code class="descname">-seg_addr_table</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-seg_addr_table_filename</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-segaddr</code><code class="descclassname"> <arg1> <arg2></code><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">
+<code class="descname">-segcreate</code><code class="descclassname"> <arg1> <arg2> <arg3></code><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">
+<code class="descname">-seglinkedit</code><code class="descclassname"></code><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">
+<code class="descname">-segprot</code><code class="descclassname"> <arg1> <arg2> <arg3></code><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-arg">
+<code class="descname">-segs_read_<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-segs-read-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-segs-read-only-addr">
+<code class="descname">-segs_read_only_addr</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-segs_read_write_addr</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-serialize-diagnostics</code><code class="descclassname"> <arg></code><code class="descclassname">, </code><code class="descname">--serialize-diagnostics</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-shared</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--shared</code><code class="descclassname"></code><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">
+<code class="descname">-shared-libgcc</code><code class="descclassname"></code><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">
+<code class="descname">-shared-libsan</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-shared-libasan</code><code class="descclassname"></code><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">
+<code class="descname">-single_module</code><code class="descclassname"></code><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">
+<code class="descname">-specs</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">--specs</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-static</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--static</code><code class="descclassname"></code><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">
+<code class="descname">-static-libgcc</code><code class="descclassname"></code><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">
+<code class="descname">-static-libsan</code><code class="descclassname"></code><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">
+<code class="descname">-static-libstdc++</code><code class="descclassname"></code><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">
+<code class="descname">-std-default</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-stdlib</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">--stdlib</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">--stdlib</code><code class="descclassname"> <arg></code><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-arg">
+<code class="descname">-sub_library<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-sub-library-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-sub-umbrella-arg">
+<code class="descname">-sub_umbrella<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang1-sub-umbrella-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-sysroot">
+<code class="descname">--sysroot</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">--sysroot</code><code class="descclassname"> <arg></code><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">
+<code class="descname">--target-help</code><code class="descclassname"></code><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">
+<code class="descname">--target</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">-target</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-time</code><code class="descclassname"></code><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">
+<code class="descname">-traditional</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--traditional</code><code class="descclassname"></code><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">
+<code class="descname">-traditional-cpp</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--traditional-cpp</code><code class="descclassname"></code><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">
+<code class="descname">-twolevel_namespace</code><code class="descclassname"></code><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">
+<code class="descname">-twolevel_namespace_hints</code><code class="descclassname"></code><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">
+<code class="descname">-umbrella</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-unexported_symbols_list</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-v</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--verbose</code><code class="descclassname"></code><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">
+<code class="descname">--verify-debug-info</code><code class="descclassname"></code><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">
+<code class="descname">--version</code><code class="descclassname"></code><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">
+<code class="descname">-w</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--no-warnings</code><code class="descclassname"></code><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-arg">
+<code class="descname">-weak-l<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-weak-l-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-weak-framework">
+<code class="descname">-weak_framework</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-weak_library</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-weak_reference_mismatches</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-whatsloaded</code><code class="descclassname"></code><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">
+<code class="descname">-whyload</code><code class="descclassname"></code><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-arg">
+<code class="descname">-working-directory<arg></code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-working-directory</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-working-directory-arg" 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-language">
+<code class="descname">-x<language></code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--language</code><code class="descclassname"> <arg></code><code class="descclassname">, </code><code class="descname">--language</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-x-language" 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-arg">
+<code class="descname">-y<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-y-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+</div>
+<div class="section" id="actions">
+<h2><a class="toc-backref" href="#id5">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">
+<code class="descname">-E</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--preprocess</code><code class="descclassname"></code><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">
+<code class="descname">-S</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--assemble</code><code class="descclassname"></code><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">
+<code class="descname">-c</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--compile</code><code class="descclassname"></code><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">
+<code class="descname">-emit-llvm</code><code class="descclassname"></code><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">
+<code class="descname">-fsyntax-only</code><code class="descclassname"></code><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">
+<code class="descname">-module-file-info</code><code class="descclassname"></code><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">
+<code class="descname">--precompile</code><code class="descclassname"></code><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">
+<code class="descname">-rewrite-objc</code><code class="descclassname"></code><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">
+<code class="descname">-verify-pch</code><code class="descclassname"></code><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="#id6">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">
+<code class="descname">-Xassembler</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-Xclang</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-fclang-abi-compat</code><code class="descclassname">=<version></code><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">
+<code class="descname">-fcomment-block-commands</code><code class="descclassname">=<arg>,<arg2>...</code><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-fcomplete-member-pointers">
+<code class="descname">-fcomplete-member-pointers</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-complete-member-pointers</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-fcomplete-member-pointers" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Require member pointer base types to be complete if they would be significant under the Microsoft ABI</p>
+<dl class="option">
+<dt id="cmdoption-clang-fcrash-diagnostics-dir">
+<code class="descname">-fcrash-diagnostics-dir</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-fcrash-diagnostics-dir" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdeclspec">
+<code class="descname">-fdeclspec</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-declspec</code><code class="descclassname"></code><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">
+<code class="descname">-fdepfile-entry</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fdiagnostics-fixit-info</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-diagnostics-fixit-info</code><code class="descclassname"></code><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">
+<code class="descname">-fdiagnostics-format</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fdiagnostics-parseable-fixits</code><code class="descclassname"></code><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">
+<code class="descname">-fdiagnostics-print-source-range-info</code><code class="descclassname"></code><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">
+<code class="descname">-fdiagnostics-show-category</code><code class="descclassname">=<arg></code><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-fdiscard-value-names">
+<code class="descname">-fdiscard-value-names</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-discard-value-names</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-fdiscard-value-names" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Discard value names in LLVM IR</p>
+<dl class="option">
+<dt id="cmdoption-clang-fexperimental-isel">
+<code class="descname">-fexperimental-isel</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-experimental-isel</code><code class="descclassname"></code><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">
+<code class="descname">-fexperimental-new-pass-manager</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-experimental-new-pass-manager</code><code class="descclassname"></code><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">
+<code class="descname">-ffine-grained-bitfield-accesses</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-fine-grained-bitfield-accesses</code><code class="descclassname"></code><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 consecutive bitfield runs with legal widths and alignments.</p>
+<dl class="option">
+<dt id="cmdoption-clang-finline-functions">
+<code class="descname">-finline-functions</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-inline-functions</code><code class="descclassname"></code><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">
+<code class="descname">-finline-hint-functions</code><code class="descclassname"></code><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">
+<code class="descname">-fno-crash-diagnostics</code><code class="descclassname"></code><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">
+<code class="descname">-fno-sanitize-blacklist</code><code class="descclassname"></code><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">
+<code class="descname">-fparse-all-comments</code><code class="descclassname"></code><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">
+<code class="descname">-fsanitize-address-field-padding</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fsanitize-address-globals-dead-stripping</code><code class="descclassname"></code><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-poison-class-member-array-new-cookie">
+<code class="descname">-fsanitize-address-poison-class-member-array-new-cookie</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-sanitize-address-poison-class-member-array-new-cookie</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-fsanitize-address-poison-class-member-array-new-cookie" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable poisoning array cookies when using class member operator new[] in AddressSanitizer</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-address-use-after-scope">
+<code class="descname">-fsanitize-address-use-after-scope</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-sanitize-address-use-after-scope</code><code class="descclassname"></code><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">
+<code class="descname">-fsanitize-blacklist</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fsanitize-cfi-cross-dso</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-sanitize-cfi-cross-dso</code><code class="descclassname"></code><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">
+<code class="descname">-fsanitize-cfi-icall-generalize-pointers</code><code class="descclassname"></code><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">
+<code class="descname">-fsanitize-coverage</code><code class="descclassname">=<arg1>,<arg2>...</code><code class="descclassname">, </code><code class="descname">-fno-sanitize-coverage</code><code class="descclassname">=<arg1>,<arg2>...</code><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-runtime">
+<code class="descname">-fsanitize-link-c++-runtime</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-fsanitize-link-c-runtime" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-memory-track-origins">
+<code class="descname">-fsanitize-memory-track-origins</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-sanitize-memory-track-origins</code><code class="descclassname"></code><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">
+<code class="descname">-fsanitize-memory-track-origins</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fsanitize-memory-use-after-dtor</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-sanitize-memory-use-after-dtor</code><code class="descclassname"></code><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">
+<code class="descname">-fsanitize-minimal-runtime</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-sanitize-minimal-runtime</code><code class="descclassname"></code><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">
+<code class="descname">-fsanitize-recover</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-sanitize-recover</code><code class="descclassname"></code><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">
+<code class="descname">-fsanitize-recover</code><code class="descclassname">=<arg1>,<arg2>...</code><code class="descclassname">, </code><code class="descname">-fno-sanitize-recover</code><code class="descclassname">=<arg1>,<arg2>...</code><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">
+<code class="descname">-fsanitize-stats</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-sanitize-stats</code><code class="descclassname"></code><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">
+<code class="descname">-fsanitize-thread-atomics</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-sanitize-thread-atomics</code><code class="descclassname"></code><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">
+<code class="descname">-fsanitize-thread-func-entry-exit</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-sanitize-thread-func-entry-exit</code><code class="descclassname"></code><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">
+<code class="descname">-fsanitize-thread-memory-access</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-sanitize-thread-memory-access</code><code class="descclassname"></code><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">
+<code class="descname">-fsanitize-trap</code><code class="descclassname">=<arg1>,<arg2>...</code><code class="descclassname">, </code><code class="descname">-fno-sanitize-trap</code><code class="descclassname">=<arg1>,<arg2>...</code><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">
+<code class="descname">-fsanitize-undefined-strip-path-components</code><code class="descclassname">=<number></code><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">
+<code class="descname">-fsanitize-undefined-trap-on-error</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-sanitize-undefined-trap-on-error</code><code class="descclassname"></code><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">
+<code class="descname">-fsanitize</code><code class="descclassname">=<check>,<arg2>...</code><code class="descclassname">, </code><code class="descname">-fno-sanitize</code><code class="descclassname">=<arg1>,<arg2>...</code><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-moutline">
+<code class="descname">-moutline</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-outline</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-moutline" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable function outlining (AArch64 only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-param">
+<code class="descname">--param</code><code class="descclassname"> <arg></code><code class="descclassname">, </code><code class="descname">--param</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-std</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">--std</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">--std</code><code class="descclassname"> <arg></code><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="#id7">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-comments">
+<code class="descname">-C</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--comments</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-comments" 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">
+<code class="descname">-CC</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--comments-in-macros</code><code class="descclassname"></code><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-macro">
+<code class="descname">-D<macro></code><code class="descclassname">=<value></code><code class="descclassname">, </code><code class="descname">--define-macro</code><code class="descclassname"> <arg></code><code class="descclassname">, </code><code class="descname">--define-macro</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-d-macro" 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">
+<code class="descname">-H</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--trace-includes</code><code class="descclassname"></code><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-no-line-commands">
+<code class="descname">-P</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--no-line-commands</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-no-line-commands" 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-macro">
+<code class="descname">-U<macro></code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--undefine-macro</code><code class="descclassname"> <arg></code><code class="descclassname">, </code><code class="descname">--undefine-macro</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-u-macro" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Undefine macro <macro></p>
+<dl class="option">
+<dt id="cmdoption-clang-wp-arg-arg2">
+<code class="descname">-Wp,<arg>,<arg2>...</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-wp-arg-arg2" 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">
+<code class="descname">-Xpreprocessor</code><code class="descclassname"> <arg></code><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="#id8">Include path management</a><a class="headerlink" href="#include-path-management" title="Permalink to this headline">¶</a></h4>
+<p>Flags controlling how <code class="docutils literal"><span class="pre">#include</span></code>s are resolved to files.</p>
+<dl class="option">
+<dt id="cmdoption-clang-i-dir">
+<code class="descname">-I<dir></code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--include-directory</code><code class="descclassname"> <arg></code><code class="descclassname">, </code><code class="descname">--include-directory</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-i-dir" 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">
+<code class="descname">-I-</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--include-barrier</code><code class="descclassname"></code><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-ignore-env">
+<code class="descname">--cuda-path-ignore-env</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-cuda-path-ignore-env" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Ignore environment variables to detect CUDA installation</p>
+<dl class="option">
+<dt id="cmdoption-clang-cuda-path">
+<code class="descname">--cuda-path</code><code class="descclassname">=<arg></code><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-directory">
+<code class="descname">-cxx-isystem<directory></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-cxx-isystem-directory" 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">
+<code class="descname">-fbuild-session-file</code><code class="descclassname">=<file></code><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">
+<code class="descname">-fbuild-session-timestamp</code><code class="descclassname">=<time since Epoch in seconds></code><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">
+<code class="descname">-fmodule-file</code><code class="descclassname">=[<name>=]<file></code><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">
+<code class="descname">-fmodules-cache-path</code><code class="descclassname">=<directory></code><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">
+<code class="descname">-fmodules-disable-diagnostic-validation</code><code class="descclassname"></code><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">
+<code class="descname">-fmodules-prune-after</code><code class="descclassname">=<seconds></code><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">
+<code class="descname">-fmodules-prune-interval</code><code class="descclassname">=<seconds></code><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">
+<code class="descname">-fmodules-user-build-path</code><code class="descclassname"> <directory></code><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">
+<code class="descname">-fmodules-validate-once-per-build-session</code><code class="descclassname"></code><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">
+<code class="descname">-fmodules-validate-system-headers</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-modules-validate-system-headers</code><code class="descclassname"></code><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">
+<code class="descname">-fprebuilt-module-path</code><code class="descclassname">=<directory></code><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-idirafter-arg">
+<code class="descname">-idirafter<arg></code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--include-directory-after</code><code class="descclassname"> <arg></code><code class="descclassname">, </code><code class="descname">--include-directory-after</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-idirafter-arg" 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-arg">
+<code class="descname">-iframework<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-iframework-arg" 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-directory">
+<code class="descname">-iframeworkwithsysroot<directory></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-iframeworkwithsysroot-directory" 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-file">
+<code class="descname">-imacros<file></code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--imacros<file></code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--imacros</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-imacros-file" 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-file">
+<code class="descname">-include<file></code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--include<file></code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--include</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-include-file" 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">
+<code class="descname">-include-pch</code><code class="descclassname"> <file></code><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-dir">
+<code class="descname">-iprefix<dir></code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--include-prefix</code><code class="descclassname"> <arg></code><code class="descclassname">, </code><code class="descname">--include-prefix</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-iprefix-dir" 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-directory">
+<code class="descname">-iquote<directory></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-iquote-directory" 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-dir">
+<code class="descname">-isysroot<dir></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-isysroot-dir" 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-directory">
+<code class="descname">-isystem<directory></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-isystem-directory" 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-directory">
+<code class="descname">-isystem-after<directory></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-isystem-after-directory" 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-arg">
+<code class="descname">-ivfsoverlay<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-ivfsoverlay-arg" 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-dir">
+<code class="descname">-iwithprefix<dir></code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--include-with-prefix</code><code class="descclassname"> <arg></code><code class="descclassname">, </code><code class="descname">--include-with-prefix-after</code><code class="descclassname"> <arg></code><code class="descclassname">, </code><code class="descname">--include-with-prefix-after</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">--include-with-prefix</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-iwithprefix-dir" 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-dir">
+<code class="descname">-iwithprefixbefore<dir></code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--include-with-prefix-before</code><code class="descclassname"> <arg></code><code class="descclassname">, </code><code class="descname">--include-with-prefix-before</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-iwithprefixbefore-dir" 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-directory">
+<code class="descname">-iwithsysroot<directory></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-iwithsysroot-directory" 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">
+<code class="descname">--ptxas-path</code><code class="descclassname">=<arg></code><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">
+<code class="descname">--system-header-prefix</code><code class="descclassname">=<prefix></code><code class="descclassname">, </code><code class="descname">--no-system-header-prefix</code><code class="descclassname">=<prefix></code><code class="descclassname">, </code><code class="descname">--system-header-prefix</code><code class="descclassname"> <arg></code><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="#id9">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 <code class="docutils literal"><span class="pre">make</span></code>-like build
+systems.</p>
+<dl class="option">
+<dt id="cmdoption-clang-m">
+<code class="descname">-M</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--dependencies</code><code class="descclassname"></code><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">
+<code class="descname">-MD</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--write-dependencies</code><code class="descclassname"></code><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-file">
+<code class="descname">-MF<file></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mf-file" 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">
+<code class="descname">-MG</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--print-missing-file-dependencies</code><code class="descclassname"></code><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-arg">
+<code class="descname">-MJ<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mj-arg" 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">
+<code class="descname">-MM</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--user-dependencies</code><code class="descclassname"></code><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">
+<code class="descname">-MMD</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--write-user-dependencies</code><code class="descclassname"></code><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">
+<code class="descname">-MP</code><code class="descclassname"></code><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-arg">
+<code class="descname">-MQ<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mq-arg" 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-arg">
+<code class="descname">-MT<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mt-arg" 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">
+<code class="descname">-MV</code><code class="descclassname"></code><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="#id10">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">
+<code class="descname">-d</code><code class="descclassname"></code><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-arg">
+<code class="descname">-d<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang1-d-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-da">
+<code class="descname">-dA</code><code class="descclassname"></code><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">
+<code class="descname">-dD</code><code class="descclassname"></code><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">
+<code class="descname">-dI</code><code class="descclassname"></code><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">
+<code class="descname">-dM</code><code class="descclassname"></code><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="#id11">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"><span class="doc">full list of warning and remark flags</span></a>.</p>
+<dl class="option">
+<dt id="cmdoption-clang-r-remark">
+<code class="descname">-R<remark></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-r-remark" 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">
+<code class="descname">-Rpass-analysis</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-Rpass-missed</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-Rpass</code><code class="descclassname">=<arg></code><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-warning">
+<code class="descname">-W<warning></code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--extra-warnings</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--warn-<arg></code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--warn-</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-w-warning" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable the specified warning</p>
+<dl class="option">
+<dt id="cmdoption-clang-wdeprecated">
+<code class="descname">-Wdeprecated</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-Wno-deprecated</code><code class="descclassname"></code><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-arg">
+<code class="descname">-Wnonportable-cfstrings<arg></code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-Wno-nonportable-cfstrings<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-wnonportable-cfstrings-arg" 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="#id12">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">
+<code class="descname">-Wframe-larger-than</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fPIC</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-PIC</code><code class="descclassname"></code><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">
+<code class="descname">-fPIE</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-PIE</code><code class="descclassname"></code><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">
+<code class="descname">-faccess-control</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-access-control</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-faccess-control" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-faddrsig">
+<code class="descname">-faddrsig</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-addrsig</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-faddrsig" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Emit an address-significance table</p>
+<dl class="option">
+<dt id="cmdoption-clang-falign-functions">
+<code class="descname">-falign-functions</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-align-functions</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-falign-functions" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-falign-functions">
+<code class="descname">-falign-functions</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang1-falign-functions" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-faligned-allocation">
+<code class="descname">-faligned-allocation</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-faligned-new</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-aligned-allocation</code><code class="descclassname"></code><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">
+<code class="descname">-fallow-editor-placeholders</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-allow-editor-placeholders</code><code class="descclassname"></code><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">
+<code class="descname">-fallow-unsupported</code><code class="descclassname"></code><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">
+<code class="descname">-faltivec</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-altivec</code><code class="descclassname"></code><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">
+<code class="descname">-fansi-escape-codes</code><code class="descclassname"></code><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">
+<code class="descname">-fapple-kext</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-findirect-virtual-calls</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fterminated-vtables</code><code class="descclassname"></code><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">
+<code class="descname">-fapple-pragma-pack</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-apple-pragma-pack</code><code class="descclassname"></code><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">
+<code class="descname">-fapplication-extension</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-application-extension</code><code class="descclassname"></code><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">
+<code class="descname">-fasm</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-asm</code><code class="descclassname"></code><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">
+<code class="descname">-fasm-blocks</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-asm-blocks</code><code class="descclassname"></code><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">
+<code class="descname">-fassociative-math</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-associative-math</code><code class="descclassname"></code><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">
+<code class="descname">-fassume-sane-operator-new</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-assume-sane-operator-new</code><code class="descclassname"></code><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">
+<code class="descname">-fast</code><code class="descclassname"></code><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">
+<code class="descname">-fastcp</code><code class="descclassname"></code><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">
+<code class="descname">-fastf</code><code class="descclassname"></code><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">
+<code class="descname">-fasynchronous-unwind-tables</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-asynchronous-unwind-tables</code><code class="descclassname"></code><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">
+<code class="descname">-fautolink</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-autolink</code><code class="descclassname"></code><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">
+<code class="descname">-fblocks</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-blocks</code><code class="descclassname"></code><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">
+<code class="descname">-fbootclasspath</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">--bootclasspath</code><code class="descclassname"> <arg></code><code class="descclassname">, </code><code class="descname">--bootclasspath</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fborland-extensions</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-borland-extensions</code><code class="descclassname"></code><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">
+<code class="descname">-fbracket-depth</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fbuiltin</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-builtin</code><code class="descclassname"></code><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">
+<code class="descname">-fbuiltin-module-map</code><code class="descclassname"></code><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">
+<code class="descname">-fcaret-diagnostics</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-caret-diagnostics</code><code class="descclassname"></code><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-fcf-protection">
+<code class="descname">-fcf-protection</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">-fcf-protection</code><code class="descclassname"> (equivalent to -fcf-protection=full)</code><a class="headerlink" href="#cmdoption-clang-fcf-protection" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Instrument control-flow architecture protection. Options: return, branch, full, none.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fchar8-t">
+<code class="descname">-fchar8_t</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-char8_t</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-fchar8-t" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable C++ builtin type char8_t</p>
+<dl class="option">
+<dt id="cmdoption-clang-fclasspath">
+<code class="descname">-fclasspath</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">--CLASSPATH</code><code class="descclassname"> <arg></code><code class="descclassname">, </code><code class="descname">--CLASSPATH</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">--classpath</code><code class="descclassname"> <arg></code><code class="descclassname">, </code><code class="descname">--classpath</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fcolor-diagnostics</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-color-diagnostics</code><code class="descclassname"></code><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">
+<code class="descname">-fcommon</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-common</code><code class="descclassname"></code><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">
+<code class="descname">-fcompile-resource</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">--resource</code><code class="descclassname"> <arg></code><code class="descclassname">, </code><code class="descname">--resource</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fconstant-cfstrings</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-constant-cfstrings</code><code class="descclassname"></code><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">
+<code class="descname">-fconstant-string-class</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fconstexpr-backtrace-limit</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fconstexpr-depth</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fconstexpr-steps</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fcoroutines-ts</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-coroutines-ts</code><code class="descclassname"></code><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">
+<code class="descname">-fcoverage-mapping</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-coverage-mapping</code><code class="descclassname"></code><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">
+<code class="descname">-fcreate-profile</code><code class="descclassname"></code><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">
+<code class="descname">-fcxx-exceptions</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-cxx-exceptions</code><code class="descclassname"></code><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">
+<code class="descname">-fcxx-modules</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-cxx-modules</code><code class="descclassname"></code><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">
+<code class="descname">-fdata-sections</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-data-sections</code><code class="descclassname"></code><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">
+<code class="descname">-fdebug-info-for-profiling</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-debug-info-for-profiling</code><code class="descclassname"></code><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">
+<code class="descname">-fdebug-macro</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-debug-macro</code><code class="descclassname"></code><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">
+<code class="descname">-fdebug-pass-arguments</code><code class="descclassname"></code><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">
+<code class="descname">-fdebug-pass-structure</code><code class="descclassname"></code><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">
+<code class="descname">-fdebug-prefix-map</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fdebug-types-section</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-debug-types-section</code><code class="descclassname"></code><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">
+<code class="descname">-fdelayed-template-parsing</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-delayed-template-parsing</code><code class="descclassname"></code><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-fdelete-null-pointer-checks">
+<code class="descname">-fdelete-null-pointer-checks</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-delete-null-pointer-checks</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-fdelete-null-pointer-checks" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Treat usage of null pointers as undefined behavior.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdenormal-fp-math">
+<code class="descname">-fdenormal-fp-math</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fdiagnostics-absolute-paths</code><code class="descclassname"></code><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">
+<code class="descname">-fdiagnostics-color</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-diagnostics-color</code><code class="descclassname"></code><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">
+<code class="descname">-fdiagnostics-color</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fdiagnostics-hotness-threshold</code><code class="descclassname">=<number></code><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">
+<code class="descname">-fdiagnostics-show-hotness</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-diagnostics-show-hotness</code><code class="descclassname"></code><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">
+<code class="descname">-fdiagnostics-show-note-include-stack</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-diagnostics-show-note-include-stack</code><code class="descclassname"></code><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">
+<code class="descname">-fdiagnostics-show-option</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-diagnostics-show-option</code><code class="descclassname"></code><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">
+<code class="descname">-fdiagnostics-show-template-tree</code><code class="descclassname"></code><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-fdigraphs">
+<code class="descname">-fdigraphs</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-digraphs</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-fdigraphs" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable alternative token representations â<:â, â:>â, â<%â, â%>â, â%:â, â%:%:â (default)</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdollars-in-identifiers">
+<code class="descname">-fdollars-in-identifiers</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-dollars-in-identifiers</code><code class="descclassname"></code><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">
+<code class="descname">-fdouble-square-bracket-attributes</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-double-square-bracket-attributes</code><code class="descclassname"></code><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">
+<code class="descname">-fdwarf-directory-asm</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-dwarf-directory-asm</code><code class="descclassname"></code><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">
+<code class="descname">-fdwarf-exceptions</code><code class="descclassname"></code><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">
+<code class="descname">-felide-constructors</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-elide-constructors</code><code class="descclassname"></code><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">
+<code class="descname">-feliminate-unused-debug-symbols</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-eliminate-unused-debug-symbols</code><code class="descclassname"></code><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">
+<code class="descname">-fembed-bitcode</code><code class="descclassname">=<option></code><code class="descclassname">, </code><code class="descname">-fembed-bitcode</code><code class="descclassname"> (equivalent to -fembed-bitcode=all)</code><code class="descclassname">, </code><code class="descname">-fembed-bitcode-marker</code><code class="descclassname"> (equivalent to -fembed-bitcode=marker)</code><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">
+<code class="descname">-femit-all-decls</code><code class="descclassname"></code><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">
+<code class="descname">-femulated-tls</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-emulated-tls</code><code class="descclassname"></code><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">
+<code class="descname">-fencoding</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">--encoding</code><code class="descclassname"> <arg></code><code class="descclassname">, </code><code class="descname">--encoding</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-ferror-limit</code><code class="descclassname">=<arg></code><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-fescaping-block-tail-calls">
+<code class="descname">-fescaping-block-tail-calls</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-escaping-block-tail-calls</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-fescaping-block-tail-calls" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fexceptions">
+<code class="descname">-fexceptions</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-exceptions</code><code class="descclassname"></code><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">
+<code class="descname">-fexec-charset</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fextdirs</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">--extdirs</code><code class="descclassname"> <arg></code><code class="descclassname">, </code><code class="descname">--extdirs</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-ffast-math</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-fast-math</code><code class="descclassname"></code><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">
+<code class="descname">-ffinite-math-only</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-finite-math-only</code><code class="descclassname"></code><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-ffixed-point">
+<code class="descname">-ffixed-point</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-fixed-point</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-ffixed-point" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable fixed point types</p>
+<dl class="option">
+<dt id="cmdoption-clang-ffor-scope">
+<code class="descname">-ffor-scope</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-for-scope</code><code class="descclassname"></code><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-fforce-emit-vtables">
+<code class="descname">-fforce-emit-vtables</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-force-emit-vtables</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-fforce-emit-vtables" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Emits more virtual tables to improve devirtualization</p>
+<dl class="option">
+<dt id="cmdoption-clang-fforce-enable-int128">
+<code class="descname">-fforce-enable-int128</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-force-enable-int128</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-fforce-enable-int128" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable support for int128_t type</p>
+<dl class="option">
+<dt id="cmdoption-clang-ffp-contract">
+<code class="descname">-ffp-contract</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-ffreestanding</code><code class="descclassname"></code><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">
+<code class="descname">-ffunction-sections</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-function-sections</code><code class="descclassname"></code><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">
+<code class="descname">-fgnu-inline-asm</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-gnu-inline-asm</code><code class="descclassname"></code><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">
+<code class="descname">-fgnu-keywords</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-gnu-keywords</code><code class="descclassname"></code><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">
+<code class="descname">-fgnu-runtime</code><code class="descclassname"></code><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">
+<code class="descname">-fgnu89-inline</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-gnu89-inline</code><code class="descclassname"></code><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">
+<code class="descname">-fhonor-infinities</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fhonor-infinites</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-honor-infinities</code><code class="descclassname"></code><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">
+<code class="descname">-fhonor-nans</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-honor-nans</code><code class="descclassname"></code><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">
+<code class="descname">-fhosted</code><code class="descclassname"></code><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">
+<code class="descname">-fimplicit-module-maps</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fmodule-maps</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-implicit-module-maps</code><code class="descclassname"></code><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">
+<code class="descname">-fimplicit-modules</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-implicit-modules</code><code class="descclassname"></code><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">
+<code class="descname">-finput-charset</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-finstrument-function-entry-bare</code><code class="descclassname"></code><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">
+<code class="descname">-finstrument-functions</code><code class="descclassname"></code><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">
+<code class="descname">-finstrument-functions-after-inlining</code><code class="descclassname"></code><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">
+<code class="descname">-fintegrated-as</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-integrated-as</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-integrated-as</code><code class="descclassname"></code><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">
+<code class="descname">-fjump-tables</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-jump-tables</code><code class="descclassname"></code><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">
+<code class="descname">-flax-vector-conversions</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-lax-vector-conversions</code><code class="descclassname"></code><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">
+<code class="descname">-flimited-precision</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-flto</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-lto</code><code class="descclassname"></code><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">
+<code class="descname">-flto-jobs</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-flto</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fmacro-backtrace-limit</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fmath-errno</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-math-errno</code><code class="descclassname"></code><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">
+<code class="descname">-fmax-type-align</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fmerge-all-constants</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-merge-all-constants</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-fmerge-all-constants" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Allow merging of constants</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmessage-length">
+<code class="descname">-fmessage-length</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fmodule-file-deps</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-module-file-deps</code><code class="descclassname"></code><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">
+<code class="descname">-fmodule-map-file</code><code class="descclassname">=<file></code><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">
+<code class="descname">-fmodule-name</code><code class="descclassname">=<name></code><code class="descclassname">, </code><code class="descname">-fmodule-implementation-of</code><code class="descclassname"> <arg></code><code class="descclassname">, </code><code class="descname">-fmodule-name</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-fmodules</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-modules</code><code class="descclassname"></code><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">
+<code class="descname">-fmodules-decluse</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-modules-decluse</code><code class="descclassname"></code><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">
+<code class="descname">-fmodules-ignore-macro</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fmodules-search-all</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-modules-search-all</code><code class="descclassname"></code><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">
+<code class="descname">-fmodules-strict-decluse</code><code class="descclassname"></code><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">
+<code class="descname">-fmodules-ts</code><code class="descclassname"></code><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">
+<code class="descname">-fms-compatibility</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-ms-compatibility</code><code class="descclassname"></code><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">
+<code class="descname">-fms-compatibility-version</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fms-extensions</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-ms-extensions</code><code class="descclassname"></code><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">
+<code class="descname">-fms-memptr-rep</code><code class="descclassname">=<arg></code><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-arg">
+<code class="descname">-fms-volatile<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-fms-volatile-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fmsc-version">
+<code class="descname">-fmsc-version</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fmudflap</code><code class="descclassname"></code><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">
+<code class="descname">-fmudflapth</code><code class="descclassname"></code><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">
+<code class="descname">-fnested-functions</code><code class="descclassname"></code><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">
+<code class="descname">-fnew-alignment</code><code class="descclassname">=<align></code><code class="descclassname">, </code><code class="descname">-fnew-alignment</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-fnext-runtime</code><code class="descclassname"></code><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-arg">
+<code class="descname">-fno-builtin-<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-fno-builtin-arg" 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">
+<code class="descname">-fno-elide-type</code><code class="descclassname"></code><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">
+<code class="descname">-fno-max-type-align</code><code class="descclassname"></code><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">
+<code class="descname">-fno-operator-names</code><code class="descclassname"></code><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-rtti-data">
+<code class="descname">-fno-rtti-data</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-fno-rtti-data" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Control emission of RTTI data</p>
+<dl class="option">
+<dt id="cmdoption-clang-fno-strict-modules-decluse">
+<code class="descname">-fno-strict-modules-decluse</code><code class="descclassname"></code><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">
+<code class="descname">-fno-working-directory</code><code class="descclassname"></code><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-fnoxray-link-deps">
+<code class="descname">-fnoxray-link-deps</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-fnoxray-link-deps" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fobjc-abi-version">
+<code class="descname">-fobjc-abi-version</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fobjc-arc</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-objc-arc</code><code class="descclassname"></code><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">
+<code class="descname">-fobjc-arc-exceptions</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-objc-arc-exceptions</code><code class="descclassname"></code><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">
+<code class="descname">-fobjc-exceptions</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-objc-exceptions</code><code class="descclassname"></code><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">
+<code class="descname">-fobjc-infer-related-result-type</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-objc-infer-related-result-type</code><code class="descclassname"></code><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">
+<code class="descname">-fobjc-legacy-dispatch</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-objc-legacy-dispatch</code><code class="descclassname"></code><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">
+<code class="descname">-fobjc-link-runtime</code><code class="descclassname"></code><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">
+<code class="descname">-fobjc-nonfragile-abi</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-objc-nonfragile-abi</code><code class="descclassname"></code><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">
+<code class="descname">-fobjc-nonfragile-abi-version</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fobjc-runtime</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fobjc-sender-dependent-dispatch</code><code class="descclassname"></code><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">
+<code class="descname">-fobjc-weak</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-objc-weak</code><code class="descclassname"></code><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">
+<code class="descname">-fomit-frame-pointer</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-omit-frame-pointer</code><code class="descclassname"></code><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">
+<code class="descname">-fopenmp</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-openmp</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-fopenmp" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Parse OpenMP pragmas and generate parallel code.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fopenmp-simd">
+<code class="descname">-fopenmp-simd</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-openmp-simd</code><code class="descclassname"></code><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-version">
+<code class="descname">-fopenmp-version</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fopenmp</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-foperator-arrow-depth</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-foptimization-record-file</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-foptimize-sibling-calls</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-optimize-sibling-calls</code><code class="descclassname"></code><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">
+<code class="descname">-foutput-class-dir</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">--output-class-directory</code><code class="descclassname"> <arg></code><code class="descclassname">, </code><code class="descname">--output-class-directory</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fpack-struct</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-pack-struct</code><code class="descclassname"></code><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">
+<code class="descname">-fpack-struct</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fpascal-strings</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-pascal-strings</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mpascal-strings</code><code class="descclassname"></code><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">
+<code class="descname">-fpcc-struct-return</code><code class="descclassname"></code><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">
+<code class="descname">-fpch-preprocess</code><code class="descclassname"></code><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-fno-pic">
+<code class="descname">-fpic</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-pic</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-fno-pic" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fno-pie">
+<code class="descname">-fpie</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-pie</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-fno-pie" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fplt">
+<code class="descname">-fplt</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-plt</code><code class="descclassname"></code><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">
+<code class="descname">-fplugin</code><code class="descclassname">=<dsopath></code><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">
+<code class="descname">-fpreserve-as-comments</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-preserve-as-comments</code><code class="descclassname"></code><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">
+<code class="descname">-fprofile-arcs</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-profile-arcs</code><code class="descclassname"></code><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">
+<code class="descname">-fprofile-dir</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fprofile-generate</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-profile-generate</code><code class="descclassname"></code><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">
+<code class="descname">-fprofile-generate</code><code class="descclassname">=<directory></code><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">
+<code class="descname">-fprofile-instr-generate</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-profile-instr-generate</code><code class="descclassname"></code><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">
+<code class="descname">-fprofile-instr-generate</code><code class="descclassname">=<file></code><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">
+<code class="descname">-fprofile-instr-use</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-profile-instr-use</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fprofile-use</code><code class="descclassname"></code><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">
+<code class="descname">-fprofile-instr-use</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fprofile-sample-accurate</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fauto-profile-accurate</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-profile-sample-accurate</code><code class="descclassname"></code><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">
+<code class="descname">-fprofile-sample-use</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fauto-profile</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-profile-sample-use</code><code class="descclassname"></code><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">
+<code class="descname">-fprofile-sample-use</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">-fauto-profile</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fprofile-use</code><code class="descclassname">=<pathname></code><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">
+<code class="descname">-freciprocal-math</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-reciprocal-math</code><code class="descclassname"></code><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">
+<code class="descname">-freg-struct-return</code><code class="descclassname"></code><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-fregister-global-dtors-with-atexit">
+<code class="descname">-fregister-global-dtors-with-atexit</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-register-global-dtors-with-atexit</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-fregister-global-dtors-with-atexit" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Use atexit or __cxa_atexit to register global destructors</p>
+<dl class="option">
+<dt id="cmdoption-clang-frelaxed-template-template-args">
+<code class="descname">-frelaxed-template-template-args</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-relaxed-template-template-args</code><code class="descclassname"></code><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">
+<code class="descname">-freroll-loops</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-reroll-loops</code><code class="descclassname"></code><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">
+<code class="descname">-fretain-comments-from-system-headers</code><code class="descclassname"></code><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">
+<code class="descname">-frewrite-imports</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-rewrite-imports</code><code class="descclassname"></code><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">
+<code class="descname">-frewrite-includes</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-rewrite-includes</code><code class="descclassname"></code><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">
+<code class="descname">-frewrite-map-file</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-frewrite-map-file</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fropi</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-ropi</code><code class="descclassname"></code><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">
+<code class="descname">-frtti</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-rtti</code><code class="descclassname"></code><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">
+<code class="descname">-frwpi</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-rwpi</code><code class="descclassname"></code><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">
+<code class="descname">-fsave-optimization-record</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-save-optimization-record</code><code class="descclassname"></code><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">
+<code class="descname">-fseh-exceptions</code><code class="descclassname"></code><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">
+<code class="descname">-fshort-enums</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-short-enums</code><code class="descclassname"></code><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">
+<code class="descname">-fshort-wchar</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-short-wchar</code><code class="descclassname"></code><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">
+<code class="descname">-fshow-column</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-show-column</code><code class="descclassname"></code><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">
+<code class="descname">-fshow-overloads</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fshow-source-location</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-show-source-location</code><code class="descclassname"></code><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">
+<code class="descname">-fsignaling-math</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-signaling-math</code><code class="descclassname"></code><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">
+<code class="descname">-fsigned-bitfields</code><code class="descclassname"></code><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">
+<code class="descname">-fsigned-char</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-signed-char</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--signed-char</code><code class="descclassname"></code><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">
+<code class="descname">-fsigned-zeros</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-signed-zeros</code><code class="descclassname"></code><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">
+<code class="descname">-fsized-deallocation</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-sized-deallocation</code><code class="descclassname"></code><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">
+<code class="descname">-fsjlj-exceptions</code><code class="descclassname"></code><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">
+<code class="descname">-fslp-vectorize</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-slp-vectorize</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-ftree-slp-vectorize</code><code class="descclassname"></code><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">
+<code class="descname">-fspell-checking</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-spell-checking</code><code class="descclassname"></code><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">
+<code class="descname">-fspell-checking-limit</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fsplit-dwarf-inlining</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-split-dwarf-inlining</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-fsplit-dwarf-inlining" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Provide minimal debug info in the object/executable to facilitate online symbolication/stack traces in the absence of .dwo/.dwp files when using Split DWARF</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsplit-stack">
+<code class="descname">-fsplit-stack</code><code class="descclassname"></code><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">
+<code class="descname">-fstack-protector</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-stack-protector</code><code class="descclassname"></code><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">
+<code class="descname">-fstack-protector-all</code><code class="descclassname"></code><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">
+<code class="descname">-fstack-protector-strong</code><code class="descclassname"></code><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-fstack-size-section">
+<code class="descname">-fstack-size-section</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-stack-size-section</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-fstack-size-section" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Emit section containing metadata on function stack sizes</p>
+<dl class="option">
+<dt id="cmdoption-clang-fstandalone-debug">
+<code class="descname">-fstandalone-debug</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-limit-debug-info</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-standalone-debug</code><code class="descclassname"></code><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">
+<code class="descname">-fstrict-aliasing</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-strict-aliasing</code><code class="descclassname"></code><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">
+<code class="descname">-fstrict-enums</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-strict-enums</code><code class="descclassname"></code><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-float-cast-overflow">
+<code class="descname">-fstrict-float-cast-overflow</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-strict-float-cast-overflow</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-fstrict-float-cast-overflow" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Assume that overflowing float-to-int casts are undefined (default)</p>
+<dl class="option">
+<dt id="cmdoption-clang-fstrict-overflow">
+<code class="descname">-fstrict-overflow</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-strict-overflow</code><code class="descclassname"></code><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">
+<code class="descname">-fstrict-return</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-strict-return</code><code class="descclassname"></code><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">
+<code class="descname">-fstrict-vtable-pointers</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-strict-vtable-pointers</code><code class="descclassname"></code><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">
+<code class="descname">-fstruct-path-tbaa</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-struct-path-tbaa</code><code class="descclassname"></code><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">
+<code class="descname">-ftabstop</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-ftemplate-backtrace-limit</code><code class="descclassname">=<arg></code><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-arg">
+<code class="descname">-ftemplate-depth-<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-ftemplate-depth-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ftemplate-depth">
+<code class="descname">-ftemplate-depth</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-ftest-coverage</code><code class="descclassname"></code><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">
+<code class="descname">-fthinlto-index</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fthreadsafe-statics</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-threadsafe-statics</code><code class="descclassname"></code><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">
+<code class="descname">-ftime-report</code><code class="descclassname"></code><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">
+<code class="descname">-ftls-model</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-ftrap-function</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-ftrapping-math</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-trapping-math</code><code class="descclassname"></code><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">
+<code class="descname">-ftrapv</code><code class="descclassname"></code><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">
+<code class="descname">-ftrapv-handler</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-ftrapv-handler</code><code class="descclassname">=<function name></code><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">
+<code class="descname">-ftrigraphs</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-trigraphs</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-trigraphs</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--trigraphs</code><code class="descclassname"></code><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">
+<code class="descname">-funique-section-names</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-unique-section-names</code><code class="descclassname"></code><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">
+<code class="descname">-funit-at-a-time</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-unit-at-a-time</code><code class="descclassname"></code><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">
+<code class="descname">-funroll-loops</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-unroll-loops</code><code class="descclassname"></code><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">
+<code class="descname">-funsafe-math-optimizations</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-unsafe-math-optimizations</code><code class="descclassname"></code><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">
+<code class="descname">-funsigned-bitfields</code><code class="descclassname"></code><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">
+<code class="descname">-funsigned-char</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-unsigned-char</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--unsigned-char</code><code class="descclassname"></code><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">
+<code class="descname">-funwind-tables</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-unwind-tables</code><code class="descclassname"></code><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">
+<code class="descname">-fuse-cxa-atexit</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-use-cxa-atexit</code><code class="descclassname"></code><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">
+<code class="descname">-fuse-init-array</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-use-init-array</code><code class="descclassname"></code><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">
+<code class="descname">-fuse-ld</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fuse-line-directives</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-use-line-directives</code><code class="descclassname"></code><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">
+<code class="descname">-fveclib</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fvectorize</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-vectorize</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-ftree-vectorize</code><code class="descclassname"></code><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">
+<code class="descname">-fverbose-asm</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-verbose-asm</code><code class="descclassname"></code><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">
+<code class="descname">-fvisibility-inlines-hidden</code><code class="descclassname"></code><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 hidden visibility by default</p>
+<dl class="option">
+<dt id="cmdoption-clang-fvisibility-ms-compat">
+<code class="descname">-fvisibility-ms-compat</code><code class="descclassname"></code><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">
+<code class="descname">-fvisibility</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fwhole-program-vtables</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-whole-program-vtables</code><code class="descclassname"></code><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">
+<code class="descname">-fwrapv</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-wrapv</code><code class="descclassname"></code><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">
+<code class="descname">-fwritable-strings</code><code class="descclassname"></code><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">
+<code class="descname">-fxray-always-emit-customevents</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-xray-always-emit-customevents</code><code class="descclassname"></code><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-emit-typedevents">
+<code class="descname">-fxray-always-emit-typedevents</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-xray-always-emit-typedevents</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-fxray-always-emit-typedevents" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Determine whether to always emit __xray_typedevent(â¦) calls even if the function it appears in is not always instrumented.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fxray-always-instrument">
+<code class="descname">-fxray-always-instrument</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-fxray-always-instrument" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>DEPRECATED: Filename defining the whitelist for imbuing the âalways instrumentâ XRay attribute.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fxray-attr-list">
+<code class="descname">-fxray-attr-list</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-fxray-attr-list" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Filename defining the list of functions/types for imbuing XRay attributes.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fxray-instruction-threshold-arg">
+<code class="descname">-fxray-instruction-threshold<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-fxray-instruction-threshold-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-fxray-instruction-threshold">
+<code class="descname">-fxray-instruction-threshold</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fxray-instrument</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-xray-instrument</code><code class="descclassname"></code><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-instrumentation-bundle">
+<code class="descname">-fxray-instrumentation-bundle</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-fxray-instrumentation-bundle" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Select which XRay instrumentation points to emit. Options: all, none, function, custom. Default is âallâ.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fxray-link-deps">
+<code class="descname">-fxray-link-deps</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-fxray-link-deps" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Tells clang to add the link dependencies for XRay.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fxray-modes">
+<code class="descname">-fxray-modes</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-fxray-modes" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>List of modes to link in by default into XRay instrumented binaries.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fxray-never-instrument">
+<code class="descname">-fxray-never-instrument</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-fxray-never-instrument" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>DEPRECATED: Filename defining the whitelist for imbuing the ânever instrumentâ XRay attribute.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fzero-initialized-in-bss">
+<code class="descname">-fzero-initialized-in-bss</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-zero-initialized-in-bss</code><code class="descclassname"></code><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">
+<code class="descname">-fzvector</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-zvector</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mzvector</code><code class="descclassname"></code><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">
+<code class="descname">-pedantic</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--pedantic</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-no-pedantic</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--no-pedantic</code><code class="descclassname"></code><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">
+<code class="descname">-pedantic-errors</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--pedantic-errors</code><code class="descclassname"></code><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="#id13">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">
+<code class="descname">-cl-denorms-are-zero</code><code class="descclassname"></code><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">
+<code class="descname">-cl-fast-relaxed-math</code><code class="descclassname"></code><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">
+<code class="descname">-cl-finite-math-only</code><code class="descclassname"></code><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">
+<code class="descname">-cl-fp32-correctly-rounded-divide-sqrt</code><code class="descclassname"></code><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">
+<code class="descname">-cl-kernel-arg-info</code><code class="descclassname"></code><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">
+<code class="descname">-cl-mad-enable</code><code class="descclassname"></code><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">
+<code class="descname">-cl-no-signed-zeros</code><code class="descclassname"></code><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">
+<code class="descname">-cl-opt-disable</code><code class="descclassname"></code><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">
+<code class="descname">-cl-single-precision-constant</code><code class="descclassname"></code><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">
+<code class="descname">-cl-std</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-cl-strict-aliasing</code><code class="descclassname"></code><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-uniform-work-group-size">
+<code class="descname">-cl-uniform-work-group-size</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-cl-uniform-work-group-size" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>OpenCL only. Defines that the global work-size be a multiple of the work-group size specified to clEnqueueNDRangeKernel</p>
+<dl class="option">
+<dt id="cmdoption-clang-cl-unsafe-math-optimizations">
+<code class="descname">-cl-unsafe-math-optimizations</code><code class="descclassname"></code><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="#id14">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-size">
+<code class="descname">-G<size></code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-G</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">-msmall-data-threshold</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-g-size" 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">
+<code class="descname">-m16</code><code class="descclassname"></code><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">
+<code class="descname">-m32</code><code class="descclassname"></code><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">
+<code class="descname">-m64</code><code class="descclassname"></code><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">
+<code class="descname">-mabi</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-mabi" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-malign-double">
+<code class="descname">-malign-double</code><code class="descclassname"></code><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">
+<code class="descname">-march</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-masm</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-mbackchain</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-backchain</code><code class="descclassname"></code><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-mcmodel">
+<code class="descname">-mcmodel</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-mcmodel" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mconsole-arg">
+<code class="descname">-mconsole<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mconsole-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mcpu">
+<code class="descname">-mcpu</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">-mv4</code><code class="descclassname"> (equivalent to -mcpu=hexagonv4)</code><code class="descclassname">, </code><code class="descname">-mv5</code><code class="descclassname"> (equivalent to -mcpu=hexagonv5)</code><code class="descclassname">, </code><code class="descname">-mv55</code><code class="descclassname"> (equivalent to -mcpu=hexagonv55)</code><code class="descclassname">, </code><code class="descname">-mv60</code><code class="descclassname"> (equivalent to -mcpu=hexagonv60)</code><code class="descclassname">, </code><code class="descname">-mv62</code><code class="descclassname"> (equivalent to -mcpu=hexagonv62)</code><code class="descclassname">, </code><code class="descname">-mv65</code><code class="descclassname"> (equivalent to -mcpu=hexagonv65)</code><a class="headerlink" href="#cmdoption-clang-mcpu" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mcrc">
+<code class="descname">-mcrc</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-crc</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mcrc" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Allow use of CRC instructions (ARM/Mips only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mdefault-build-attributes-arg">
+<code class="descname">-mdefault-build-attributes<arg></code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-default-build-attributes<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mdefault-build-attributes-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mdll-arg">
+<code class="descname">-mdll<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mdll-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mdynamic-no-pic-arg">
+<code class="descname">-mdynamic-no-pic<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mdynamic-no-pic-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-meabi">
+<code class="descname">-meabi</code><code class="descclassname"> <arg></code><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-mfentry">
+<code class="descname">-mfentry</code><code class="descclassname"></code><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">
+<code class="descname">-mfloat-abi</code><code class="descclassname">=<arg></code><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-mfpmath">
+<code class="descname">-mfpmath</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-mfpu</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-mglobal-merge</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-global-merge</code><code class="descclassname"></code><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-mhard-float">
+<code class="descname">-mhard-float</code><code class="descclassname"></code><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">
+<code class="descname">-mhwdiv</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">--mhwdiv</code><code class="descclassname"> <arg></code><code class="descclassname">, </code><code class="descname">--mhwdiv</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-miamcu</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-iamcu</code><code class="descclassname"></code><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">
+<code class="descname">-mimplicit-float</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-implicit-float</code><code class="descclassname"></code><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">
+<code class="descname">-mimplicit-it</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-mincremental-linker-compatible</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-incremental-linker-compatible</code><code class="descclassname"></code><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">
+<code class="descname">-miphoneos-version-min</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">-mios-version-min</code><code class="descclassname">=<arg></code><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-mkernel">
+<code class="descname">-mkernel</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mkernel" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mlong-calls">
+<code class="descname">-mlong-calls</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-long-calls</code><code class="descclassname"></code><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">
+<code class="descname">-mmacosx-version-min</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">-mmacos-version-min</code><code class="descclassname">=<arg></code><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-mmcu">
+<code class="descname">-mmcu</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-mmcu" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mms-bitfields">
+<code class="descname">-mms-bitfields</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-ms-bitfields</code><code class="descclassname"></code><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-momit-leaf-frame-pointer">
+<code class="descname">-momit-leaf-frame-pointer</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-omit-leaf-frame-pointer</code><code class="descclassname"></code><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">
+<code class="descname">-moslib</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-mpie-copy-relocations</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-pie-copy-relocations</code><code class="descclassname"></code><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">
+<code class="descname">-mprefer-vector-width</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-mqdsp6-compat</code><code class="descclassname"></code><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">
+<code class="descname">-mrecip</code><code class="descclassname"></code><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">
+<code class="descname">-mrecip</code><code class="descclassname">=<arg1>,<arg2>...</code><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">
+<code class="descname">-mred-zone</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-red-zone</code><code class="descclassname"></code><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">
+<code class="descname">-mregparm</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-mrelax-all</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-relax-all</code><code class="descclassname"></code><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">
+<code class="descname">-mrtd</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-rtd</code><code class="descclassname"></code><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-msoft-float">
+<code class="descname">-msoft-float</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-soft-float</code><code class="descclassname"></code><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">
+<code class="descname">-mstack-alignment</code><code class="descclassname">=<arg></code><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-arg-probe">
+<code class="descname">-mstack-arg-probe</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-stack-arg-probe</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mstack-arg-probe" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable stack probes</p>
+<dl class="option">
+<dt id="cmdoption-clang-mstack-probe-size">
+<code class="descname">-mstack-probe-size</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-mstackrealign</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-stackrealign</code><code class="descclassname"></code><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">
+<code class="descname">-mthread-model</code><code class="descclassname"> <arg></code><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-arg">
+<code class="descname">-mthreads<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mthreads-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mthumb">
+<code class="descname">-mthumb</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-thumb</code><code class="descclassname"></code><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">
+<code class="descname">-mtune</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-mtvos-version-min</code><code class="descclassname">=<arg></code><code class="descclassname">, </code><code class="descname">-mappletvos-version-min</code><code class="descclassname">=<arg></code><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-arg">
+<code class="descname">-municode<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-municode-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mvx">
+<code class="descname">-mvx</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-vx</code><code class="descclassname"></code><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">
+<code class="descname">-mwarn-nonportable-cfstrings</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-warn-nonportable-cfstrings</code><code class="descclassname"></code><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">
+<code class="descname">-mwatchos-version-min</code><code class="descclassname">=<arg></code><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-arg">
+<code class="descname">-mwindows<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mwindows-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mx32">
+<code class="descname">-mx32</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mx32" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<div class="section" id="aarch64">
+<h4><a class="toc-backref" href="#id15">AARCH64</a><a class="headerlink" href="#aarch64" title="Permalink to this headline">¶</a></h4>
+<dl class="option">
+<dt id="cmdoption-clang-ffixed-x18">
+<code class="descname">-ffixed-x18</code><code class="descclassname"></code><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-ffixed-x20">
+<code class="descname">-ffixed-x20</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-ffixed-x20" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Reserve the x20 register (AArch64 only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mfix-cortex-a53-835769">
+<code class="descname">-mfix-cortex-a53-835769</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-fix-cortex-a53-835769</code><code class="descclassname"></code><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">
+<code class="descname">-mgeneral-regs-only</code><code class="descclassname"></code><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="#id16">AMDGPU</a><a class="headerlink" href="#amdgpu" title="Permalink to this headline">¶</a></h4>
+<dl class="option">
+<dt id="cmdoption-clang-mxnack">
+<code class="descname">-mxnack</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-xnack</code><code class="descclassname"></code><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="#id17">ARM</a><a class="headerlink" href="#arm" title="Permalink to this headline">¶</a></h4>
+<dl class="option">
+<dt id="cmdoption-clang-ffixed-r9">
+<code class="descname">-ffixed-r9</code><code class="descclassname"></code><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-mexecute-only">
+<code class="descname">-mexecute-only</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-execute-only</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mpure-code</code><code class="descclassname"></code><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">
+<code class="descname">-mno-movt</code><code class="descclassname"></code><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">
+<code class="descname">-mno-neg-immediates</code><code class="descclassname"></code><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">
+<code class="descname">-mnocrc</code><code class="descclassname"></code><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">
+<code class="descname">-mrestrict-it</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-restrict-it</code><code class="descclassname"></code><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">
+<code class="descname">-mtp</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-munaligned-access</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-unaligned-access</code><code class="descclassname"></code><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="#id18">Hexagon</a><a class="headerlink" href="#hexagon" title="Permalink to this headline">¶</a></h4>
+<dl class="option">
+<dt id="cmdoption-clang-mieee-rnd-near">
+<code class="descname">-mieee-rnd-near</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mieee-rnd-near" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mmemops">
+<code class="descname">-mmemops</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-memops</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mmemops" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable generation of memop instructions</p>
+<dl class="option">
+<dt id="cmdoption-clang-mnvj">
+<code class="descname">-mnvj</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-nvj</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mnvj" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable generation of new-value jumps</p>
+<dl class="option">
+<dt id="cmdoption-clang-mnvs">
+<code class="descname">-mnvs</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-nvs</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mnvs" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable generation of new-value stores</p>
+<dl class="option">
+<dt id="cmdoption-clang-mpackets">
+<code class="descname">-mpackets</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-packets</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mpackets" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable generation of instruction packets</p>
+</div>
+<div class="section" id="id1">
+<h4><a class="toc-backref" href="#id19">Hexagon</a><a class="headerlink" href="#id1" title="Permalink to this headline">¶</a></h4>
+<dl class="option">
+<dt id="cmdoption-clang-mhvx">
+<code class="descname">-mhvx</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-hvx</code><code class="descclassname"></code><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-length">
+<code class="descname">-mhvx-length</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-mhvx</code><code class="descclassname">=<arg></code><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="mips">
+<h4><a class="toc-backref" href="#id20">MIPS</a><a class="headerlink" href="#mips" title="Permalink to this headline">¶</a></h4>
+<dl class="option">
+<dt id="cmdoption-clang-mabicalls">
+<code class="descname">-mabicalls</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-abicalls</code><code class="descclassname"></code><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">
+<code class="descname">-mabs</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-mabs" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mcheck-zero-division">
+<code class="descname">-mcheck-zero-division</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-check-zero-division</code><code class="descclassname"></code><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-mcompact-branches">
+<code class="descname">-mcompact-branches</code><code class="descclassname">=<arg></code><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-mdouble-float">
+<code class="descname">-mdouble-float</code><code class="descclassname"></code><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">
+<code class="descname">-mdsp</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-dsp</code><code class="descclassname"></code><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">
+<code class="descname">-mdspr2</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-dspr2</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mdspr2" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-membedded-data">
+<code class="descname">-membedded-data</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-embedded-data</code><code class="descclassname"></code><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">
+<code class="descname">-mextern-sdata</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-extern-sdata</code><code class="descclassname"></code><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-mfp32">
+<code class="descname">-mfp32</code><code class="descclassname"></code><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">
+<code class="descname">-mfp64</code><code class="descclassname"></code><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-mginv">
+<code class="descname">-mginv</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-ginv</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mginv" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mgpopt">
+<code class="descname">-mgpopt</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-gpopt</code><code class="descclassname"></code><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-mindirect-jump">
+<code class="descname">-mindirect-jump</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-mindirect-jump" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Change indirect jump instructions to inhibit speculation</p>
+<dl class="option">
+<dt id="cmdoption-clang-mips16">
+<code class="descname">-mips16</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mips16" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mldc1-sdc1">
+<code class="descname">-mldc1-sdc1</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-ldc1-sdc1</code><code class="descclassname"></code><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">
+<code class="descname">-mlocal-sdata</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-local-sdata</code><code class="descclassname"></code><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-mmadd4">
+<code class="descname">-mmadd4</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-madd4</code><code class="descclassname"></code><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-mmicromips">
+<code class="descname">-mmicromips</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-micromips</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mmicromips" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mmsa">
+<code class="descname">-mmsa</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-msa</code><code class="descclassname"></code><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">
+<code class="descname">-mmt</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-mt</code><code class="descclassname"></code><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">
+<code class="descname">-mnan</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-mno-mips16</code><code class="descclassname"></code><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-msingle-float">
+<code class="descname">-msingle-float</code><code class="descclassname"></code><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-mvirt">
+<code class="descname">-mvirt</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-virt</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mvirt" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mxgot">
+<code class="descname">-mxgot</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-xgot</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mxgot" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+</div>
+<div class="section" id="powerpc">
+<h4><a class="toc-backref" href="#id21">PowerPC</a><a class="headerlink" href="#powerpc" title="Permalink to this headline">¶</a></h4>
+<dl class="option">
+<dt id="cmdoption-clang-maltivec">
+<code class="descname">-maltivec</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-altivec</code><code class="descclassname"></code><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">
+<code class="descname">-mcmpb</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-cmpb</code><code class="descclassname"></code><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">
+<code class="descname">-mcrbits</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-crbits</code><code class="descclassname"></code><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">
+<code class="descname">-mcrypto</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-crypto</code><code class="descclassname"></code><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">
+<code class="descname">-mdirect-move</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-direct-move</code><code class="descclassname"></code><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">
+<code class="descname">-mfloat128</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-float128</code><code class="descclassname"></code><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">
+<code class="descname">-mfprnd</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-fprnd</code><code class="descclassname"></code><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">
+<code class="descname">-mhtm</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-htm</code><code class="descclassname"></code><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">
+<code class="descname">-minvariant-function-descriptors</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-invariant-function-descriptors</code><code class="descclassname"></code><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">
+<code class="descname">-misel</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-isel</code><code class="descclassname"></code><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">
+<code class="descname">-mlongcall</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-longcall</code><code class="descclassname"></code><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">
+<code class="descname">-mmfocrf</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mmfcrf</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-mfocrf</code><code class="descclassname"></code><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">
+<code class="descname">-mpopcntd</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-popcntd</code><code class="descclassname"></code><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">
+<code class="descname">-mpower8-vector</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-power8-vector</code><code class="descclassname"></code><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">
+<code class="descname">-mpower9-vector</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-power9-vector</code><code class="descclassname"></code><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">
+<code class="descname">-mqpx</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-qpx</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mqpx" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-msecure-plt">
+<code class="descname">-msecure-plt</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-msecure-plt" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mvsx">
+<code class="descname">-mvsx</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-vsx</code><code class="descclassname"></code><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="#id22">WebAssembly</a><a class="headerlink" href="#webassembly" title="Permalink to this headline">¶</a></h4>
+<dl class="option">
+<dt id="cmdoption-clang-mexception-handling">
+<code class="descname">-mexception-handling</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-exception-handling</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mexception-handling" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mnontrapping-fptoint">
+<code class="descname">-mnontrapping-fptoint</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-nontrapping-fptoint</code><code class="descclassname"></code><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-msign-ext">
+<code class="descname">-msign-ext</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-sign-ext</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-msign-ext" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-msimd128">
+<code class="descname">-msimd128</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-simd128</code><code class="descclassname"></code><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="#id23">X86</a><a class="headerlink" href="#x86" title="Permalink to this headline">¶</a></h4>
+<dl class="option">
+<dt id="cmdoption-clang-m3dnow">
+<code class="descname">-m3dnow</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-3dnow</code><code class="descclassname"></code><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">
+<code class="descname">-m3dnowa</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-3dnowa</code><code class="descclassname"></code><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">
+<code class="descname">-madx</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-adx</code><code class="descclassname"></code><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">
+<code class="descname">-maes</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-aes</code><code class="descclassname"></code><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">
+<code class="descname">-mavx</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-avx</code><code class="descclassname"></code><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">
+<code class="descname">-mavx2</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-avx2</code><code class="descclassname"></code><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">
+<code class="descname">-mavx512bitalg</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-avx512bitalg</code><code class="descclassname"></code><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">
+<code class="descname">-mavx512bw</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-avx512bw</code><code class="descclassname"></code><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">
+<code class="descname">-mavx512cd</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-avx512cd</code><code class="descclassname"></code><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">
+<code class="descname">-mavx512dq</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-avx512dq</code><code class="descclassname"></code><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">
+<code class="descname">-mavx512er</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-avx512er</code><code class="descclassname"></code><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">
+<code class="descname">-mavx512f</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-avx512f</code><code class="descclassname"></code><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">
+<code class="descname">-mavx512ifma</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-avx512ifma</code><code class="descclassname"></code><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">
+<code class="descname">-mavx512pf</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-avx512pf</code><code class="descclassname"></code><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">
+<code class="descname">-mavx512vbmi</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-avx512vbmi</code><code class="descclassname"></code><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">
+<code class="descname">-mavx512vbmi2</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-avx512vbmi2</code><code class="descclassname"></code><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">
+<code class="descname">-mavx512vl</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-avx512vl</code><code class="descclassname"></code><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">
+<code class="descname">-mavx512vnni</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-avx512vnni</code><code class="descclassname"></code><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">
+<code class="descname">-mavx512vpopcntdq</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-avx512vpopcntdq</code><code class="descclassname"></code><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">
+<code class="descname">-mbmi</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-bmi</code><code class="descclassname"></code><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">
+<code class="descname">-mbmi2</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-bmi2</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mbmi2" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mcldemote">
+<code class="descname">-mcldemote</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-cldemote</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mcldemote" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mclflushopt">
+<code class="descname">-mclflushopt</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-clflushopt</code><code class="descclassname"></code><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">
+<code class="descname">-mclwb</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-clwb</code><code class="descclassname"></code><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">
+<code class="descname">-mclzero</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-clzero</code><code class="descclassname"></code><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">
+<code class="descname">-mcx16</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-cx16</code><code class="descclassname"></code><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">
+<code class="descname">-mf16c</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-f16c</code><code class="descclassname"></code><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">
+<code class="descname">-mfma</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-fma</code><code class="descclassname"></code><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">
+<code class="descname">-mfma4</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-fma4</code><code class="descclassname"></code><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">
+<code class="descname">-mfsgsbase</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-fsgsbase</code><code class="descclassname"></code><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">
+<code class="descname">-mfxsr</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-fxsr</code><code class="descclassname"></code><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">
+<code class="descname">-mgfni</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-gfni</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mgfni" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-minvpcid">
+<code class="descname">-minvpcid</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-invpcid</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-minvpcid" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mlwp">
+<code class="descname">-mlwp</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-lwp</code><code class="descclassname"></code><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">
+<code class="descname">-mlzcnt</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-lzcnt</code><code class="descclassname"></code><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">
+<code class="descname">-mmmx</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-mmx</code><code class="descclassname"></code><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">
+<code class="descname">-mmovbe</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-movbe</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mmovbe" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mmovdir64b">
+<code class="descname">-mmovdir64b</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-movdir64b</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mmovdir64b" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mmovdiri">
+<code class="descname">-mmovdiri</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-movdiri</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mmovdiri" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mmpx">
+<code class="descname">-mmpx</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-mpx</code><code class="descclassname"></code><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">
+<code class="descname">-mmwaitx</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-mwaitx</code><code class="descclassname"></code><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">
+<code class="descname">-mpclmul</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-pclmul</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mpclmul" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mpconfig">
+<code class="descname">-mpconfig</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-pconfig</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mpconfig" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mpku">
+<code class="descname">-mpku</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-pku</code><code class="descclassname"></code><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">
+<code class="descname">-mpopcnt</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-popcnt</code><code class="descclassname"></code><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">
+<code class="descname">-mprefetchwt1</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-prefetchwt1</code><code class="descclassname"></code><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">
+<code class="descname">-mprfchw</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-prfchw</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mprfchw" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mptwrite">
+<code class="descname">-mptwrite</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-ptwrite</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mptwrite" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mrdpid">
+<code class="descname">-mrdpid</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-rdpid</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mrdpid" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mrdrnd">
+<code class="descname">-mrdrnd</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-rdrnd</code><code class="descclassname"></code><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">
+<code class="descname">-mrdseed</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-rdseed</code><code class="descclassname"></code><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">
+<code class="descname">-mretpoline</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-retpoline</code><code class="descclassname"></code><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">
+<code class="descname">-mretpoline-external-thunk</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-retpoline-external-thunk</code><code class="descclassname"></code><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">
+<code class="descname">-mrtm</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-rtm</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mrtm" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-msahf">
+<code class="descname">-msahf</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-sahf</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-msahf" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-msgx">
+<code class="descname">-msgx</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-sgx</code><code class="descclassname"></code><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">
+<code class="descname">-msha</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-sha</code><code class="descclassname"></code><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">
+<code class="descname">-mshstk</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-shstk</code><code class="descclassname"></code><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">
+<code class="descname">-msse</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-sse</code><code class="descclassname"></code><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">
+<code class="descname">-msse2</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-sse2</code><code class="descclassname"></code><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">
+<code class="descname">-msse3</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-sse3</code><code class="descclassname"></code><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-1">
+<code class="descname">-msse4.1</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-sse4.1</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-msse4-1" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-msse4-2">
+<code class="descname">-msse4.2</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-sse4.2</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-msse4</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang1-msse4-2" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-msse4a">
+<code class="descname">-msse4a</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-sse4a</code><code class="descclassname"></code><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">
+<code class="descname">-mssse3</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-ssse3</code><code class="descclassname"></code><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">
+<code class="descname">-mtbm</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-tbm</code><code class="descclassname"></code><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">
+<code class="descname">-mvaes</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-vaes</code><code class="descclassname"></code><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">
+<code class="descname">-mvpclmulqdq</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-vpclmulqdq</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mvpclmulqdq" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mwaitpkg">
+<code class="descname">-mwaitpkg</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-waitpkg</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mwaitpkg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mwbnoinvd">
+<code class="descname">-mwbnoinvd</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-wbnoinvd</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mwbnoinvd" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mx87">
+<code class="descname">-mx87</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-m80387</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-x87</code><code class="descclassname"></code><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">
+<code class="descname">-mxop</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-xop</code><code class="descclassname"></code><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">
+<code class="descname">-mxsave</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-xsave</code><code class="descclassname"></code><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">
+<code class="descname">-mxsavec</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-xsavec</code><code class="descclassname"></code><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">
+<code class="descname">-mxsaveopt</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-xsaveopt</code><code class="descclassname"></code><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">
+<code class="descname">-mxsaves</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-xsaves</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mxsaves" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+</div>
+<div class="section" id="riscv">
+<h4><a class="toc-backref" href="#id24">RISCV</a><a class="headerlink" href="#riscv" title="Permalink to this headline">¶</a></h4>
+<dl class="option">
+<dt id="cmdoption-clang-mrelax">
+<code class="descname">-mrelax</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-mno-relax</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-mrelax" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable linker relaxation</p>
+</div>
+</div>
+<div class="section" id="optimization-level">
+<h3><a class="toc-backref" href="#id25">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-arg">
+<code class="descname">-O<arg></code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-O</code><code class="descclassname"> (equivalent to -O2)</code><code class="descclassname">, </code><code class="descname">--optimize</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--optimize</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-o-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ofast-arg">
+<code class="descname">-Ofast<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-ofast-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+</div>
+<div class="section" id="debug-information-generation">
+<h3><a class="toc-backref" href="#id26">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="#id27">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">
+<code class="descname">-g</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--debug</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--debug</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-gdwarf-2</code><code class="descclassname"></code><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">
+<code class="descname">-gdwarf-3</code><code class="descclassname"></code><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">
+<code class="descname">-gdwarf-4</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-gdwarf</code><code class="descclassname"></code><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">
+<code class="descname">-gdwarf-5</code><code class="descclassname"></code><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">
+<code class="descname">-gfull</code><code class="descclassname"></code><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">
+<code class="descname">-gused</code><code class="descclassname"></code><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="#id28">Debug level</a><a class="headerlink" href="#debug-level" title="Permalink to this headline">¶</a></h5>
+<dl class="option">
+<dt id="cmdoption-clang-g0">
+<code class="descname">-g0</code><code class="descclassname"></code><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">
+<code class="descname">-g2</code><code class="descclassname"></code><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">
+<code class="descname">-g3</code><code class="descclassname"></code><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">
+<code class="descname">-ggdb0</code><code class="descclassname"></code><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">
+<code class="descname">-ggdb1</code><code class="descclassname"></code><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">
+<code class="descname">-ggdb2</code><code class="descclassname"></code><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">
+<code class="descname">-ggdb3</code><code class="descclassname"></code><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">
+<code class="descname">-gline-tables-only</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-g1</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-gmlt</code><code class="descclassname"></code><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">
+<code class="descname">-gmodules</code><code class="descclassname"></code><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="#id29">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">
+<code class="descname">-ggdb</code><code class="descclassname"></code><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">
+<code class="descname">-glldb</code><code class="descclassname"></code><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">
+<code class="descname">-gsce</code><code class="descclassname"></code><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="#id30">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">
+<code class="descname">-gcolumn-info</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-gno-column-info</code><code class="descclassname"></code><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">
+<code class="descname">-gdwarf-aranges</code><code class="descclassname"></code><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-gembed-source">
+<code class="descname">-gembed-source</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-gno-embed-source</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-gembed-source" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Embed source text in DWARF debug sections</p>
+<dl class="option">
+<dt id="cmdoption-clang-ggnu-pubnames">
+<code class="descname">-ggnu-pubnames</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-gno-gnu-pubnames</code><code class="descclassname"></code><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">
+<code class="descname">-grecord-gcc-switches</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-gno-record-gcc-switches</code><code class="descclassname"></code><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">
+<code class="descname">-gsplit-dwarf</code><code class="descclassname"></code><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">
+<code class="descname">-gstrict-dwarf</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-gno-strict-dwarf</code><code class="descclassname"></code><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">
+<code class="descname">-gz</code><code class="descclassname"></code><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">
+<code class="descname">-gz</code><code class="descclassname">=<arg></code><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="#id31">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">
+<code class="descname">-Xanalyzer</code><code class="descclassname"> <arg></code><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="#id32">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 <code class="docutils literal"><span class="pre">gfortran</span></code> compiler when Clang is given
+a Fortran input.</p>
+<dl class="option">
+<dt id="cmdoption-clang-assert">
+<code class="descname">-A<arg></code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--assert</code><code class="descclassname"> <arg></code><code class="descclassname">, </code><code class="descname">--assert</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-assert" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="id2">
+<code class="descname">-A-<arg></code><code class="descclassname"></code><a class="headerlink" href="#id2" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-j-arg">
+<code class="descname">-J<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-j-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-cpp">
+<code class="descname">-cpp</code><code class="descclassname"></code><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">
+<code class="descname">-faggressive-function-elimination</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-aggressive-function-elimination</code><code class="descclassname"></code><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">
+<code class="descname">-falign-commons</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-align-commons</code><code class="descclassname"></code><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">
+<code class="descname">-fall-intrinsics</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-all-intrinsics</code><code class="descclassname"></code><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">
+<code class="descname">-fautomatic</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-automatic</code><code class="descclassname"></code><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">
+<code class="descname">-fbackslash</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-backslash</code><code class="descclassname"></code><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">
+<code class="descname">-fbacktrace</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-backtrace</code><code class="descclassname"></code><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">
+<code class="descname">-fblas-matmul-limit</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fbounds-check</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-bounds-check</code><code class="descclassname"></code><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">
+<code class="descname">-fcheck-array-temporaries</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-check-array-temporaries</code><code class="descclassname"></code><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">
+<code class="descname">-fcheck</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fcoarray</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fconvert</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fcray-pointer</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-cray-pointer</code><code class="descclassname"></code><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">
+<code class="descname">-fd-lines-as-code</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-d-lines-as-code</code><code class="descclassname"></code><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">
+<code class="descname">-fd-lines-as-comments</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-d-lines-as-comments</code><code class="descclassname"></code><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">
+<code class="descname">-fdefault-double-8</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-default-double-8</code><code class="descclassname"></code><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">
+<code class="descname">-fdefault-integer-8</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-default-integer-8</code><code class="descclassname"></code><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">
+<code class="descname">-fdefault-real-8</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-default-real-8</code><code class="descclassname"></code><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">
+<code class="descname">-fdollar-ok</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-dollar-ok</code><code class="descclassname"></code><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">
+<code class="descname">-fdump-fortran-optimized</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-dump-fortran-optimized</code><code class="descclassname"></code><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">
+<code class="descname">-fdump-fortran-original</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-dump-fortran-original</code><code class="descclassname"></code><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">
+<code class="descname">-fdump-parse-tree</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-dump-parse-tree</code><code class="descclassname"></code><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">
+<code class="descname">-fexternal-blas</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-external-blas</code><code class="descclassname"></code><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">
+<code class="descname">-ff2c</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-f2c</code><code class="descclassname"></code><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">
+<code class="descname">-ffixed-form</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-fixed-form</code><code class="descclassname"></code><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-arg">
+<code class="descname">-ffixed-line-length-<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-ffixed-line-length-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ffpe-trap">
+<code class="descname">-ffpe-trap</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-ffree-form</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-free-form</code><code class="descclassname"></code><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-arg">
+<code class="descname">-ffree-line-length-<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-ffree-line-length-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ffrontend-optimize">
+<code class="descname">-ffrontend-optimize</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-frontend-optimize</code><code class="descclassname"></code><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">
+<code class="descname">-fimplicit-none</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-implicit-none</code><code class="descclassname"></code><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">
+<code class="descname">-finit-character</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-finit-integer</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-finit-local-zero</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-init-local-zero</code><code class="descclassname"></code><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">
+<code class="descname">-finit-logical</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-finit-real</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-finteger-4-integer-8</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-integer-4-integer-8</code><code class="descclassname"></code><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">
+<code class="descname">-fintrinsic-modules-path</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-intrinsic-modules-path</code><code class="descclassname"></code><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">
+<code class="descname">-fmax-array-constructor</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fmax-errors</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fmax-identifier-length</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-max-identifier-length</code><code class="descclassname"></code><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">
+<code class="descname">-fmax-stack-var-size</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fmax-subrecord-length</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-fmodule-private</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-module-private</code><code class="descclassname"></code><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">
+<code class="descname">-fpack-derived</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-pack-derived</code><code class="descclassname"></code><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">
+<code class="descname">-fprotect-parens</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-protect-parens</code><code class="descclassname"></code><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">
+<code class="descname">-frange-check</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-range-check</code><code class="descclassname"></code><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">
+<code class="descname">-freal-4-real-10</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-real-4-real-10</code><code class="descclassname"></code><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">
+<code class="descname">-freal-4-real-16</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-real-4-real-16</code><code class="descclassname"></code><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">
+<code class="descname">-freal-4-real-8</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-real-4-real-8</code><code class="descclassname"></code><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">
+<code class="descname">-freal-8-real-10</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-real-8-real-10</code><code class="descclassname"></code><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">
+<code class="descname">-freal-8-real-16</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-real-8-real-16</code><code class="descclassname"></code><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">
+<code class="descname">-freal-8-real-4</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-real-8-real-4</code><code class="descclassname"></code><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">
+<code class="descname">-frealloc-lhs</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-realloc-lhs</code><code class="descclassname"></code><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">
+<code class="descname">-frecord-marker</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-frecursive</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-recursive</code><code class="descclassname"></code><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">
+<code class="descname">-frepack-arrays</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-repack-arrays</code><code class="descclassname"></code><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">
+<code class="descname">-fsecond-underscore</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-second-underscore</code><code class="descclassname"></code><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">
+<code class="descname">-fsign-zero</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-sign-zero</code><code class="descclassname"></code><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">
+<code class="descname">-fstack-arrays</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-stack-arrays</code><code class="descclassname"></code><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">
+<code class="descname">-funderscoring</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-underscoring</code><code class="descclassname"></code><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">
+<code class="descname">-fwhole-file</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-whole-file</code><code class="descclassname"></code><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-imultilib">
+<code class="descname">-imultilib</code><code class="descclassname"> <arg></code><a class="headerlink" href="#cmdoption-clang-imultilib" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-nocpp">
+<code class="descname">-nocpp</code><code class="descclassname"></code><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">
+<code class="descname">-static-libgfortran</code><code class="descclassname"></code><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="#id33">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-dir">
+<code class="descname">-L<dir></code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--library-directory</code><code class="descclassname"> <arg></code><code class="descclassname">, </code><code class="descname">--library-directory</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-l-dir" 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">
+<code class="descname">-Mach</code><code class="descclassname"></code><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-script">
+<code class="descname">-T<script></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-t-script" 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-addr">
+<code class="descname">-Tbss<addr></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-tbss-addr" 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-addr">
+<code class="descname">-Tdata<addr></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-tdata-addr" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Set starting address of DATA to <addr></p>
+<dl class="option">
+<dt id="cmdoption-clang-ttext-addr">
+<code class="descname">-Ttext<addr></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-ttext-addr" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>Set starting address of TEXT to <addr></p>
+<dl class="option">
+<dt id="cmdoption-clang-wl-arg-arg2">
+<code class="descname">-Wl,<arg>,<arg2>...</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-wl-arg-arg2" 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">
+<code class="descname">-X</code><code class="descclassname"></code><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">
+<code class="descname">-Xlinker</code><code class="descclassname"> <arg></code><code class="descclassname">, </code><code class="descname">--for-linker</code><code class="descclassname"> <arg></code><code class="descclassname">, </code><code class="descname">--for-linker</code><code class="descclassname">=<arg></code><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">
+<code class="descname">-Z</code><code class="descclassname"></code><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-arg">
+<code class="descname">-e<arg></code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--entry</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-e-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-filelist">
+<code class="descname">-filelist</code><code class="descclassname"> <arg></code><a class="headerlink" href="#cmdoption-clang-filelist" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-hip-device-lib-path">
+<code class="descname">--hip-device-lib-path</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-hip-device-lib-path" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>HIP device library path</p>
+<dl class="option">
+<dt id="cmdoption-clang-hip-device-lib">
+<code class="descname">--hip-device-lib</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-hip-device-lib" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<p>HIP device library</p>
+<dl class="option">
+<dt id="cmdoption-clang-l-arg">
+<code class="descname">-l<arg></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-l-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-r">
+<code class="descname">-r</code><code class="descclassname"></code><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">
+<code class="descname">-rpath</code><code class="descclassname"> <arg></code><a class="headerlink" href="#cmdoption-clang-rpath" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="id3">
+<code class="descname">-s</code><code class="descclassname"></code><a class="headerlink" href="#id3" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-t">
+<code class="descname">-t</code><code class="descclassname"></code><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-arg">
+<code class="descname">-u<arg></code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--force-link</code><code class="descclassname"> <arg></code><code class="descclassname">, </code><code class="descname">--force-link</code><code class="descclassname">=<arg></code><a class="headerlink" href="#cmdoption-clang-u-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-undef">
+<code class="descname">-undef</code><code class="descclassname"></code><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-arg">
+<code class="descname">-undefined<arg></code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">--no-undefined</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-clang-undefined-arg" title="Permalink to this definition">¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-z">
+<code class="descname">-z</code><code class="descclassname"> <arg></code><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" role="navigation" aria-label="bottom navigation">
+
+ <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" role="contentinfo">
+ © Copyright 2007-2018, The Clang Team.
+ Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.6.4.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/7.0.0/tools/clang/docs/ClangFormat.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/7.0.0/tools/clang/docs/ClangFormat.html?rev=342530&view=auto
==============================================================================
--- www-releases/trunk/7.0.0/tools/clang/docs/ClangFormat.html (added)
+++ www-releases/trunk/7.0.0/tools/clang/docs/ClangFormat.html Wed Sep 19 02:40:08 2018
@@ -0,0 +1,243 @@
+
+<!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 7 documentation</title>
+ <link rel="stylesheet" href="_static/haiku.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: './',
+ VERSION: '7',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true,
+ SOURCELINK_SUFFIX: '.txt'
+ };
+ </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="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+ <link rel="index" title="Index" href="genindex.html" />
+ <link rel="search" title="Search" href="search.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" role="banner"><h1 class="heading"><a href="index.html">
+ <span>Clang 7 documentation</span></a></h1>
+ <h2 class="heading"><span>ClangFormat</span></h2>
+ </div>
+ <div class="topnav" role="navigation" aria-label="top navigation">
+
+ <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"><span class="doc">LibFormat</span></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></span><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 <code class="docutils literal"><span class="pre">-style="{key:</span> <span class="pre">value,</span> <span class="pre">...}"</span></code> option or
+by putting your style configuration in the <code class="docutils literal"><span class="pre">.clang-format</span></code> or <code class="docutils literal"><span class="pre">_clang-format</span></code>
+file in your projectâs directory and using <code class="docutils literal"><span class="pre">clang-format</span> <span class="pre">-style=file</span></code>.</p>
+<p>An easy way to create the <code class="docutils literal"><span class="pre">.clang-format</span></code> file is:</p>
+<div class="highlight-console"><div class="highlight"><pre><span></span><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"><span class="doc">Clang-Format Style Options</span></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><span></span>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></span><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></span><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></span><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></span><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></span><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" role="navigation" aria-label="bottom navigation">
+
+ <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" role="contentinfo">
+ © Copyright 2007-2018, The Clang Team.
+ Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.6.4.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/7.0.0/tools/clang/docs/ClangFormatStyleOptions.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/7.0.0/tools/clang/docs/ClangFormatStyleOptions.html?rev=342530&view=auto
==============================================================================
--- www-releases/trunk/7.0.0/tools/clang/docs/ClangFormatStyleOptions.html (added)
+++ www-releases/trunk/7.0.0/tools/clang/docs/ClangFormatStyleOptions.html Wed Sep 19 02:40:08 2018
@@ -0,0 +1,1938 @@
+
+<!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 7 documentation</title>
+ <link rel="stylesheet" href="_static/haiku.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: './',
+ VERSION: '7',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true,
+ SOURCELINK_SUFFIX: '.txt'
+ };
+ </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="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+ <link rel="index" title="Index" href="genindex.html" />
+ <link rel="search" title="Search" href="search.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" role="banner"><h1 class="heading"><a href="index.html">
+ <span>Clang 7 documentation</span></a></h1>
+ <h2 class="heading"><span>Clang-Format Style Options</span></h2>
+ </div>
+ <div class="topnav" role="navigation" aria-label="top navigation">
+
+ <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="#"><span class="doc">Clang-Format Style Options</span></a> describes configurable formatting style options
+supported by <a class="reference internal" href="LibFormat.html"><span class="doc">LibFormat</span></a> and <a class="reference internal" href="ClangFormat.html"><span class="doc">ClangFormat</span></a>.</p>
+<p>When using <strong class="program">clang-format</strong> command line utility or
+<code class="docutils literal"><span class="pre">clang::format::reformat(...)</span></code> 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 <code class="docutils literal"><span class="pre">-style=</span></code> command line option or
+use <code class="docutils literal"><span class="pre">-style=file</span></code> and put style configuration in the <code class="docutils literal"><span class="pre">.clang-format</span></code> or
+<code class="docutils literal"><span class="pre">_clang-format</span></code> file in the project directory.</p>
+<p>When using <code class="docutils literal"><span class="pre">-style=file</span></code>, <strong class="program">clang-format</strong> for each input file will
+try to find the <code class="docutils literal"><span class="pre">.clang-format</span></code> 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 <code class="docutils literal"><span class="pre">.clang-format</span></code> file uses YAML format:</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span></span><span class="l l-Scalar l-Scalar-Plain">key1</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">value1</span>
+<span class="l l-Scalar l-Scalar-Plain">key2</span><span class="p p-Indicator">:</span> <span class="l l-Scalar 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
+<code class="docutils literal"><span class="pre">Language:</span></code> 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, <code class="docutils literal"><span class="pre">-assume-filename=</span></code> 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></span><span class="nn">---</span>
+<span class="c1"># We'll use defaults from the LLVM style, but with 4 columns indentation.</span>
+<span class="l l-Scalar l-Scalar-Plain">BasedOnStyle</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">LLVM</span>
+<span class="l l-Scalar l-Scalar-Plain">IndentWidth</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">4</span>
+<span class="nn">---</span>
+<span class="l l-Scalar l-Scalar-Plain">Language</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">Cpp</span>
+<span class="c1"># Force pointers to the type for C++.</span>
+<span class="l l-Scalar l-Scalar-Plain">DerivePointerAlignment</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">false</span>
+<span class="l l-Scalar l-Scalar-Plain">PointerAlignment</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">Left</span>
+<span class="nn">---</span>
+<span class="l l-Scalar l-Scalar-Plain">Language</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">JavaScript</span>
+<span class="c1"># Use 100 columns for JS.</span>
+<span class="l l-Scalar l-Scalar-Plain">ColumnLimit</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">100</span>
+<span class="nn">---</span>
+<span class="l l-Scalar l-Scalar-Plain">Language</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">Proto</span>
+<span class="c1"># Don't format .proto files.</span>
+<span class="l l-Scalar l-Scalar-Plain">DisableFormat</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">true</span>
+<span class="nn">...</span>
+</pre></div>
+</div>
+<p>An easy way to get a valid <code class="docutils literal"><span class="pre">.clang-format</span></code> file containing all configuration
+options of a certain predefined style is:</p>
+<div class="highlight-console"><div class="highlight"><pre><span></span><span class="go">clang-format -style=llvm -dump-config > .clang-format</span>
+</pre></div>
+</div>
+<p>When specifying configuration in the <code class="docutils literal"><span class="pre">-style=</span></code> 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></span><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 <code class="docutils literal"><span class="pre">//</span> <span class="pre">clang-format</span> <span class="pre">off</span></code> or
+<code class="docutils literal"><span class="pre">/*</span> <span class="pre">clang-format</span> <span class="pre">off</span> <span class="pre">*/</span></code> up to a comment <code class="docutils literal"><span class="pre">//</span> <span class="pre">clang-format</span> <span class="pre">on</span></code> or
+<code class="docutils literal"><span class="pre">/*</span> <span class="pre">clang-format</span> <span class="pre">on</span> <span class="pre">*/</span></code> will not be formatted. The comments themselves
+will be formatted (aligned) normally.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><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 <code class="docutils literal"><span class="pre">clang::format::reformat(...)</span></code> 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. <code class="docutils literal"><span class="pre">LS_Auto</span></code>), and as a value usable in
+the configuration (without a prefix: <code class="docutils literal"><span class="pre">Auto</span></code>).</p>
+<dl class="docutils">
+<dt><strong>BasedOnStyle</strong> (<code class="docutils literal"><span class="pre">string</span></code>)</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 <code class="docutils literal"><span class="pre">-style='{...}'</span></code> and the <code class="docutils literal"><span class="pre">.clang-format</span></code> file).</p>
+<p>Possible values:</p>
+<ul class="last simple">
+<li><code class="docutils literal"><span class="pre">LLVM</span></code>
+A style complying with the <a class="reference external" href="http://llvm.org/docs/CodingStandards.html">LLVM coding standards</a></li>
+<li><code class="docutils literal"><span class="pre">Google</span></code>
+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><code class="docutils literal"><span class="pre">Chromium</span></code>
+A style complying with <a class="reference external" href="http://www.chromium.org/developers/coding-style">Chromiumâs style guide</a></li>
+<li><code class="docutils literal"><span class="pre">Mozilla</span></code>
+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><code class="docutils literal"><span class="pre">WebKit</span></code>
+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> (<code class="docutils literal"><span class="pre">int</span></code>)</dt>
+<dd>The extra indent or outdent of access modifiers, e.g. <code class="docutils literal"><span class="pre">public:</span></code>.</dd>
+<dt><strong>AlignAfterOpenBracket</strong> (<code class="docutils literal"><span class="pre">BracketAlignmentStyle</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">true</span></code>, 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"><code class="docutils literal"><span class="pre">BAS_Align</span></code> (in configuration: <code class="docutils literal"><span class="pre">Align</span></code>)
+Align parameters on the open bracket, e.g.:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><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"><code class="docutils literal"><span class="pre">BAS_DontAlign</span></code> (in configuration: <code class="docutils literal"><span class="pre">DontAlign</span></code>)
+Donât align, instead use <code class="docutils literal"><span class="pre">ContinuationIndentWidth</span></code>, e.g.:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><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"><code class="docutils literal"><span class="pre">BAS_AlwaysBreak</span></code> (in configuration: <code class="docutils literal"><span class="pre">AlwaysBreak</span></code>)
+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></span><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> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">true</span></code>, 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></span><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> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">true</span></code>, 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></span><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> (<code class="docutils literal"><span class="pre">EscapedNewlineAlignmentStyle</span></code>)</dt>
+<dd><p class="first">Options for aligning backslashes in escaped newlines.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><code class="docutils literal"><span class="pre">ENAS_DontAlign</span></code> (in configuration: <code class="docutils literal"><span class="pre">DontAlign</span></code>)
+Donât align escaped newlines.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><code class="docutils literal"><span class="pre">ENAS_Left</span></code> (in configuration: <code class="docutils literal"><span class="pre">Left</span></code>)
+Align escaped newlines as far left as possible.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="nb">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="nb">false</span><span class="o">:</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><code class="docutils literal"><span class="pre">ENAS_Right</span></code> (in configuration: <code class="docutils literal"><span class="pre">Right</span></code>)
+Align escaped newlines in the right-most column.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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>
+</pre></div>
+</div>
+</li>
+</ul>
+</dd>
+<dt><strong>AlignOperands</strong> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">true</span></code>, 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></span><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> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">true</span></code>, aligns trailing comments.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></span><span class="nb">true</span><span class="o">:</span> <span class="nb">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> (<code class="docutils literal"><span class="pre">bool</span></code>)</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 <code class="docutils literal"><span class="pre">BinPackParameters</span></code> is <code class="docutils literal"><span class="pre">false</span></code>.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></span><span class="nb">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="nb">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> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">Allows contracting simple braced statements to a single line.</p>
+<p class="last">E.g., this allows <code 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></code> to be put on a single line.</p>
+</dd>
+<dt><strong>AllowShortCaseLabelsOnASingleLine</strong> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">true</span></code>, short case labels will be contracted to a single line.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></span><span class="nb">true</span><span class="o">:</span> <span class="nb">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> (<code class="docutils literal"><span class="pre">ShortFunctionStyle</span></code>)</dt>
+<dd><p class="first">Dependent on the value, <code 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></code> can be put on a
+single line.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><code class="docutils literal"><span class="pre">SFS_None</span></code> (in configuration: <code class="docutils literal"><span class="pre">None</span></code>)
+Never merge functions into a single line.</p>
+</li>
+<li><p class="first"><code class="docutils literal"><span class="pre">SFS_InlineOnly</span></code> (in configuration: <code class="docutils literal"><span class="pre">InlineOnly</span></code>)
+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></span><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="nf">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="nf">f</span><span class="p">()</span> <span class="p">{</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><code class="docutils literal"><span class="pre">SFS_Empty</span></code> (in configuration: <code class="docutils literal"><span class="pre">Empty</span></code>)
+Only merge empty functions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="kt">void</span> <span class="nf">f</span><span class="p">()</span> <span class="p">{}</span>
+<span class="kt">void</span> <span class="nf">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"><code class="docutils literal"><span class="pre">SFS_Inline</span></code> (in configuration: <code class="docutils literal"><span class="pre">Inline</span></code>)
+Only merge functions defined inside a class. Implies âemptyâ.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><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="nf">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="nf">f</span><span class="p">()</span> <span class="p">{}</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><code class="docutils literal"><span class="pre">SFS_All</span></code> (in configuration: <code class="docutils literal"><span class="pre">All</span></code>)
+Merge all functions fitting on a single line.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><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="nf">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> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd>If <code class="docutils literal"><span class="pre">true</span></code>, <code class="docutils literal"><span class="pre">if</span> <span class="pre">(a)</span> <span class="pre">return;</span></code> can be put on a single line.</dd>
+<dt><strong>AllowShortLoopsOnASingleLine</strong> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd>If <code class="docutils literal"><span class="pre">true</span></code>, <code class="docutils literal"><span class="pre">while</span> <span class="pre">(true)</span> <span class="pre">continue;</span></code> can be put on a single
+line.</dd>
+<dt><strong>AlwaysBreakAfterDefinitionReturnType</strong> (<code class="docutils literal"><span class="pre">DefinitionReturnTypeBreakingStyle</span></code>)</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><code class="docutils literal"><span class="pre">DRTBS_None</span></code> (in configuration: <code class="docutils literal"><span class="pre">None</span></code>)
+Break after return type automatically.
+<code class="docutils literal"><span class="pre">PenaltyReturnTypeOnItsOwnLine</span></code> is taken into account.</li>
+<li><code class="docutils literal"><span class="pre">DRTBS_All</span></code> (in configuration: <code class="docutils literal"><span class="pre">All</span></code>)
+Always break after the return type.</li>
+<li><code class="docutils literal"><span class="pre">DRTBS_TopLevel</span></code> (in configuration: <code class="docutils literal"><span class="pre">TopLevel</span></code>)
+Always break after the return types of top-level functions.</li>
+</ul>
+</dd>
+<dt><strong>AlwaysBreakAfterReturnType</strong> (<code class="docutils literal"><span class="pre">ReturnTypeBreakingStyle</span></code>)</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"><code class="docutils literal"><span class="pre">RTBS_None</span></code> (in configuration: <code class="docutils literal"><span class="pre">None</span></code>)
+Break after return type automatically.
+<code class="docutils literal"><span class="pre">PenaltyReturnTypeOnItsOwnLine</span></code> is taken into account.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><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="nf">f</span><span class="p">();</span>
+<span class="kt">int</span> <span class="nf">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"><code class="docutils literal"><span class="pre">RTBS_All</span></code> (in configuration: <code class="docutils literal"><span class="pre">All</span></code>)
+Always break after the return type.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><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="nf">f</span><span class="p">();</span>
+<span class="kt">int</span>
+<span class="nf">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"><code class="docutils literal"><span class="pre">RTBS_TopLevel</span></code> (in configuration: <code class="docutils literal"><span class="pre">TopLevel</span></code>)
+Always break after the return types of top-level functions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><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="nf">f</span><span class="p">();</span>
+<span class="kt">int</span>
+<span class="nf">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"><code class="docutils literal"><span class="pre">RTBS_AllDefinitions</span></code> (in configuration: <code class="docutils literal"><span class="pre">AllDefinitions</span></code>)
+Always break after the return type of function definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><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="nf">f</span><span class="p">();</span>
+<span class="kt">int</span>
+<span class="nf">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"><code class="docutils literal"><span class="pre">RTBS_TopLevelDefinitions</span></code> (in configuration: <code class="docutils literal"><span class="pre">TopLevelDefinitions</span></code>)
+Always break after the return type of top-level definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><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="nf">f</span><span class="p">();</span>
+<span class="kt">int</span>
+<span class="nf">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> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">true</span></code>, 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
+<code class="docutils literal"><span class="pre">ContinuationIndentWidth</span></code> spaces from the start of the line.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></span><span class="nb">true</span><span class="o">:</span> <span class="nb">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> (<code class="docutils literal"><span class="pre">BreakTemplateDeclarationsStyle</span></code>)</dt>
+<dd><p class="first">The template declaration breaking style to use.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><code class="docutils literal"><span class="pre">BTDS_No</span></code> (in configuration: <code class="docutils literal"><span class="pre">No</span></code>)
+Do not force break before declaration.
+<code class="docutils literal"><span class="pre">PenaltyBreakTemplateDeclaration</span></code> is taken into account.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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">T</span> <span class="n">foo</span><span class="p">()</span> <span class="p">{</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="n">T</span> <span class="n">foo</span><span class="p">(</span><span class="kt">int</span> <span class="n">aaaaaaaaaaaaaaaaaaaaa</span><span class="p">,</span>
+ <span class="kt">int</span> <span class="n">bbbbbbbbbbbbbbbbbbbbb</span><span class="p">)</span> <span class="p">{</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><code class="docutils literal"><span class="pre">BTDS_MultiLine</span></code> (in configuration: <code class="docutils literal"><span class="pre">MultiLine</span></code>)
+Force break after template declaration only when the following
+declaration spans multiple lines.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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">T</span> <span class="n">foo</span><span class="p">()</span> <span class="p">{</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="n">T</span> <span class="n">foo</span><span class="p">(</span><span class="kt">int</span> <span class="n">aaaaaaaaaaaaaaaaaaaaa</span><span class="p">,</span>
+ <span class="kt">int</span> <span class="n">bbbbbbbbbbbbbbbbbbbbb</span><span class="p">)</span> <span class="p">{</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><code class="docutils literal"><span class="pre">BTDS_Yes</span></code> (in configuration: <code class="docutils literal"><span class="pre">Yes</span></code>)
+Always break after template declaration.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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">T</span> <span class="n">foo</span><span class="p">()</span> <span class="p">{</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="n">T</span> <span class="n">foo</span><span class="p">(</span><span class="kt">int</span> <span class="n">aaaaaaaaaaaaaaaaaaaaa</span><span class="p">,</span>
+ <span class="kt">int</span> <span class="n">bbbbbbbbbbbbbbbbbbbbb</span><span class="p">)</span> <span class="p">{</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</li>
+</ul>
+</dd>
+<dt><strong>BinPackArguments</strong> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">false</span></code>, 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></span><span class="nb">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="nb">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> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">false</span></code>, 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></span><span class="nb">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="nb">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> (<code class="docutils literal"><span class="pre">BraceWrappingFlags</span></code>)</dt>
+<dd><p class="first">Control of individual brace wrapping cases.</p>
+<p>If <code class="docutils literal"><span class="pre">BreakBeforeBraces</span></code> is set to <code class="docutils literal"><span class="pre">BS_Custom</span></code>, 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></span><span class="c1"># Example of usage:</span>
+<span class="l l-Scalar l-Scalar-Plain">BreakBeforeBraces</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">Custom</span>
+<span class="l l-Scalar l-Scalar-Plain">BraceWrapping</span><span class="p p-Indicator">:</span>
+ <span class="l l-Scalar l-Scalar-Plain">AfterEnum</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">true</span>
+ <span class="l l-Scalar l-Scalar-Plain">AfterStruct</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">false</span>
+ <span class="l l-Scalar l-Scalar-Plain">SplitEmptyFunction</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">false</span>
+</pre></div>
+</div>
+<p>Nested configuration flags:</p>
+<ul class="last">
+<li><p class="first"><code class="docutils literal"><span class="pre">bool</span> <span class="pre">AfterClass</span></code> Wrap class definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="nb">true</span><span class="o">:</span>
+<span class="k">class</span> <span class="nc">foo</span> <span class="p">{};</span>
+
+<span class="nb">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"><code class="docutils literal"><span class="pre">bool</span> <span class="pre">AfterControlStatement</span></code> Wrap control statements (<code class="docutils literal"><span class="pre">if</span></code>/<code class="docutils literal"><span class="pre">for</span></code>/<code class="docutils literal"><span class="pre">while</span></code>/<code class="docutils literal"><span class="pre">switch</span></code>/..).</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="nb">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="nb">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"><code class="docutils literal"><span class="pre">bool</span> <span class="pre">AfterEnum</span></code> Wrap enum definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="nb">true</span><span class="o">:</span>
+<span class="k">enum</span> <span class="nl">X</span> <span class="p">:</span> <span class="kt">int</span>
+<span class="p">{</span>
+ <span class="n">B</span>
+<span class="p">};</span>
+
+<span class="nb">false</span><span class="o">:</span>
+<span class="k">enum</span> <span class="nl">X</span> <span class="p">:</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"><code class="docutils literal"><span class="pre">bool</span> <span class="pre">AfterFunction</span></code> Wrap function definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="nb">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="nb">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"><code class="docutils literal"><span class="pre">bool</span> <span class="pre">AfterNamespace</span></code> Wrap namespace definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="nb">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="nf">bar</span><span class="p">();</span>
+<span class="p">}</span>
+
+<span class="nb">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="nf">bar</span><span class="p">();</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><code class="docutils literal"><span class="pre">bool</span> <span class="pre">AfterObjCDeclaration</span></code> Wrap ObjC definitions (interfaces, implementationsâ¦).
+@autoreleasepool and @synchronized blocks are wrapped
+according to <cite>AfterControlStatement</cite> flag.</p>
+</li>
+<li><p class="first"><code class="docutils literal"><span class="pre">bool</span> <span class="pre">AfterStruct</span></code> Wrap struct definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="nb">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="nb">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"><code class="docutils literal"><span class="pre">bool</span> <span class="pre">AfterUnion</span></code> Wrap union definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="nb">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="nb">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"><code class="docutils literal"><span class="pre">bool</span> <span class="pre">AfterExternBlock</span></code> Wrap extern blocks.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="nb">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="nb">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"><code class="docutils literal"><span class="pre">bool</span> <span class="pre">BeforeCatch</span></code> Wrap before <code class="docutils literal"><span class="pre">catch</span></code>.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="nb">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="nb">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"><code class="docutils literal"><span class="pre">bool</span> <span class="pre">BeforeElse</span></code> Wrap before <code class="docutils literal"><span class="pre">else</span></code>.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="nb">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="nb">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"><code class="docutils literal"><span class="pre">bool</span> <span class="pre">IndentBraces</span></code> Indent the wrapped braces themselves.</p>
+</li>
+<li><p class="first"><code class="docutils literal"><span class="pre">bool</span> <span class="pre">SplitEmptyFunction</span></code> If <code class="docutils literal"><span class="pre">false</span></code>, 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></span><span class="kt">int</span> <span class="nf">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"><code class="docutils literal"><span class="pre">bool</span> <span class="pre">SplitEmptyRecord</span></code> If <code class="docutils literal"><span class="pre">false</span></code>, 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></span><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"><code class="docutils literal"><span class="pre">bool</span> <span class="pre">SplitEmptyNamespace</span></code> If <code class="docutils literal"><span class="pre">false</span></code>, 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></span><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> (<code class="docutils literal"><span class="pre">bool</span></code>)</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></span><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> (<code class="docutils literal"><span class="pre">BinaryOperatorStyle</span></code>)</dt>
+<dd><p class="first">The way to wrap binary operators.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><code class="docutils literal"><span class="pre">BOS_None</span></code> (in configuration: <code class="docutils literal"><span class="pre">None</span></code>)
+Break after operators.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><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"><code class="docutils literal"><span class="pre">BOS_NonAssignment</span></code> (in configuration: <code class="docutils literal"><span class="pre">NonAssignment</span></code>)
+Break before operators that arenât assignments.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><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"><code class="docutils literal"><span class="pre">BOS_All</span></code> (in configuration: <code class="docutils literal"><span class="pre">All</span></code>)
+Break before operators.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><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> (<code class="docutils literal"><span class="pre">BraceBreakingStyle</span></code>)</dt>
+<dd><p class="first">The brace breaking style to use.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><code class="docutils literal"><span class="pre">BS_Attach</span></code> (in configuration: <code class="docutils literal"><span class="pre">Attach</span></code>)
+Always attach braces to surrounding context.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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="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="nl">X</span> <span class="p">:</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"><code class="docutils literal"><span class="pre">BS_Linux</span></code> (in configuration: <code class="docutils literal"><span class="pre">Linux</span></code>)
+Like <code class="docutils literal"><span class="pre">Attach</span></code>, but break before braces on function, namespace and
+class definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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="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="nl">X</span> <span class="p">:</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"><code class="docutils literal"><span class="pre">BS_Mozilla</span></code> (in configuration: <code class="docutils literal"><span class="pre">Mozilla</span></code>)
+Like <code class="docutils literal"><span class="pre">Attach</span></code>, but break before braces on enum, function, and record
+definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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="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="nl">X</span> <span class="p">:</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"><code class="docutils literal"><span class="pre">BS_Stroustrup</span></code> (in configuration: <code class="docutils literal"><span class="pre">Stroustrup</span></code>)
+Like <code class="docutils literal"><span class="pre">Attach</span></code>, but break before function definitions, <code class="docutils literal"><span class="pre">catch</span></code>, and
+<code class="docutils literal"><span class="pre">else</span></code>.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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="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="nl">X</span> <span class="p">:</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"><code class="docutils literal"><span class="pre">BS_Allman</span></code> (in configuration: <code class="docutils literal"><span class="pre">Allman</span></code>)
+Always break before braces.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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="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="nl">X</span> <span class="p">:</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"><code class="docutils literal"><span class="pre">BS_GNU</span></code> (in configuration: <code class="docutils literal"><span class="pre">GNU</span></code>)
+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></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="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="nl">X</span> <span class="p">:</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"><code class="docutils literal"><span class="pre">BS_WebKit</span></code> (in configuration: <code class="docutils literal"><span class="pre">WebKit</span></code>)
+Like <code class="docutils literal"><span class="pre">Attach</span></code>, but break before functions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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="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="nl">X</span> <span class="p">:</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"><code class="docutils literal"><span class="pre">BS_Custom</span></code> (in configuration: <code class="docutils literal"><span class="pre">Custom</span></code>)
+Configure each individual brace in <cite>BraceWrapping</cite>.</p>
+</li>
+</ul>
+</dd>
+<dt><strong>BreakBeforeTernaryOperators</strong> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">true</span></code>, ternary operators will be placed after line breaks.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></span><span class="nb">true</span><span class="o">:</span>
+<span class="n">veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription</span>
+ <span class="o">?</span> <span class="nl">firstValue</span>
+ <span class="p">:</span> <span class="n">SecondValueVeryVeryVeryVeryLong</span><span class="p">;</span>
+
+<span class="nb">false</span><span class="o">:</span>
+<span class="n">veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription</span> <span class="o">?</span>
+ <span class="nl">firstValue</span> <span class="p">:</span>
+ <span class="n">SecondValueVeryVeryVeryVeryLong</span><span class="p">;</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>BreakConstructorInitializers</strong> (<code class="docutils literal"><span class="pre">BreakConstructorInitializersStyle</span></code>)</dt>
+<dd><p class="first">The constructor initializers style to use.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><code class="docutils literal"><span class="pre">BCIS_BeforeColon</span></code> (in configuration: <code class="docutils literal"><span class="pre">BeforeColon</span></code>)
+Break constructor initializers before the colon and after the commas.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><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"><code class="docutils literal"><span class="pre">BCIS_BeforeComma</span></code> (in configuration: <code class="docutils literal"><span class="pre">BeforeComma</span></code>)
+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></span><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"><code class="docutils literal"><span class="pre">BCIS_AfterColon</span></code> (in configuration: <code class="docutils literal"><span class="pre">AfterColon</span></code>)
+Break constructor initializers after the colon and commas.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><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>BreakInheritanceList</strong> (<code class="docutils literal"><span class="pre">BreakInheritanceListStyle</span></code>)</dt>
+<dd><p class="first">The inheritance list style to use.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><code class="docutils literal"><span class="pre">BILS_BeforeColon</span></code> (in configuration: <code class="docutils literal"><span class="pre">BeforeColon</span></code>)
+Break inheritance list before the colon and after the commas.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">Foo</span>
+ <span class="o">:</span> <span class="n">Base1</span><span class="p">,</span>
+ <span class="n">Base2</span>
+<span class="p">{};</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><code class="docutils literal"><span class="pre">BILS_BeforeComma</span></code> (in configuration: <code class="docutils literal"><span class="pre">BeforeComma</span></code>)
+Break inheritance list before the colon and commas, and align
+the commas with the colon.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">Foo</span>
+ <span class="o">:</span> <span class="n">Base1</span>
+ <span class="p">,</span> <span class="n">Base2</span>
+<span class="p">{};</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><code class="docutils literal"><span class="pre">BILS_AfterColon</span></code> (in configuration: <code class="docutils literal"><span class="pre">AfterColon</span></code>)
+Break inheritance list after the colon and commas.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">Foo</span> <span class="o">:</span>
+ <span class="n">Base1</span><span class="p">,</span>
+ <span class="n">Base2</span>
+<span class="p">{};</span>
+</pre></div>
+</div>
+</li>
+</ul>
+</dd>
+<dt><strong>BreakStringLiterals</strong> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd>Allow breaking string literals when formatting.</dd>
+<dt><strong>ColumnLimit</strong> (<code class="docutils literal"><span class="pre">unsigned</span></code>)</dt>
+<dd><p class="first">The column limit.</p>
+<p class="last">A column limit of <code class="docutils literal"><span class="pre">0</span></code> 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> (<code class="docutils literal"><span class="pre">std::string</span></code>)</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></span><span class="c1">// CommentPragmas: '^ FOOBAR pragma:'</span>
+<span class="c1">// Will leave the following line unaffected</span>
+<span class="cp">#include</span> <span class="cpf"><vector> // FOOBAR pragma: keep</span><span class="cp"></span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>CompactNamespaces</strong> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">true</span></code>, consecutive namespace declarations will be on the same
+line. If <code class="docutils literal"><span class="pre">false</span></code>, each namespace is declared on a new line.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="nb">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="nb">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></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="k">namespace</span> <span class="n">Extra</span> <span class="p">{</span>
+<span class="p">}}}</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>ConstructorInitializerAllOnOneLineOrOnePerLine</strong> (<code class="docutils literal"><span class="pre">bool</span></code>)</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></span><span class="nb">true</span><span class="o">:</span>
+<span class="n">FitsOnOneLine</span><span class="o">::</span><span class="n">Constructor</span><span class="p">()</span>
+ <span class="o">:</span> <span class="n">aaaaaaaaaaaaa</span><span class="p">(</span><span class="n">aaaaaaaaaaaaaa</span><span class="p">),</span> <span class="n">aaaaaaaaaaaaa</span><span class="p">(</span><span class="n">aaaaaaaaaaaaaa</span><span class="p">)</span> <span class="p">{}</span>
+
+<span class="n">DoesntFit</span><span class="o">::</span><span class="n">Constructor</span><span class="p">()</span>
+ <span class="o">:</span> <span class="n">aaaaaaaaaaaaa</span><span class="p">(</span><span class="n">aaaaaaaaaaaaaa</span><span class="p">),</span>
+ <span class="n">aaaaaaaaaaaaa</span><span class="p">(</span><span class="n">aaaaaaaaaaaaaa</span><span class="p">),</span>
+ <span class="n">aaaaaaaaaaaaa</span><span class="p">(</span><span class="n">aaaaaaaaaaaaaa</span><span class="p">)</span> <span class="p">{}</span>
+
+<span class="nb">false</span><span class="o">:</span>
+<span class="n">FitsOnOneLine</span><span class="o">::</span><span class="n">Constructor</span><span class="p">()</span>
+ <span class="o">:</span> <span class="n">aaaaaaaaaaaaa</span><span class="p">(</span><span class="n">aaaaaaaaaaaaaa</span><span class="p">),</span> <span class="n">aaaaaaaaaaaaa</span><span class="p">(</span><span class="n">aaaaaaaaaaaaaa</span><span class="p">)</span> <span class="p">{}</span>
+
+<span class="n">DoesntFit</span><span class="o">::</span><span class="n">Constructor</span><span class="p">()</span>
+ <span class="o">:</span> <span class="n">aaaaaaaaaaaaa</span><span class="p">(</span><span class="n">aaaaaaaaaaaaaa</span><span class="p">),</span> <span class="n">aaaaaaaaaaaaa</span><span class="p">(</span><span class="n">aaaaaaaaaaaaaa</span><span class="p">),</span>
+ <span class="n">aaaaaaaaaaaaa</span><span class="p">(</span><span class="n">aaaaaaaaaaaaaa</span><span class="p">)</span> <span class="p">{}</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>ConstructorInitializerIndentWidth</strong> (<code class="docutils literal"><span class="pre">unsigned</span></code>)</dt>
+<dd>The number of characters to use for indentation of constructor
+initializer lists as well as inheritance lists.</dd>
+<dt><strong>ContinuationIndentWidth</strong> (<code class="docutils literal"><span class="pre">unsigned</span></code>)</dt>
+<dd><p class="first">Indent width for line continuations.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></span><span class="nl">ContinuationIndentWidth</span><span class="p">:</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> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">true</span></code>, 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 <code class="docutils literal"><span class="pre">{}</span></code> 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></span><span class="nb">true</span><span class="o">:</span> <span class="nb">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> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd>If <code class="docutils literal"><span class="pre">true</span></code>, analyze the formatted file for the most common
+alignment of <code class="docutils literal"><span class="pre">&</span></code> and <code class="docutils literal"><span class="pre">*</span></code>.
+Pointer and reference alignment styles are going to be updated according
+to the preferences found in the file.
+<code class="docutils literal"><span class="pre">PointerAlignment</span></code> is then used only as fallback.</dd>
+<dt><strong>DisableFormat</strong> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd>Disables formatting completely.</dd>
+<dt><strong>ExperimentalAutoDetectBinPacking</strong> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">true</span></code>, 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> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">true</span></code>, clang-format adds missing namespace end comments and
+fixes invalid existing ones.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></span><span class="nb">true</span><span class="o">:</span> <span class="nb">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> (<code class="docutils literal"><span class="pre">std::vector<std::string></span></code>)</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></span><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></span><span class="l l-Scalar l-Scalar-Plain">ForEachMacros</span><span class="p p-Indicator">:</span> <span class="p p-Indicator">[</span><span class="s">'RANGES_FOR'</span><span class="p p-Indicator">,</span> <span class="s">'FOREACH'</span><span class="p p-Indicator">]</span>
+</pre></div>
+</div>
+<p class="last">For example: BOOST_FOREACH.</p>
+</dd>
+<dt><strong>IncludeBlocks</strong> (<code class="docutils literal"><span class="pre">IncludeBlocksStyle</span></code>)</dt>
+<dd><p class="first">Dependent on the value, multiple <code class="docutils literal"><span class="pre">#include</span></code> blocks can be sorted
+as one and divided based on category.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><code class="docutils literal"><span class="pre">IBS_Preserve</span></code> (in configuration: <code class="docutils literal"><span class="pre">Preserve</span></code>)
+Sort each <code class="docutils literal"><span class="pre">#include</span></code> block separately.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="cp">#include</span> <span class="cpf">"b.h" into #include "b.h"</span><span class="cp"></span>
+
+<span class="cp">#include</span> <span class="cpf"><lib/main.h> #include "a.h"</span><span class="cp"></span>
+<span class="cp">#include</span> <span class="cpf">"a.h" #include <lib/main.h></span><span class="cp"></span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><code class="docutils literal"><span class="pre">IBS_Merge</span></code> (in configuration: <code class="docutils literal"><span class="pre">Merge</span></code>)
+Merge multiple <code class="docutils literal"><span class="pre">#include</span></code> blocks together and sort as one.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="cp">#include</span> <span class="cpf">"b.h" into #include "a.h"</span><span class="cp"></span>
+ <span class="cp">#include</span> <span class="cpf">"b.h"</span><span class="cp"></span>
+<span class="cp">#include</span> <span class="cpf"><lib/main.h> #include <lib/main.h></span><span class="cp"></span>
+<span class="cp">#include</span> <span class="cpf">"a.h"</span><span class="cp"></span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><code class="docutils literal"><span class="pre">IBS_Regroup</span></code> (in configuration: <code class="docutils literal"><span class="pre">Regroup</span></code>)
+Merge multiple <code class="docutils literal"><span class="pre">#include</span></code> blocks together and sort as one.
+Then split into groups based on category priority. See
+<code class="docutils literal"><span class="pre">IncludeCategories</span></code>.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="cp">#include</span> <span class="cpf">"b.h" into #include "a.h"</span><span class="cp"></span>
+ <span class="cp">#include</span> <span class="cpf">"b.h"</span><span class="cp"></span>
+<span class="cp">#include</span> <span class="cpf"><lib/main.h></span><span class="cp"></span>
+<span class="cp">#include</span> <span class="cpf">"a.h" #include <lib/main.h></span><span class="cp"></span>
+</pre></div>
+</div>
+</li>
+</ul>
+</dd>
+<dt><strong>IncludeCategories</strong> (<code class="docutils literal"><span class="pre">std::vector<IncludeCategory></span></code>)</dt>
+<dd><p class="first">Regular expressions denoting the different <code class="docutils literal"><span class="pre">#include</span></code> categories
+used for ordering <code class="docutils literal"><span class="pre">#includes</span></code>.</p>
+<p><a class="reference external" href="http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap09.html">POSIX extended</a>
+regular expressions are supported.</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 <code class="docutils literal"><span class="pre">#includes</span></code> 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 <code class="docutils literal"><span class="pre">#includes</span></code>
+(<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></span><span class="l l-Scalar l-Scalar-Plain">IncludeCategories</span><span class="p p-Indicator">:</span>
+ <span class="p p-Indicator">-</span> <span class="l l-Scalar l-Scalar-Plain">Regex</span><span class="p p-Indicator">:</span> <span class="s">'^"(llvm|llvm-c|clang|clang-c)/'</span>
+ <span class="l l-Scalar l-Scalar-Plain">Priority</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">2</span>
+ <span class="p p-Indicator">-</span> <span class="l l-Scalar l-Scalar-Plain">Regex</span><span class="p p-Indicator">:</span> <span class="s">'^(<|"(gtest|gmock|isl|json)/)'</span>
+ <span class="l l-Scalar l-Scalar-Plain">Priority</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">3</span>
+ <span class="p p-Indicator">-</span> <span class="l l-Scalar l-Scalar-Plain">Regex</span><span class="p p-Indicator">:</span> <span class="s">'<[[:alnum:].]+>'</span>
+ <span class="l l-Scalar l-Scalar-Plain">Priority</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">4</span>
+ <span class="p p-Indicator">-</span> <span class="l l-Scalar l-Scalar-Plain">Regex</span><span class="p p-Indicator">:</span> <span class="s">'.*'</span>
+ <span class="l l-Scalar l-Scalar-Plain">Priority</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">1</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>IncludeIsMainRegex</strong> (<code class="docutils literal"><span class="pre">std::string</span></code>)</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> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">Indent case labels one level from the switch statement.</p>
+<p>When <code class="docutils literal"><span class="pre">false</span></code>, 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></span><span class="nb">false</span><span class="o">:</span> <span class="nb">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> (<code class="docutils literal"><span class="pre">PPDirectiveIndentStyle</span></code>)</dt>
+<dd><p class="first">The preprocessor directive indenting style to use.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><code class="docutils literal"><span class="pre">PPDIS_None</span></code> (in configuration: <code class="docutils literal"><span class="pre">None</span></code>)
+Does not indent any directives.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="cp">#if FOO</span>
+<span class="cp">#if BAR</span>
+<span class="cp">#include</span> <span class="cpf"><foo></span><span class="cp"></span>
+<span class="cp">#endif</span>
+<span class="cp">#endif</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first"><code class="docutils literal"><span class="pre">PPDIS_AfterHash</span></code> (in configuration: <code class="docutils literal"><span class="pre">AfterHash</span></code>)
+Indents directives after the hash.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><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> (<code class="docutils literal"><span class="pre">unsigned</span></code>)</dt>
+<dd><p class="first">The number of columns to use for indentation.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></span><span class="nl">IndentWidth</span><span class="p">:</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="nb">true</span><span class="p">,</span> <span class="nb">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> (<code class="docutils literal"><span class="pre">bool</span></code>)</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></span><span class="nb">true</span><span class="o">:</span>
+<span class="n">LoooooooooooooooooooooooooooooooooooooooongReturnType</span>
+ <span class="n">LoooooooooooooooooooooooooooooooongFunctionDeclaration</span><span class="p">();</span>
+
+<span class="nb">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> (<code class="docutils literal"><span class="pre">JavaScriptQuoteStyle</span></code>)</dt>
+<dd><p class="first">The JavaScriptQuoteStyle to use for JavaScript strings.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><code class="docutils literal"><span class="pre">JSQS_Leave</span></code> (in configuration: <code class="docutils literal"><span class="pre">Leave</span></code>)
+Leave string quotes as they are.</p>
+<div class="highlight-js"><div class="highlight"><pre><span></span><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"><code class="docutils literal"><span class="pre">JSQS_Single</span></code> (in configuration: <code class="docutils literal"><span class="pre">Single</span></code>)
+Always use single quotes.</p>
+<div class="highlight-js"><div class="highlight"><pre><span></span><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"><code class="docutils literal"><span class="pre">JSQS_Double</span></code> (in configuration: <code class="docutils literal"><span class="pre">Double</span></code>)
+Always use double quotes.</p>
+<div class="highlight-js"><div class="highlight"><pre><span></span><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> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">Whether to wrap JavaScript import/export statements.</p>
+<div class="last highlight-js"><div class="highlight"><pre><span></span><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> (<code class="docutils literal"><span class="pre">bool</span></code>)</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></span><span class="nb">true</span><span class="o">:</span> <span class="nb">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> (<code class="docutils literal"><span class="pre">LanguageKind</span></code>)</dt>
+<dd><p class="first">Language, this format style is targeted at.</p>
+<p>Possible values:</p>
+<ul class="last simple">
+<li><code class="docutils literal"><span class="pre">LK_None</span></code> (in configuration: <code class="docutils literal"><span class="pre">None</span></code>)
+Do not use.</li>
+<li><code class="docutils literal"><span class="pre">LK_Cpp</span></code> (in configuration: <code class="docutils literal"><span class="pre">Cpp</span></code>)
+Should be used for C, C++.</li>
+<li><code class="docutils literal"><span class="pre">LK_Java</span></code> (in configuration: <code class="docutils literal"><span class="pre">Java</span></code>)
+Should be used for Java.</li>
+<li><code class="docutils literal"><span class="pre">LK_JavaScript</span></code> (in configuration: <code class="docutils literal"><span class="pre">JavaScript</span></code>)
+Should be used for JavaScript.</li>
+<li><code class="docutils literal"><span class="pre">LK_ObjC</span></code> (in configuration: <code class="docutils literal"><span class="pre">ObjC</span></code>)
+Should be used for Objective-C, Objective-C++.</li>
+<li><code class="docutils literal"><span class="pre">LK_Proto</span></code> (in configuration: <code class="docutils literal"><span class="pre">Proto</span></code>)
+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><code class="docutils literal"><span class="pre">LK_TableGen</span></code> (in configuration: <code class="docutils literal"><span class="pre">TableGen</span></code>)
+Should be used for TableGen code.</li>
+<li><code class="docutils literal"><span class="pre">LK_TextProto</span></code> (in configuration: <code class="docutils literal"><span class="pre">TextProto</span></code>)
+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> (<code class="docutils literal"><span class="pre">std::string</span></code>)</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></span><span class="cp"># With:</span>
+<span class="nl">MacroBlockBegin</span><span class="p">:</span> <span class="s">"^NS_MAP_BEGIN|\</span>
+<span class="s">NS_TABLE_HEAD$"</span>
+<span class="nl">MacroBlockEnd</span><span class="p">:</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="nf">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="nf">bar</span><span class="p">();</span>
+<span class="n">NS_TABLE_FOO_END</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>MacroBlockEnd</strong> (<code class="docutils literal"><span class="pre">std::string</span></code>)</dt>
+<dd>A regular expression matching macros that end a block.</dd>
+<dt><strong>MaxEmptyLinesToKeep</strong> (<code class="docutils literal"><span class="pre">unsigned</span></code>)</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></span><span class="nl">MaxEmptyLinesToKeep</span><span class="p">:</span> <span class="mi">1</span> <span class="n">vs</span><span class="p">.</span> <span class="nl">MaxEmptyLinesToKeep</span><span class="p">:</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> (<code class="docutils literal"><span class="pre">NamespaceIndentationKind</span></code>)</dt>
+<dd><p class="first">The indentation used for namespaces.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><code class="docutils literal"><span class="pre">NI_None</span></code> (in configuration: <code class="docutils literal"><span class="pre">None</span></code>)
+Donât indent in namespaces.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><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"><code class="docutils literal"><span class="pre">NI_Inner</span></code> (in configuration: <code class="docutils literal"><span class="pre">Inner</span></code>)
+Indent only in inner namespaces (nested in other namespaces).</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><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"><code class="docutils literal"><span class="pre">NI_All</span></code> (in configuration: <code class="docutils literal"><span class="pre">All</span></code>)
+Indent in all namespaces.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><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>ObjCBinPackProtocolList</strong> (<code class="docutils literal"><span class="pre">BinPackStyle</span></code>)</dt>
+<dd><p class="first">Controls bin-packing Objective-C protocol conformance list
+items into as few lines as possible when they go over <code class="docutils literal"><span class="pre">ColumnLimit</span></code>.</p>
+<p>If <code class="docutils literal"><span class="pre">Auto</span></code> (the default), delegates to the value in
+<code class="docutils literal"><span class="pre">BinPackParameters</span></code>. If that is <code class="docutils literal"><span class="pre">true</span></code>, bin-packs Objective-C
+protocol conformance list items into as few lines as possible
+whenever they go over <code class="docutils literal"><span class="pre">ColumnLimit</span></code>.</p>
+<p>If <code class="docutils literal"><span class="pre">Always</span></code>, always bin-packs Objective-C protocol conformance
+list items into as few lines as possible whenever they go over
+<code class="docutils literal"><span class="pre">ColumnLimit</span></code>.</p>
+<p>If <code class="docutils literal"><span class="pre">Never</span></code>, lays out Objective-C protocol conformance list items
+onto individual lines whenever they go over <code class="docutils literal"><span class="pre">ColumnLimit</span></code>.</p>
+<div class="highlight-objc"><div class="highlight"><pre><span></span><span class="n">Always</span> <span class="p">(</span><span class="n">or</span> <span class="n">Auto</span><span class="p">,</span> <span class="k">if</span> <span class="n">BinPackParameters</span><span class="o">=</span><span class="nb">true</span><span class="p">)</span><span class="o">:</span>
+<span class="k">@interface</span> <span class="nc">ccccccccccccc</span> <span class="p">()</span> <span class="o"><</span>
+ <span class="n">ccccccccccccc</span><span class="p">,</span> <span class="n">ccccccccccccc</span><span class="p">,</span>
+ <span class="n">ccccccccccccc</span><span class="p">,</span> <span class="n">ccccccccccccc</span><span class="o">></span> <span class="p">{</span>
+<span class="p">}</span>
+
+<span class="n">Never</span> <span class="p">(</span><span class="n">or</span> <span class="n">Auto</span><span class="p">,</span> <span class="k">if</span> <span class="n">BinPackParameters</span><span class="o">=</span><span class="nb">false</span><span class="p">)</span><span class="o">:</span>
+<span class="k">@interface</span> <span class="nc">ddddddddddddd</span> <span class="p">()</span> <span class="o"><</span>
+ <span class="n">ddddddddddddd</span><span class="p">,</span>
+ <span class="n">ddddddddddddd</span><span class="p">,</span>
+ <span class="n">ddddddddddddd</span><span class="p">,</span>
+ <span class="n">ddddddddddddd</span><span class="o">></span> <span class="p">{</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>Possible values:</p>
+<ul class="last simple">
+<li><code class="docutils literal"><span class="pre">BPS_Auto</span></code> (in configuration: <code class="docutils literal"><span class="pre">Auto</span></code>)
+Automatically determine parameter bin-packing behavior.</li>
+<li><code class="docutils literal"><span class="pre">BPS_Always</span></code> (in configuration: <code class="docutils literal"><span class="pre">Always</span></code>)
+Always bin-pack parameters.</li>
+<li><code class="docutils literal"><span class="pre">BPS_Never</span></code> (in configuration: <code class="docutils literal"><span class="pre">Never</span></code>)
+Never bin-pack parameters.</li>
+</ul>
+</dd>
+<dt><strong>ObjCBlockIndentWidth</strong> (<code class="docutils literal"><span class="pre">unsigned</span></code>)</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></span><span class="nl">ObjCBlockIndentWidth</span><span class="p">:</span> <span class="mi">4</span>
+
+<span class="p">[</span><span class="n">operation</span> <span class="nl">setCompletionBlock</span><span class="p">:</span><span class="o">^</span><span class="p">{</span>
+ <span class="p">[</span><span class="nb">self</span> <span class="n">onOperationDone</span><span class="p">];</span>
+<span class="p">}];</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>ObjCSpaceAfterProperty</strong> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd>Add a space after <code class="docutils literal"><span class="pre">@property</span></code> in Objective-C, i.e. use
+<code class="docutils literal"><span class="pre">@property</span> <span class="pre">(readonly)</span></code> instead of <code class="docutils literal"><span class="pre">@property(readonly)</span></code>.</dd>
+<dt><strong>ObjCSpaceBeforeProtocolList</strong> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd>Add a space in front of an Objective-C protocol list, i.e. use
+<code class="docutils literal"><span class="pre">Foo</span> <span class="pre"><Protocol></span></code> instead of <code class="docutils literal"><span class="pre">Foo<Protocol></span></code>.</dd>
+<dt><strong>PenaltyBreakAssignment</strong> (<code class="docutils literal"><span class="pre">unsigned</span></code>)</dt>
+<dd>The penalty for breaking around an assignment operator.</dd>
+<dt><strong>PenaltyBreakBeforeFirstCallParameter</strong> (<code class="docutils literal"><span class="pre">unsigned</span></code>)</dt>
+<dd>The penalty for breaking a function call after <code class="docutils literal"><span class="pre">call(</span></code>.</dd>
+<dt><strong>PenaltyBreakComment</strong> (<code class="docutils literal"><span class="pre">unsigned</span></code>)</dt>
+<dd>The penalty for each line break introduced inside a comment.</dd>
+<dt><strong>PenaltyBreakFirstLessLess</strong> (<code class="docutils literal"><span class="pre">unsigned</span></code>)</dt>
+<dd>The penalty for breaking before the first <code class="docutils literal"><span class="pre"><<</span></code>.</dd>
+<dt><strong>PenaltyBreakString</strong> (<code class="docutils literal"><span class="pre">unsigned</span></code>)</dt>
+<dd>The penalty for each line break introduced inside a string literal.</dd>
+<dt><strong>PenaltyBreakTemplateDeclaration</strong> (<code class="docutils literal"><span class="pre">unsigned</span></code>)</dt>
+<dd>The penalty for breaking after template declaration.</dd>
+<dt><strong>PenaltyExcessCharacter</strong> (<code class="docutils literal"><span class="pre">unsigned</span></code>)</dt>
+<dd>The penalty for each character outside of the column limit.</dd>
+<dt><strong>PenaltyReturnTypeOnItsOwnLine</strong> (<code class="docutils literal"><span class="pre">unsigned</span></code>)</dt>
+<dd>Penalty for putting the return type of a function onto its own
+line.</dd>
+<dt><strong>PointerAlignment</strong> (<code class="docutils literal"><span class="pre">PointerAlignmentStyle</span></code>)</dt>
+<dd><p class="first">Pointer and reference alignment style.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><code class="docutils literal"><span class="pre">PAS_Left</span></code> (in configuration: <code class="docutils literal"><span class="pre">Left</span></code>)
+Align pointer to the left.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><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"><code class="docutils literal"><span class="pre">PAS_Right</span></code> (in configuration: <code class="docutils literal"><span class="pre">Right</span></code>)
+Align pointer to the right.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><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"><code class="docutils literal"><span class="pre">PAS_Middle</span></code> (in configuration: <code class="docutils literal"><span class="pre">Middle</span></code>)
+Align pointer in the middle.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><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> (<code class="docutils literal"><span class="pre">std::vector<RawStringFormat></span></code>)</dt>
+<dd><p class="first">Defines hints for detecting supported languages code blocks in raw
+strings.</p>
+<p>A raw string with a matching delimiter or a matching enclosing function
+name will be reformatted assuming the specified language based on the
+style for that language defined in the .clang-format file. If no style has
+been defined in the .clang-format file for the specific language, a
+predefined style given by âBasedOnStyleâ is used. If âBasedOnStyleâ is not
+found, the formatting is based on llvm style. A matching delimiter takes
+precedence over a matching enclosing function name for determining the
+language of the raw string contents.</p>
+<p>If a canonical delimiter is specified, occurrences of other delimiters for
+the same language will be updated to the canonical if possible.</p>
+<p>There should be at most one specification per language and each delimiter
+and enclosing function should not occur in multiple specifications.</p>
+<p>To configure this in the .clang-format file, use:</p>
+<div class="last highlight-yaml"><div class="highlight"><pre><span></span><span class="l l-Scalar l-Scalar-Plain">RawStringFormats</span><span class="p p-Indicator">:</span>
+ <span class="p p-Indicator">-</span> <span class="l l-Scalar l-Scalar-Plain">Language</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">TextProto</span>
+ <span class="l l-Scalar l-Scalar-Plain">Delimiters</span><span class="p p-Indicator">:</span>
+ <span class="p p-Indicator">-</span> <span class="s">'pb'</span>
+ <span class="p p-Indicator">-</span> <span class="s">'proto'</span>
+ <span class=" -Error"> </span><span class="l l-Scalar l-Scalar-Plain">EnclosingFunctions</span><span class="p p-Indicator">:</span>
+ <span class="p p-Indicator">-</span> <span class="s">'PARSE_TEXT_PROTO'</span>
+ <span class="l l-Scalar l-Scalar-Plain">BasedOnStyle</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">google</span>
+ <span class="p p-Indicator">-</span> <span class="l l-Scalar l-Scalar-Plain">Language</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">Cpp</span>
+ <span class="l l-Scalar l-Scalar-Plain">Delimiters</span><span class="p p-Indicator">:</span>
+ <span class="p p-Indicator">-</span> <span class="s">'cc'</span>
+ <span class="p p-Indicator">-</span> <span class="s">'cpp'</span>
+ <span class=" -Error"> </span><span class="l l-Scalar l-Scalar-Plain">BasedOnStyle</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">llvm</span>
+ <span class="l l-Scalar l-Scalar-Plain">CanonicalDelimiter</span><span class="p p-Indicator">:</span> <span class="s">'cc'</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>ReflowComments</strong> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">true</span></code>, clang-format will attempt to re-flow comments.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></span><span class="nb">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="nb">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> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">true</span></code>, clang-format will sort <code class="docutils literal"><span class="pre">#includes</span></code>.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></span><span class="nb">false</span><span class="o">:</span> <span class="nb">true</span><span class="o">:</span>
+<span class="cp">#include</span> <span class="cpf">"b.h" vs. #include "a.h"</span><span class="cp"></span>
+<span class="cp">#include</span> <span class="cpf">"a.h" #include "b.h"</span><span class="cp"></span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>SortUsingDeclarations</strong> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">true</span></code>, 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></span><span class="nb">false</span><span class="o">:</span> <span class="nb">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> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">true</span></code>, a space is inserted after C style casts.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></span><span class="nb">true</span><span class="o">:</span> <span class="nb">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> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">true</span></code>, a space will be inserted after the âtemplateâ keyword.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></span><span class="nb">true</span><span class="o">:</span> <span class="nb">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> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">false</span></code>, spaces will be removed before assignment operators.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></span><span class="nb">true</span><span class="o">:</span> <span class="nb">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>SpaceBeforeCpp11BracedList</strong> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">true</span></code>, a space will be inserted before a C++11 braced list
+used to initialize an object (after the preceding identifier or type).</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></span><span class="nb">true</span><span class="o">:</span> <span class="nb">false</span><span class="o">:</span>
+<span class="n">Foo</span> <span class="n">foo</span> <span class="p">{</span> <span class="n">bar</span> <span class="p">};</span> <span class="n">vs</span><span class="p">.</span> <span class="n">Foo</span> <span class="n">foo</span><span class="p">{</span> <span class="n">bar</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="n">vector</span><span class="o"><</span><span class="kt">int</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="n">vector</span><span class="o"><</span><span class="kt">int</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="k">new</span> <span class="kt">int</span><span class="p">[</span><span class="mi">3</span><span class="p">]</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>SpaceBeforeCtorInitializerColon</strong> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">false</span></code>, spaces will be removed before constructor initializer
+colon.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></span><span class="nb">true</span><span class="o">:</span> <span class="nb">false</span><span class="o">:</span>
+<span class="n">Foo</span><span class="o">::</span><span class="n">Foo</span><span class="p">()</span> <span class="o">:</span> <span class="n">a</span><span class="p">(</span><span class="n">a</span><span class="p">)</span> <span class="p">{}</span> <span class="n">Foo</span><span class="o">::</span><span class="n">Foo</span><span class="p">()</span><span class="o">:</span> <span class="n">a</span><span class="p">(</span><span class="n">a</span><span class="p">)</span> <span class="p">{}</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>SpaceBeforeInheritanceColon</strong> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">false</span></code>, spaces will be removed before inheritance colon.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></span><span class="nb">true</span><span class="o">:</span> <span class="nb">false</span><span class="o">:</span>
+<span class="k">class</span> <span class="nc">Foo</span> <span class="o">:</span> <span class="n">Bar</span> <span class="p">{}</span> <span class="n">vs</span><span class="p">.</span> <span class="k">class</span> <span class="nc">Foo</span><span class="o">:</span> <span class="n">Bar</span> <span class="p">{}</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>SpaceBeforeParens</strong> (<code class="docutils literal"><span class="pre">SpaceBeforeParensOptions</span></code>)</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"><code class="docutils literal"><span class="pre">SBPO_Never</span></code> (in configuration: <code class="docutils literal"><span class="pre">Never</span></code>)
+Never put a space before opening parentheses.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="kt">void</span> <span class="nf">f</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">if</span><span class="p">(</span><span class="nb">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"><code class="docutils literal"><span class="pre">SBPO_ControlStatements</span></code> (in configuration: <code class="docutils literal"><span class="pre">ControlStatements</span></code>)
+Put a space before opening parentheses only after control statement
+keywords (<code class="docutils literal"><span class="pre">for/if/while...</span></code>).</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="kt">void</span> <span class="nf">f</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="nb">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"><code class="docutils literal"><span class="pre">SBPO_Always</span></code> (in configuration: <code class="docutils literal"><span class="pre">Always</span></code>)
+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></span><span class="kt">void</span> <span class="nf">f</span> <span class="p">()</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="nb">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>SpaceBeforeRangeBasedForLoopColon</strong> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">false</span></code>, spaces will be removed before range-based for loop
+colon.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></span><span class="nb">true</span><span class="o">:</span> <span class="nb">false</span><span class="o">:</span>
+<span class="k">for</span> <span class="p">(</span><span class="k">auto</span> <span class="nl">v</span> <span class="p">:</span> <span class="n">values</span><span class="p">)</span> <span class="p">{}</span> <span class="n">vs</span><span class="p">.</span> <span class="k">for</span><span class="p">(</span><span class="k">auto</span> <span class="nl">v</span><span class="p">:</span> <span class="n">values</span><span class="p">)</span> <span class="p">{}</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>SpaceInEmptyParentheses</strong> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">true</span></code>, spaces may be inserted into <code class="docutils literal"><span class="pre">()</span></code>.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></span><span class="nb">true</span><span class="o">:</span> <span class="nb">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="nb">true</span><span class="p">)</span> <span class="p">{</span> <span class="k">if</span> <span class="p">(</span><span class="nb">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> (<code class="docutils literal"><span class="pre">unsigned</span></code>)</dt>
+<dd><p class="first">The number of spaces before trailing line comments
+(<code class="docutils literal"><span class="pre">//</span></code> - comments).</p>
+<p>This does not affect trailing block comments (<code class="docutils literal"><span class="pre">/*</span></code> - 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></span><span class="nl">SpacesBeforeTrailingComments</span><span class="p">:</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="nb">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> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">true</span></code>, spaces will be inserted after <code class="docutils literal"><span class="pre"><</span></code> and before <code class="docutils literal"><span class="pre">></span></code>
+in template argument lists.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></span><span class="nb">true</span><span class="o">:</span> <span class="nb">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> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">true</span></code>, spaces may be inserted into C style casts.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></span><span class="nb">true</span><span class="o">:</span> <span class="nb">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> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">true</span></code>, 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></span><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> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">true</span></code>, spaces will be inserted after <code class="docutils literal"><span class="pre">(</span></code> and before <code class="docutils literal"><span class="pre">)</span></code>.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></span><span class="nb">true</span><span class="o">:</span> <span class="nb">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> (<code class="docutils literal"><span class="pre">bool</span></code>)</dt>
+<dd><p class="first">If <code class="docutils literal"><span class="pre">true</span></code>, spaces will be inserted after <code class="docutils literal"><span class="pre">[</span></code> and before <code class="docutils literal"><span class="pre">]</span></code>.
+Lambdas or unspecified size array declarations will not be affected.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></span><span class="nb">true</span><span class="o">:</span> <span class="nb">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> (<code class="docutils literal"><span class="pre">LanguageStandard</span></code>)</dt>
+<dd><p class="first">Format compatible with this standard, e.g. use <code class="docutils literal"><span class="pre">A<A<int></span> <span class="pre">></span></code>
+instead of <code class="docutils literal"><span class="pre">A<A<int>></span></code> for <code class="docutils literal"><span class="pre">LS_Cpp03</span></code>.</p>
+<p>Possible values:</p>
+<ul class="last simple">
+<li><code class="docutils literal"><span class="pre">LS_Cpp03</span></code> (in configuration: <code class="docutils literal"><span class="pre">Cpp03</span></code>)
+Use C++03-compatible syntax.</li>
+<li><code class="docutils literal"><span class="pre">LS_Cpp11</span></code> (in configuration: <code class="docutils literal"><span class="pre">Cpp11</span></code>)
+Use features of C++11, C++14 and C++1z (e.g. <code class="docutils literal"><span class="pre">A<A<int>></span></code> instead of
+<code class="docutils literal"><span class="pre">A<A<int></span> <span class="pre">></span></code>).</li>
+<li><code class="docutils literal"><span class="pre">LS_Auto</span></code> (in configuration: <code class="docutils literal"><span class="pre">Auto</span></code>)
+Automatic detection based on the input.</li>
+</ul>
+</dd>
+<dt><strong>TabWidth</strong> (<code class="docutils literal"><span class="pre">unsigned</span></code>)</dt>
+<dd>The number of columns used for tab stops.</dd>
+<dt><strong>UseTab</strong> (<code class="docutils literal"><span class="pre">UseTabStyle</span></code>)</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><code class="docutils literal"><span class="pre">UT_Never</span></code> (in configuration: <code class="docutils literal"><span class="pre">Never</span></code>)
+Never use tab.</li>
+<li><code class="docutils literal"><span class="pre">UT_ForIndentation</span></code> (in configuration: <code class="docutils literal"><span class="pre">ForIndentation</span></code>)
+Use tabs only for indentation.</li>
+<li><code class="docutils literal"><span class="pre">UT_ForContinuationAndIndentation</span></code> (in configuration: <code class="docutils literal"><span class="pre">ForContinuationAndIndentation</span></code>)
+Use tabs only for line continuation and indentation.</li>
+<li><code class="docutils literal"><span class="pre">UT_Always</span></code> (in configuration: <code class="docutils literal"><span class="pre">Always</span></code>)
+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></span><span class="l l-Scalar l-Scalar-Plain">BasedOnStyle</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">LLVM</span>
+<span class="l l-Scalar l-Scalar-Plain">IndentWidth</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">8</span>
+<span class="l l-Scalar l-Scalar-Plain">UseTab</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">Always</span>
+<span class="l l-Scalar l-Scalar-Plain">BreakBeforeBraces</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">Linux</span>
+<span class="l l-Scalar l-Scalar-Plain">AllowShortIfStatementsOnASingleLine</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">false</span>
+<span class="l l-Scalar l-Scalar-Plain">IndentCaseLabels</span><span class="p p-Indicator">:</span> <span class="l l-Scalar 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></span><span class="kt">void</span> <span class="nf">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></span><span class="l l-Scalar l-Scalar-Plain">UseTab</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">Never</span>
+<span class="l l-Scalar l-Scalar-Plain">IndentWidth</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">4</span>
+<span class="l l-Scalar l-Scalar-Plain">BreakBeforeBraces</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">Allman</span>
+<span class="l l-Scalar l-Scalar-Plain">AllowShortIfStatementsOnASingleLine</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">false</span>
+<span class="l l-Scalar l-Scalar-Plain">IndentCaseLabels</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">false</span>
+<span class="l l-Scalar l-Scalar-Plain">ColumnLimit</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">0</span>
+</pre></div>
+</div>
+<p>The result is:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="kt">void</span> <span class="nf">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" role="navigation" aria-label="bottom navigation">
+
+ <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" role="contentinfo">
+ © Copyright 2007-2018, The Clang Team.
+ Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.6.4.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/7.0.0/tools/clang/docs/ClangPlugins.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/7.0.0/tools/clang/docs/ClangPlugins.html?rev=342530&view=auto
==============================================================================
--- www-releases/trunk/7.0.0/tools/clang/docs/ClangPlugins.html (added)
+++ www-releases/trunk/7.0.0/tools/clang/docs/ClangPlugins.html Wed Sep 19 02:40:08 2018
@@ -0,0 +1,181 @@
+
+<!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 7 documentation</title>
+ <link rel="stylesheet" href="_static/haiku.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: './',
+ VERSION: '7',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true,
+ SOURCELINK_SUFFIX: '.txt'
+ };
+ </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="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+ <link rel="index" title="Index" href="genindex.html" />
+ <link rel="search" title="Search" href="search.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" role="banner"><h1 class="heading"><a href="index.html">
+ <span>Clang 7 documentation</span></a></h1>
+ <h2 class="heading"><span>Clang Plugins</span></h2>
+ </div>
+ <div class="topnav" role="navigation" aria-label="top navigation">
+
+ <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"><span class="doc">FrontendAction
+tutorial</span></a> on how to write a <code class="docutils literal"><span class="pre">FrontendAction</span></code> using the
+<code class="docutils literal"><span class="pre">RecursiveASTVisitor</span></code>. 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 <code class="docutils literal"><span class="pre">PluginASTAction</span></code><a class="headerlink" href="#writing-a-pluginastaction" title="Permalink to this headline">¶</a></h2>
+<p>The main difference from writing normal <code class="docutils literal"><span class="pre">FrontendActions</span></code> is that you can
+handle plugin command line options. The <code class="docutils literal"><span class="pre">PluginASTAction</span></code> base class declares
+a <code class="docutils literal"><span class="pre">ParseArgs</span></code> method which you have to implement in your plugin.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="kt">bool</span> <span class="nf">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="nb">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 <code class="docutils literal"><span class="pre">FrontendPluginRegistry::Add<></span></code>:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><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 <code class="docutils literal"><span class="pre">PragmaHandler</span></code> and
+registering it using <code class="docutils literal"><span class="pre">PragmaHandlerRegistry::Add<></span></code>:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><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 <code class="docutils literal"><span class="pre">print-function-names</span></code> 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></span><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>
+ -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -D_GNU_SOURCE <span class="se">\</span>
+ -I<span class="nv">$BD</span>/tools/clang/include -Itools/clang/include -I<span class="nv">$BD</span>/include -Iinclude <span class="se">\</span>
+ tools/clang/tools/clang-check/ClangCheck.cpp -fsyntax-only <span class="se">\</span>
+ -Xclang -load -Xclang <span class="nv">$BD</span>/lib/PrintFunctionNames.so -Xclang <span class="se">\</span>
+ -plugin -Xclang print-fns
+</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 <code class="docutils literal"><span class="pre">getActionType</span></code> 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></span><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="k">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" role="navigation" aria-label="bottom navigation">
+
+ <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" role="contentinfo">
+ © Copyright 2007-2018, The Clang Team.
+ Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.6.4.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/7.0.0/tools/clang/docs/ClangTools.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/7.0.0/tools/clang/docs/ClangTools.html?rev=342530&view=auto
==============================================================================
--- www-releases/trunk/7.0.0/tools/clang/docs/ClangTools.html (added)
+++ www-releases/trunk/7.0.0/tools/clang/docs/ClangTools.html Wed Sep 19 02:40:08 2018
@@ -0,0 +1,219 @@
+
+<!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 7 documentation</title>
+ <link rel="stylesheet" href="_static/haiku.css" type="text/css" />
+ <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: './',
+ VERSION: '7',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true,
+ SOURCELINK_SUFFIX: '.txt'
+ };
+ </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="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+ <link rel="index" title="Index" href="genindex.html" />
+ <link rel="search" title="Search" href="search.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" role="banner"><h1 class="heading"><a href="index.html">
+ <span>Clang 7 documentation</span></a></h1>
+ <h2 class="heading"><span>Overview</span></h2>
+ </div>
+ <div class="topnav" role="navigation" aria-label="top navigation">
+
+ <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><code class="docutils literal"><span class="pre">cd</span> <span class="pre">llvm/tools/clang/tools</span></code></li>
+<li><code 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></code></li>
+</ul>
+</li>
+<li>Or with Git:<ul>
+<li><code class="docutils literal"><span class="pre">cd</span> <span class="pre">llvm/tools/clang/tools</span></code></li>
+<li><code 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></code></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"><span class="doc">LibTooling</span></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><code class="docutils literal"><span class="pre">clang-check</span></code><a class="headerlink" href="#clang-check" title="Permalink to this headline">¶</a></h3>
+<p><a class="reference internal" href="ClangCheck.html"><span class="doc">ClangCheck</span></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"><span class="doc">How To Setup Clang Tooling For LLVM</span></a> for
+instructions on how to setup and used <cite>clang-check</cite>.</p>
+</div>
+<div class="section" id="clang-format">
+<h3><code class="docutils literal"><span class="pre">clang-format</span></code><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"><span class="doc">library</span></a> and a <a class="reference internal" href="ClangFormat.html"><span class="doc">stand-alone tool</span></a> with the goal of automatically reformatting C++ sources files
+according to configurable style guides. To do so, clang-format uses Clangâs
+<code class="docutils literal"><span class="pre">Lexer</span></code> 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><code class="docutils literal"><span class="pre">clang-tidy</span></code><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 (<code class="docutils literal"><span class="pre">(type)</span> <span class="pre">value</span></code>) to
+appropriate C++ cast (<code class="docutils literal"><span class="pre">static_cast</span></code>, <code class="docutils literal"><span class="pre">const_cast</span></code> or
+<code class="docutils literal"><span class="pre">reinterpret_cast</span></code>).</p>
+</li>
+<li><p class="first">Non-member <code class="docutils literal"><span class="pre">begin()</span></code> and <code class="docutils literal"><span class="pre">end()</span></code> conversion tool. Will convert
+<code class="docutils literal"><span class="pre">foo.begin()</span></code> into <code class="docutils literal"><span class="pre">begin(foo)</span></code> and similarly for <code class="docutils literal"><span class="pre">end()</span></code>, where
+<code class="docutils literal"><span class="pre">foo</span></code> is a standard container. We could also detect similar patterns for
+arrays.</p>
+</li>
+<li><p class="first"><code class="docutils literal"><span class="pre">tr1</span></code> 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></span><span class="cp">#include</span> <span class="cpf"><tr1/unordered_map></span><span class="cp"></span>
+<span class="kt">int</span> <span class="nf">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></span><span class="cp">#include</span> <span class="cpf"><unordered_map></span><span class="cp"></span>
+<span class="kt">int</span> <span class="nf">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 <code class="docutils literal"><span class="pre">auto</span></code>. Will convert <code class="docutils literal"><span class="pre">auto</span></code> to an explicit type or add
+comments with deduced types. The motivation is that there are developers
+that donât want to use <code class="docutils literal"><span class="pre">auto</span></code> 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></span><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></span><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" role="navigation" aria-label="bottom navigation">
+
+ <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" role="contentinfo">
+ © Copyright 2007-2018, The Clang Team.
+ Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.6.4.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/7.0.0/tools/clang/docs/CommandGuide/clang.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/7.0.0/tools/clang/docs/CommandGuide/clang.html?rev=342530&view=auto
==============================================================================
--- www-releases/trunk/7.0.0/tools/clang/docs/CommandGuide/clang.html (added)
+++ www-releases/trunk/7.0.0/tools/clang/docs/CommandGuide/clang.html Wed Sep 19 02:40:08 2018
@@ -0,0 +1,847 @@
+
+<!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 7 documentation</title>
+ <link rel="stylesheet" href="../_static/haiku.css" type="text/css" />
+ <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: '../',
+ VERSION: '7',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true,
+ SOURCELINK_SUFFIX: '.txt'
+ };
+ </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="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+ <link rel="index" title="Index" href="../genindex.html" />
+ <link rel="search" title="Search" href="../search.html" />
+ <link rel="next" title="diagtool - clang diagnostics tool" href="diagtool.html" />
+ <link rel="prev" title="Clang âmanâ pages" href="index.html" />
+ </head>
+ <body>
+ <div class="header" role="banner"><h1 class="heading"><a href="../index.html">
+ <span>Clang 7 documentation</span></a></h1>
+ <h2 class="heading"><span>clang - the Clang C, C++, and Objective-C compiler</span></h2>
+ </div>
+ <div class="topnav" role="navigation" aria-label="top navigation">
+
+ <p>
+ « <a href="index.html">Clang âmanâ pages</a>
+ ::
+ <a class="uplink" href="../index.html">Contents</a>
+ ::
+ <a href="diagtool.html">diagtool - clang diagnostics tool</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">
+<code class="descname">-E</code><code class="descclassname"></code><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">
+<code class="descname">-fsyntax-only</code><code class="descclassname"></code><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">
+<code class="descname">-S</code><code class="descclassname"></code><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">
+<code class="descname">-c</code><code class="descclassname"></code><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 id="cmdoption-arg-no">
+<code class="descname">no</code><code class="descclassname"> stage selection option</code><a class="headerlink" href="#cmdoption-arg-no" title="Permalink to this definition">¶</a></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">
+<code class="descname">-x</code><code class="descclassname"> <language></code><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">
+<code class="descname">-std</code><code class="descclassname">=<standard></code><a class="headerlink" href="#cmdoption-std" title="Permalink to this definition">¶</a></dt>
+<dd><p>Specify the language standard to compile for.</p>
+<p>Supported values for the C language are:</p>
+<blockquote>
+<div><div class="line-block">
+<div class="line"><code class="docutils literal"><span class="pre">c89</span></code></div>
+<div class="line"><code class="docutils literal"><span class="pre">c90</span></code></div>
+<div class="line"><code class="docutils literal"><span class="pre">iso9899:1990</span></code></div>
+</div>
+<blockquote>
+<div>ISO C 1990</div></blockquote>
+<div class="line-block">
+<div class="line"><code class="docutils literal"><span class="pre">iso9899:199409</span></code></div>
+</div>
+<blockquote>
+<div>ISO C 1990 with amendment 1</div></blockquote>
+<div class="line-block">
+<div class="line"><code class="docutils literal"><span class="pre">gnu89</span></code></div>
+<div class="line"><code class="docutils literal"><span class="pre">gnu90</span></code></div>
+</div>
+<blockquote>
+<div>ISO C 1990 with GNU extensions</div></blockquote>
+<div class="line-block">
+<div class="line"><code class="docutils literal"><span class="pre">c99</span></code></div>
+<div class="line"><code class="docutils literal"><span class="pre">iso9899:1999</span></code></div>
+</div>
+<blockquote>
+<div>ISO C 1999</div></blockquote>
+<div class="line-block">
+<div class="line"><code class="docutils literal"><span class="pre">gnu99</span></code></div>
+</div>
+<blockquote>
+<div>ISO C 1999 with GNU extensions</div></blockquote>
+<div class="line-block">
+<div class="line"><code class="docutils literal"><span class="pre">c11</span></code></div>
+<div class="line"><code class="docutils literal"><span class="pre">iso9899:2011</span></code></div>
+</div>
+<blockquote>
+<div>ISO C 2011</div></blockquote>
+<div class="line-block">
+<div class="line"><code class="docutils literal"><span class="pre">gnu11</span></code></div>
+</div>
+<blockquote>
+<div>ISO C 2011 with GNU extensions</div></blockquote>
+<div class="line-block">
+<div class="line"><code class="docutils literal"><span class="pre">c17</span></code></div>
+<div class="line"><code class="docutils literal"><span class="pre">iso9899:2017</span></code></div>
+</div>
+<blockquote>
+<div>ISO C 2017</div></blockquote>
+<div class="line-block">
+<div class="line"><code class="docutils literal"><span class="pre">gnu17</span></code></div>
+</div>
+<blockquote>
+<div>ISO C 2017 with GNU extensions</div></blockquote>
+</div></blockquote>
+<p>The default C language standard is <code class="docutils literal"><span class="pre">gnu11</span></code>, except on PS4, where it is
+<code class="docutils literal"><span class="pre">gnu99</span></code>.</p>
+<p>Supported values for the C++ language are:</p>
+<blockquote>
+<div><div class="line-block">
+<div class="line"><code class="docutils literal"><span class="pre">c++98</span></code></div>
+<div class="line"><code class="docutils literal"><span class="pre">c++03</span></code></div>
+</div>
+<blockquote>
+<div>ISO C++ 1998 with amendments</div></blockquote>
+<div class="line-block">
+<div class="line"><code class="docutils literal"><span class="pre">gnu++98</span></code></div>
+<div class="line"><code class="docutils literal"><span class="pre">gnu++03</span></code></div>
+</div>
+<blockquote>
+<div>ISO C++ 1998 with amendments and GNU extensions</div></blockquote>
+<div class="line-block">
+<div class="line"><code class="docutils literal"><span class="pre">c++11</span></code></div>
+</div>
+<blockquote>
+<div>ISO C++ 2011 with amendments</div></blockquote>
+<div class="line-block">
+<div class="line"><code class="docutils literal"><span class="pre">gnu++11</span></code></div>
+</div>
+<blockquote>
+<div>ISO C++ 2011 with amendments and GNU extensions</div></blockquote>
+<div class="line-block">
+<div class="line"><code class="docutils literal"><span class="pre">c++14</span></code></div>
+</div>
+<blockquote>
+<div>ISO C++ 2014 with amendments</div></blockquote>
+<div class="line-block">
+<div class="line"><code class="docutils literal"><span class="pre">gnu++14</span></code></div>
+</div>
+<blockquote>
+<div>ISO C++ 2014 with amendments and GNU extensions</div></blockquote>
+<div class="line-block">
+<div class="line"><code class="docutils literal"><span class="pre">c++17</span></code></div>
+</div>
+<blockquote>
+<div>ISO C++ 2017 with amendments</div></blockquote>
+<div class="line-block">
+<div class="line"><code class="docutils literal"><span class="pre">gnu++17</span></code></div>
+</div>
+<blockquote>
+<div>ISO C++ 2017 with amendments and GNU extensions</div></blockquote>
+<div class="line-block">
+<div class="line"><code class="docutils literal"><span class="pre">c++2a</span></code></div>
+</div>
+<blockquote>
+<div>Working draft for ISO C++ 2020</div></blockquote>
+<div class="line-block">
+<div class="line"><code class="docutils literal"><span class="pre">gnu++2a</span></code></div>
+</div>
+<blockquote>
+<div>Working draft for ISO C++ 2020 with GNU extensions</div></blockquote>
+</div></blockquote>
+<p>The default C++ language standard is <code class="docutils literal"><span class="pre">gnu++14</span></code>.</p>
+<p>Supported values for the OpenCL language are:</p>
+<blockquote>
+<div><div class="line-block">
+<div class="line"><code class="docutils literal"><span class="pre">cl1.0</span></code></div>
+</div>
+<blockquote>
+<div>OpenCL 1.0</div></blockquote>
+<div class="line-block">
+<div class="line"><code class="docutils literal"><span class="pre">cl1.1</span></code></div>
+</div>
+<blockquote>
+<div>OpenCL 1.1</div></blockquote>
+<div class="line-block">
+<div class="line"><code class="docutils literal"><span class="pre">cl1.2</span></code></div>
+</div>
+<blockquote>
+<div>OpenCL 1.2</div></blockquote>
+<div class="line-block">
+<div class="line"><code class="docutils literal"><span class="pre">cl2.0</span></code></div>
+</div>
+<blockquote>
+<div>OpenCL 2.0</div></blockquote>
+</div></blockquote>
+<p>The default OpenCL language standard is <code class="docutils literal"><span class="pre">cl1.0</span></code>.</p>
+<p>Supported values for the CUDA language are:</p>
+<blockquote>
+<div><div class="line-block">
+<div class="line"><code class="docutils literal"><span class="pre">cuda</span></code></div>
+</div>
+<blockquote>
+<div>NVIDIA CUDA(tm)</div></blockquote>
+</div></blockquote>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-stdlib">
+<code class="descname">-stdlib</code><code class="descclassname">=<library></code><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">
+<code class="descname">-rtlib</code><code class="descclassname">=<library></code><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">
+<code class="descname">-ansi</code><code class="descclassname"></code><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">
+<code class="descname">-ObjC</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-ObjC++</code><code class="descclassname"></code><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">
+<code class="descname">-trigraphs</code><code class="descclassname"></code><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">
+<code class="descname">-ffreestanding</code><code class="descclassname"></code><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">
+<code class="descname">-fno-builtin</code><code class="descclassname"></code><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
+<code class="xref c c-func docutils literal"><span class="pre">strlen()</span></code> and <code class="xref c c-func docutils literal"><span class="pre">malloc()</span></code>.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fmath-errno">
+<code class="descname">-fmath-errno</code><code class="descclassname"></code><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 <code class="xref c c-data docutils literal"><span class="pre">errno</span></code>.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fpascal-strings">
+<code class="descname">-fpascal-strings</code><code class="descclassname"></code><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">
+<code class="descname">-fms-extensions</code><code class="descclassname"></code><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">
+<code class="descname">-fmsc-version</code><code class="descclassname">=</code><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">
+<code class="descname">-fborland-extensions</code><code class="descclassname"></code><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">
+<code class="descname">-fwritable-strings</code><code class="descclassname"></code><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">
+<code class="descname">-flax-vector-conversions</code><code class="descclassname"></code><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">
+<code class="descname">-fblocks</code><code class="descclassname"></code><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">
+<code class="descname">-fobjc-abi-version</code><code class="descclassname">=version</code><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">
+<code class="descname">-fobjc-nonfragile-abi-version</code><code class="descclassname">=<version></code><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"><code class="xref std std-option docutils literal"><span class="pre">-fobjc-nonfragile-abi</span></code></a>, or because it is the platform
+default).</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fobjc-nonfragile-abi">
+<code class="descname">-fobjc-nonfragile-abi</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-objc-nonfragile-abi</code><code class="descclassname"></code><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 <a class="reference internal" href="#cmdoption-fobjc-nonfragile-abi"><code class="xref std std-option docutils literal"><span class="pre">-fno-objc-nonfragile-abi</span></code></a>.</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">
+<code class="descname">-arch</code><code class="descclassname"> <architecture></code><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">
+<code class="descname">-mmacosx-version-min</code><code class="descclassname">=<version></code><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">
+<code class="descname">-miphoneos-version-min</code><code class="descclassname"></code><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">
+<code class="descname">-march</code><code class="descclassname">=<cpu></code><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">
+<code class="descname">-O0</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-O1</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-O2</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-O3</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-Ofast</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-Os</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-Oz</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-Og</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-O</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-O4</code><code class="descclassname"></code><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"><code class="xref std std-option docutils literal"><span class="pre">-O0</span></code></a> Means âno optimizationâ: this level compiles the fastest and
+generates the most debuggable code.</p>
+<p><a class="reference internal" href="#cmdoption-o0"><code class="xref std std-option docutils literal"><span class="pre">-O1</span></code></a> Somewhere between <a class="reference internal" href="#cmdoption-o0"><code class="xref std std-option docutils literal"><span class="pre">-O0</span></code></a> and <a class="reference internal" href="#cmdoption-o0"><code class="xref std std-option docutils literal"><span class="pre">-O2</span></code></a>.</p>
+<p><a class="reference internal" href="#cmdoption-o0"><code class="xref std std-option docutils literal"><span class="pre">-O2</span></code></a> Moderate level of optimization which enables most
+optimizations.</p>
+<p><a class="reference internal" href="#cmdoption-o0"><code class="xref std std-option docutils literal"><span class="pre">-O3</span></code></a> Like <a class="reference internal" href="#cmdoption-o0"><code class="xref std std-option docutils literal"><span class="pre">-O2</span></code></a>, 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><a class="reference internal" href="#cmdoption-o0"><code class="xref std std-option docutils literal"><span class="pre">-Ofast</span></code></a> Enables all the optimizations from <a class="reference internal" href="#cmdoption-o0"><code class="xref std std-option docutils literal"><span class="pre">-O3</span></code></a> along
+with other aggressive optimizations that may violate strict compliance with
+language standards.</p>
+<p><a class="reference internal" href="#cmdoption-o0"><code class="xref std std-option docutils literal"><span class="pre">-Os</span></code></a> Like <a class="reference internal" href="#cmdoption-o0"><code class="xref std std-option docutils literal"><span class="pre">-O2</span></code></a> with extra optimizations to reduce code
+size.</p>
+<p><a class="reference internal" href="#cmdoption-o0"><code class="xref std std-option docutils literal"><span class="pre">-Oz</span></code></a> Like <a class="reference internal" href="#cmdoption-o0"><code class="xref std std-option docutils literal"><span class="pre">-Os</span></code></a> (and thus <a class="reference internal" href="#cmdoption-o0"><code class="xref std std-option docutils literal"><span class="pre">-O2</span></code></a>), but reduces code
+size further.</p>
+<p><a class="reference internal" href="#cmdoption-o0"><code class="xref std std-option docutils literal"><span class="pre">-Og</span></code></a> Like <a class="reference internal" href="#cmdoption-o0"><code class="xref std std-option docutils literal"><span class="pre">-O1</span></code></a>. In future versions, this option might
+disable different optimizations in order to improve debuggability.</p>
+<p><a class="reference internal" href="#cmdoption-o0"><code class="xref std std-option docutils literal"><span class="pre">-O</span></code></a> Equivalent to <a class="reference internal" href="#cmdoption-o0"><code class="xref std std-option docutils literal"><span class="pre">-O2</span></code></a>.</p>
+<p><a class="reference internal" href="#cmdoption-o0"><code class="xref std std-option docutils literal"><span class="pre">-O4</span></code></a> and higher</p>
+<blockquote>
+<div>Currently equivalent to <a class="reference internal" href="#cmdoption-o0"><code class="xref std std-option docutils literal"><span class="pre">-O3</span></code></a></div></blockquote>
+</div></blockquote>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-g">
+<code class="descname">-g</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-gline-tables-only</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-gmodules</code><code class="descclassname"></code><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"><code class="xref std std-option docutils literal"><span class="pre">-O0</span></code></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"><code class="xref std std-option docutils literal"><span class="pre">-g</span></code></a> Generate debug information.</p>
+<p><a class="reference internal" href="../UsersManual.html#cmdoption-gline-tables-only"><code class="xref std std-option docutils literal"><span class="pre">-gline-tables-only</span></code></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><a class="reference internal" href="#cmdoption-g"><code class="xref std std-option docutils literal"><span class="pre">-gmodules</span></code></a> 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">
+<code class="descname">-fstandalone-debug</code><code class="descclassname"> -fno-standalone-debug</code><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"><code class="xref std std-option docutils literal"><span class="pre">-fstandalone-debug</span></code></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">
+<code class="descname">-fexceptions</code><code class="descclassname"></code><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">
+<code class="descname">-ftrapv</code><code class="descclassname"></code><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">
+<code class="descname">-fvisibility</code><code class="descclassname"></code><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">
+<code class="descname">-fcommon</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fno-common</code><code class="descclassname"></code><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 <a class="reference internal" href="#cmdoption-fcommon"><code class="xref std std-option docutils literal"><span class="pre">-fno-common</span></code></a>.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-ftls-model">
+<code class="descname">-ftls-model</code><code class="descclassname">=<model></code><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">
+<code class="descname">-flto</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-flto</code><code class="descclassname">=full</code><code class="descclassname">, </code><code class="descname">-flto</code><code class="descclassname">=thin</code><code class="descclassname">, </code><code class="descname">-emit-llvm</code><code class="descclassname"></code><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"><code class="xref std std-option docutils literal"><span class="pre">-S</span></code></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"><code class="xref std std-option docutils literal"><span class="pre">-flto</span></code></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"><span class="doc">ThinLTO</span></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 id="cmdoption">
+<code class="descname">-###</code><code class="descclassname"></code><a class="headerlink" href="#cmdoption" title="Permalink to this definition">¶</a></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">
+<code class="descname">--help</code><code class="descclassname"></code><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">
+<code class="descname">-Qunused-arguments</code><code class="descclassname"></code><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-args">
+<code class="descname">-Wa,<args></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-wa-args" 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-args">
+<code class="descname">-Wl,<args></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-wl-args" 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-args">
+<code class="descname">-Wp,<args></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-wp-args" 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">
+<code class="descname">-Xanalyzer</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-Xassembler</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-Xlinker</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-Xpreprocessor</code><code class="descclassname"> <arg></code><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">
+<code class="descname">-o</code><code class="descclassname"> <file></code><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">
+<code class="descname">-print-file-name</code><code class="descclassname">=<file></code><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">
+<code class="descname">-print-libgcc-file-name</code><code class="descclassname"></code><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">
+<code class="descname">-print-prog-name</code><code class="descclassname">=<name></code><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">
+<code class="descname">-print-search-dirs</code><code class="descclassname"></code><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">
+<code class="descname">-save-temps</code><code class="descclassname"></code><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">
+<code class="descname">-save-stats</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-save-stats</code><code class="descclassname">=cwd</code><code class="descclassname">, </code><code class="descname">-save-stats</code><code class="descclassname">=obj</code><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"><code class="xref std std-option docutils literal"><span class="pre">-save-stats</span></code></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">
+<code class="descname">-integrated-as</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-no-integrated-as</code><code class="descclassname"></code><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">
+<code class="descname">-time</code><code class="descclassname"></code><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">
+<code class="descname">-ftime-report</code><code class="descclassname"></code><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">
+<code class="descname">-v</code><code class="descclassname"></code><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">
+<code class="descname">-fshow-column</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fshow-source-location</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fcaret-diagnostics</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fdiagnostics-fixit-info</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fdiagnostics-parseable-fixits</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fdiagnostics-print-source-range-info</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fprint-source-range-info</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fdiagnostics-show-option</code><code class="descclassname"></code><code class="descclassname">, </code><code class="descname">-fmessage-length</code><code class="descclassname"></code><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-macroname">
+<code class="descname">-D<macroname></code><code class="descclassname">=<value></code><a class="headerlink" href="#cmdoption-d-macroname" 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-macroname">
+<code class="descname">-U<macroname></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-u-macroname" 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">
+<code class="descname">-include</code><code class="descclassname"> <filename></code><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-directory">
+<code class="descname">-I<directory></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-i-directory" 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-directory">
+<code class="descname">-F<directory></code><code class="descclassname"></code><a class="headerlink" href="#cmdoption-f-directory" 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">
+<code class="descname">-nostdinc</code><code class="descclassname"></code><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">
+<code class="descname">-nostdlibinc</code><code class="descclassname"></code><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">
+<code class="descname">-nobuiltininc</code><code class="descclassname"></code><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">
+<code class="descname">TMPDIR, TEMP, TMP</code><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">
+<code class="descname">CPATH</code><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">
+<code class="descname">C_INCLUDE_PATH, OBJC_INCLUDE_PATH, CPLUS_INCLUDE_PATH, OBJCPLUS_INCLUDE_PATH</code><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"><code class="xref std std-envvar docutils literal"><span class="pre">CPATH</span></code></a>, which are
+only used when processing the appropriate language.</p>
+</dd></dl>
+
+<dl class="envvar">
+<dt id="envvar-MACOSX_DEPLOYMENT_TARGET">
+<code class="descname">MACOSX_DEPLOYMENT_TARGET</code><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"><code class="xref std std-option docutils literal"><span class="pre">-mmacosx-version-min</span></code></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"><code class="xref std std-option docutils literal"><span class="pre">-E</span></code></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" role="navigation" aria-label="bottom navigation">
+
+ <p>
+ « <a href="index.html">Clang âmanâ pages</a>
+ ::
+ <a class="uplink" href="../index.html">Contents</a>
+ ::
+ <a href="diagtool.html">diagtool - clang diagnostics tool</a> »
+ </p>
+
+ </div>
+
+ <div class="footer" role="contentinfo">
+ © Copyright 2007-2018, The Clang Team.
+ Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.6.4.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/7.0.0/tools/clang/docs/CommandGuide/diagtool.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/7.0.0/tools/clang/docs/CommandGuide/diagtool.html?rev=342530&view=auto
==============================================================================
--- www-releases/trunk/7.0.0/tools/clang/docs/CommandGuide/diagtool.html (added)
+++ www-releases/trunk/7.0.0/tools/clang/docs/CommandGuide/diagtool.html Wed Sep 19 02:40:08 2018
@@ -0,0 +1,110 @@
+
+<!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>diagtool - clang diagnostics tool — Clang 7 documentation</title>
+ <link rel="stylesheet" href="../_static/haiku.css" type="text/css" />
+ <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: '../',
+ VERSION: '7',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true,
+ SOURCELINK_SUFFIX: '.txt'
+ };
+ </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="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+ <link rel="index" title="Index" href="../genindex.html" />
+ <link rel="search" title="Search" href="../search.html" />
+ <link rel="next" title="Frequently Asked Questions (FAQ)" href="../FAQ.html" />
+ <link rel="prev" title="clang - the Clang C, C++, and Objective-C compiler" href="clang.html" />
+ </head>
+ <body>
+ <div class="header" role="banner"><h1 class="heading"><a href="../index.html">
+ <span>Clang 7 documentation</span></a></h1>
+ <h2 class="heading"><span>diagtool - clang diagnostics tool</span></h2>
+ </div>
+ <div class="topnav" role="navigation" aria-label="top navigation">
+
+ <p>
+ « <a href="clang.html">clang - the Clang C, C++, and Objective-C compiler</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="diagtool-clang-diagnostics-tool">
+<h1>diagtool - clang diagnostics tool<a class="headerlink" href="#diagtool-clang-diagnostics-tool" 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">diagtool</strong> <em>command</em> [<em>args</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">diagtool</strong> is a combination of four tool for dealing with diagnostics in <strong class="program">clang</strong>.</p>
+</div>
+<div class="section" id="subcommands">
+<h2>SUBCOMMANDS<a class="headerlink" href="#subcommands" title="Permalink to this headline">¶</a></h2>
+<p><strong class="program">diagtool</strong> is separated into several subcommands each tailored to a
+different purpose. A brief summary of each command follows, with more detail in
+the sections that follow.</p>
+<blockquote>
+<div><ul class="simple">
+<li><a class="reference internal" href="#find-diagnostic-id"><span class="std std-ref">find-diagnostic-id</span></a> - Print the id of the given diagnostic.</li>
+<li><a class="reference internal" href="#list-warnings"><span class="std std-ref">list-warnings</span></a> - List warnings and their corresponding flags.</li>
+<li><a class="reference internal" href="#show-enabled"><span class="std std-ref">show-enabled</span></a> - Show which warnings are enabled for a given command line.</li>
+<li><a class="reference internal" href="#tree"><span class="std std-ref">tree</span></a> - Show warning flags in a tree view.</li>
+</ul>
+</div></blockquote>
+<div class="section" id="find-diagnostic-id">
+<span id="id1"></span><h3>find-diagnostic-id<a class="headerlink" href="#find-diagnostic-id" title="Permalink to this headline">¶</a></h3>
+<p><strong class="program">diagtool</strong> find-diagnostic-id <em>diagnostic-name</em></p>
+</div>
+<div class="section" id="list-warnings">
+<span id="id2"></span><h3>list-warnings<a class="headerlink" href="#list-warnings" title="Permalink to this headline">¶</a></h3>
+<p><strong class="program">diagtool</strong> list-warnings</p>
+</div>
+<div class="section" id="show-enabled">
+<span id="id3"></span><h3>show-enabled<a class="headerlink" href="#show-enabled" title="Permalink to this headline">¶</a></h3>
+<p><strong class="program">diagtool</strong> show-enabled [<em>options</em>] <em>filename â¦</em></p>
+</div>
+<div class="section" id="tree">
+<span id="id4"></span><h3>tree<a class="headerlink" href="#tree" title="Permalink to this headline">¶</a></h3>
+<p><strong class="program">diagtool</strong> tree [<em>diagnostic-group</em>]</p>
+</div>
+</div>
+</div>
+
+
+ </div>
+ <div class="bottomnav" role="navigation" aria-label="bottom navigation">
+
+ <p>
+ « <a href="clang.html">clang - the Clang C, C++, and Objective-C compiler</a>
+ ::
+ <a class="uplink" href="../index.html">Contents</a>
+ ::
+ <a href="../FAQ.html">Frequently Asked Questions (FAQ)</a> »
+ </p>
+
+ </div>
+
+ <div class="footer" role="contentinfo">
+ © Copyright 2007-2018, The Clang Team.
+ Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.6.4.
+ </div>
+ </body>
+</html>
\ No newline at end of file
Added: www-releases/trunk/7.0.0/tools/clang/docs/CommandGuide/index.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/7.0.0/tools/clang/docs/CommandGuide/index.html?rev=342530&view=auto
==============================================================================
--- www-releases/trunk/7.0.0/tools/clang/docs/CommandGuide/index.html (added)
+++ www-releases/trunk/7.0.0/tools/clang/docs/CommandGuide/index.html Wed Sep 19 02:40:08 2018
@@ -0,0 +1,87 @@
+
+<!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 7 documentation</title>
+ <link rel="stylesheet" href="../_static/haiku.css" type="text/css" />
+ <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
+ <script type="text/javascript">
+ var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: '../',
+ VERSION: '7',
+ COLLAPSE_INDEX: false,
+ FILE_SUFFIX: '.html',
+ HAS_SOURCE: true,
+ SOURCELINK_SUFFIX: '.txt'
+ };
+ </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="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+ <link rel="index" title="Index" href="../genindex.html" />
+ <link rel="search" title="Search" href="../search.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" role="banner"><h1 class="heading"><a href="../index.html">
+ <span>Clang 7 documentation</span></a></h1>
+ <h2 class="heading"><span>Clang âmanâ pages</span></h2>
+ </div>
+ <div class="topnav" role="navigation" aria-label="top navigation">
+
+ <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 <code class="docutils literal"><span class="pre">--help</span></code> (general options) or
+<code class="docutils literal"><span class="pre">--help-hidden</span></code> (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>
+<li class="toctree-l1"><a class="reference internal" href="diagtool.html">diagtool - clang diagnostics tool</a></li>
+</ul>
+</div>
+</div>
+</div>
+
+
+ </div>
+ <div class="bottomnav" role="navigation" aria-label="bottom navigation">
+
+ <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" role="contentinfo">
+ © Copyright 2007-2018, The Clang Team.
+ Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.6.4.
+ </div>
+ </body>
+</html>
\ No newline at end of file
More information about the llvm-commits
mailing list