[www-releases] r312731 - 5.0.0 files

Thu Sep 7 10:47:19 PDT 2017

Added: www-releases/trunk/5.0.0/tools/clang/docs/Block-ABI-Apple.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/5.0.0/tools/clang/docs/Block-ABI-Apple.html?rev=312731&view=auto
==============================================================================

--- www-releases/trunk/5.0.0/tools/clang/docs/Block-ABI-Apple.html (added)
+++ www-releases/trunk/5.0.0/tools/clang/docs/Block-ABI-Apple.html Thu Sep  7 10:47:16 2017
@@ -0,0 +1,909 @@
+<!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 5 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:     '5',
+        COLLAPSE_INDEX: false,
+        FILE_SUFFIX: '.html',
+        HAS_SOURCE:  true
+      };
+    </script>
+    <script type="text/javascript" src="_static/jquery.js"></script>
+    <script type="text/javascript" src="_static/underscore.js"></script>
+    <script type="text/javascript" src="_static/doctools.js"></script>
+    <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+    <link rel="top" title="Clang 5 documentation" href="index.html" />
+    <link rel="up" title="Clang Language Extensions" href="LanguageExtensions.html" />
+    <link rel="next" title="Objective-C Automatic Reference Counting (ARC)" href="AutomaticReferenceCounting.html" />
+    <link rel="prev" title="Language Specification for Blocks" href="BlockLanguageSpec.html" /> 
+  </head>
+  <body>
+      <div class="header"><h1 class="heading"><a href="index.html">
+          <span>Clang 5 documentation</span></a></h1>
+        <h2 class="heading"><span>Block Implementation Specification</span></h2>
+      </div>
+      <div class="topnav">
+      
+        <p>
+        Â«  <a href="BlockLanguageSpec.html">Language Specification for Blocks</a>
+          ::  
+        <a class="uplink" href="index.html">Contents</a>
+          ::  
+        <a href="AutomaticReferenceCounting.html">Objective-C Automatic Reference Counting (ARC)</a>  Â»
+        </p>
+
+      </div>
+      <div class="content">
+        
+        
+  <div class="section" id="block-implementation-specification">
+<h1>Block Implementation Specification<a class="headerlink" href="#block-implementation-specification" title="Permalink to this headline">Â¶</a></h1>
+<div class="contents local topic" id="contents">
+<ul class="simple">
+<li><a class="reference internal" href="#history" id="id1">History</a></li>
+<li><a class="reference internal" href="#high-level" id="id2">High Level</a></li>
+<li><a class="reference internal" href="#imported-variables" id="id3">Imported Variables</a><ul>
+<li><a class="reference internal" href="#imported-const-copy-variables" id="id4">Imported <tt class="docutils literal"><span class="pre">const</span></tt> copy variables</a></li>
+<li><a class="reference internal" href="#imported-const-copy-of-block-reference" id="id5">Imported <tt class="docutils literal"><span class="pre">const</span></tt> copy of <tt class="docutils literal"><span class="pre">Block</span></tt> reference</a><ul>
+<li><a class="reference internal" href="#importing-attribute-nsobject-variables" id="id6">Importing <tt class="docutils literal"><span class="pre">__attribute__((NSObject))</span></tt> variables</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#imported-block-marked-variables" id="id7">Imported <tt class="docutils literal"><span class="pre">__block</span></tt> marked variables</a><ul>
+<li><a class="reference internal" href="#layout-of-block-marked-variables" id="id8">Layout of <tt class="docutils literal"><span class="pre">__block</span></tt> marked variables</a></li>
+<li><a class="reference internal" href="#access-to-block-variables-from-within-its-lexical-scope" id="id9">Access to <tt class="docutils literal"><span class="pre">__block</span></tt> variables from within its lexical scope</a></li>
+<li><a class="reference internal" href="#importing-block-variables-into-blocks" id="id10">Importing <tt class="docutils literal"><span class="pre">__block</span></tt> variables into <tt class="docutils literal"><span class="pre">Blocks</span></tt></a></li>
+<li><a class="reference internal" href="#importing-attribute-nsobject-block-variables" id="id11">Importing <tt class="docutils literal"><span class="pre">__attribute__((NSObject))</span></tt> <tt class="docutils literal"><span class="pre">__block</span></tt> variables</a></li>
+<li><a class="reference internal" href="#block-escapes" id="id12"><tt class="docutils literal"><span class="pre">__block</span></tt> escapes</a></li>
+<li><a class="reference internal" href="#nesting" id="id13">Nesting</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#objective-c-extensions-to-blocks" id="id14">Objective C Extensions to <tt class="docutils literal"><span class="pre">Blocks</span></tt></a><ul>
+<li><a class="reference internal" href="#importing-objects" id="id15">Importing Objects</a></li>
+<li><a class="reference internal" href="#blocks-as-objects" id="id16"><tt class="docutils literal"><span class="pre">Blocks</span></tt> as Objects</a></li>
+<li><a class="reference internal" href="#weak-block-support" id="id17"><tt class="docutils literal"><span class="pre">__weak</span> <span class="pre">__block</span></tt> Support</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#c-support" id="id18">C++ Support</a></li>
+<li><a class="reference internal" href="#runtime-helper-functions" id="id19">Runtime Helper Functions</a></li>
+<li><a class="reference internal" href="#copyright" id="id20">Copyright</a></li>
+</ul>
+</div>
+<div class="section" id="history">
+<h2><a class="toc-backref" href="#id1">History</a><a class="headerlink" href="#history" title="Permalink to this headline">Â¶</a></h2>
+<ul class="simple">
+<li>2008/7/14 - created.</li>
+<li>2008/8/21 - revised, C++.</li>
+<li>2008/9/24 - add <tt class="docutils literal"><span class="pre">NULL</span></tt> <tt class="docutils literal"><span class="pre">isa</span></tt> field to <tt class="docutils literal"><span class="pre">__block</span></tt> storage.</li>
+<li>2008/10/1 - revise block layout to use a <tt class="docutils literal"><span class="pre">static</span></tt> descriptor structure.</li>
+<li>2008/10/6 - revise block layout to use an unsigned long int flags.</li>
+<li>2008/10/28 - specify use of <tt class="docutils literal"><span class="pre">_Block_object_assign</span></tt> and
+<tt class="docutils literal"><span class="pre">_Block_object_dispose</span></tt> for all “Object” types in helper functions.</li>
+<li>2008/10/30 - revise new layout to have invoke function in same place.</li>
+<li>2008/10/30 - add <tt class="docutils literal"><span class="pre">__weak</span></tt> support.</li>
+<li>2010/3/16 - rev for stret return, signature field.</li>
+<li>2010/4/6 - improved wording.</li>
+<li>2013/1/6 - improved wording and converted to rst.</li>
+</ul>
+<p>This document describes the Apple ABI implementation specification of Blocks.</p>
+<p>The first shipping version of this ABI is found in Mac OS X 10.6, and shall be
+referred to as 10.6.ABI. As of 2010/3/16, the following describes the ABI
+contract with the runtime and the compiler, and, as necessary, will be referred
+to as ABI.2010.3.16.</p>
+<p>Since the Apple ABI references symbols from other elements of the system, any
+attempt to use this ABI on systems prior to SnowLeopard is undefined.</p>
+</div>
+<div class="section" id="high-level">
+<h2><a class="toc-backref" href="#id2">High Level</a><a class="headerlink" href="#high-level" title="Permalink to this headline">Â¶</a></h2>
+<p>The ABI of <tt class="docutils literal"><span class="pre">Blocks</span></tt> consist of their layout and the runtime functions required
+by the compiler.  A <tt class="docutils literal"><span class="pre">Block</span></tt> consists of a structure of the following form:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></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="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><tt class="docutils literal"><span class="pre">Block</span></tt> literals may occur within functions where the structure is created in
+stack local memory.  They may also appear as initialization expressions for
+<tt class="docutils literal"><span class="pre">Block</span></tt> variables of global or <tt class="docutils literal"><span class="pre">static</span></tt> local variables.</p>
+<p>When a <tt class="docutils literal"><span class="pre">Block</span></tt> literal expression is evaluated the stack based structure is
+initialized as follows:</p>
+<ol class="arabic simple">
+<li>A <tt class="docutils literal"><span class="pre">static</span></tt> descriptor structure is declared and initialized as follows:</li>
+</ol>
+<blockquote>
+<div><p>a. The <tt class="docutils literal"><span class="pre">invoke</span></tt> function pointer is set to a function that takes the
+<tt class="docutils literal"><span class="pre">Block</span></tt> structure as its first argument and the rest of the arguments (if
+any) to the <tt class="docutils literal"><span class="pre">Block</span></tt> and executes the <tt class="docutils literal"><span class="pre">Block</span></tt> compound statement.</p>
+<p>b. The <tt class="docutils literal"><span class="pre">size</span></tt> field is set to the size of the following <tt class="docutils literal"><span class="pre">Block</span></tt> literal
+structure.</p>
+<p>c. The <tt class="docutils literal"><span class="pre">copy_helper</span></tt> and <tt class="docutils literal"><span class="pre">dispose_helper</span></tt> function pointers are set to
+respective helper functions if they are required by the <tt class="docutils literal"><span class="pre">Block</span></tt> literal.</p>
+</div></blockquote>
+<ol class="arabic" start="2">
+<li><p class="first">A stack (or global) <tt class="docutils literal"><span class="pre">Block</span></tt> literal data structure is created and
+initialized as follows:</p>
+<p>a. The <tt class="docutils literal"><span class="pre">isa</span></tt> field is set to the address of the external
+<tt class="docutils literal"><span class="pre">_NSConcreteStackBlock</span></tt>, which is a block of uninitialized memory supplied
+in <tt class="docutils literal"><span class="pre">libSystem</span></tt>, or <tt class="docutils literal"><span class="pre">_NSConcreteGlobalBlock</span></tt> if this is a static or file
+level <tt class="docutils literal"><span class="pre">Block</span></tt> literal.</p>
+<p>b. The <tt class="docutils literal"><span class="pre">flags</span></tt> field is set to zero unless there are variables imported
+into the <tt class="docutils literal"><span class="pre">Block</span></tt> that need helper functions for program level
+<tt class="docutils literal"><span class="pre">Block_copy()</span></tt> and <tt class="docutils literal"><span class="pre">Block_release()</span></tt> operations, in which case the
+(1<<25) flags bit is set.</p>
+</li>
+</ol>
+<p>As an example, the <tt class="docutils literal"><span class="pre">Block</span></tt> literal expression:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">Block</span></tt> 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 <tt class="docutils literal"><span class="pre">Block</span></tt> imports other <tt class="docutils literal"><span class="pre">Block</span></tt> references, <tt class="docutils literal"><span class="pre">const</span></tt> copies of other
+variables, and variables marked <tt class="docutils literal"><span class="pre">__block</span></tt>.  In Objective-C, variables may
+additionally be objects.</p>
+<p>When a <tt class="docutils literal"><span class="pre">Block</span></tt> literal expression is used as the initial value of a global
+or <tt class="docutils literal"><span class="pre">static</span></tt> local variable, it is initialized as follows:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">flags</span></tt> field, and otherwise it is the same as for
+stack based <tt class="docutils literal"><span class="pre">Block</span></tt> literals.  This is an optimization that can be used for
+any <tt class="docutils literal"><span class="pre">Block</span></tt> literal that imports no <tt class="docutils literal"><span class="pre">const</span></tt> or <tt class="docutils literal"><span class="pre">__block</span></tt> storage
+variables.</p>
+</div>
+<div class="section" id="imported-variables">
+<h2><a class="toc-backref" href="#id3">Imported Variables</a><a class="headerlink" href="#imported-variables" title="Permalink to this headline">Â¶</a></h2>
+<p>Variables of <tt class="docutils literal"><span class="pre">auto</span></tt> storage class are imported as <tt class="docutils literal"><span class="pre">const</span></tt> copies.  Variables
+of <tt class="docutils literal"><span class="pre">__block</span></tt> storage class are imported as a pointer to an enclosing data
+structure.  Global variables are simply referenced and not considered as
+imported.</p>
+<div class="section" id="imported-const-copy-variables">
+<h3><a class="toc-backref" href="#id4">Imported <tt class="docutils literal"><span class="pre">const</span></tt> copy variables</a><a class="headerlink" href="#imported-const-copy-variables" title="Permalink to this headline">Â¶</a></h3>
+<p>Automatic storage variables not marked with <tt class="docutils literal"><span class="pre">__block</span></tt> are imported as
+<tt class="docutils literal"><span class="pre">const</span></tt> copies.</p>
+<p>The simplest example is that of importing a variable of type <tt class="docutils literal"><span class="pre">int</span></tt>:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">const</span></tt> copies with no need for helper functions.</p>
+</div>
+<div class="section" id="imported-const-copy-of-block-reference">
+<h3><a class="toc-backref" href="#id5">Imported <tt class="docutils literal"><span class="pre">const</span></tt> copy of <tt class="docutils literal"><span class="pre">Block</span></tt> reference</a><a class="headerlink" href="#imported-const-copy-of-block-reference" title="Permalink to this headline">Â¶</a></h3>
+<p>The first case where copy and dispose helper functions are required is for the
+case of when a <tt class="docutils literal"><span class="pre">Block</span></tt> itself is imported.  In this case both a
+<tt class="docutils literal"><span class="pre">copy_helper</span></tt> function and a <tt class="docutils literal"><span class="pre">dispose_helper</span></tt> function are needed.  The
+<tt class="docutils literal"><span class="pre">copy_helper</span></tt> function is passed both the existing stack based pointer and the
+pointer to the new heap version and should call back into the runtime to
+actually do the copy operation on the imported fields within the <tt class="docutils literal"><span class="pre">Block</span></tt>. The
+runtime functions are all described in <a class="reference internal" href="#runtimehelperfunctions"><em>Runtime Helper Functions</em></a>.</p>
+<p>A quick example:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">Block</span></tt> 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 <tt class="docutils literal"><span class="pre">__attribute__((NSObject))</span></tt> variables</a><a class="headerlink" href="#importing-attribute-nsobject-variables" title="Permalink to this headline">Â¶</a></h4>
+<p>GCC introduces <tt class="docutils literal"><span class="pre">__attribute__((NSObject))</span></tt> on structure pointers to mean “this
+is an object”.  This is useful because many low level data structures are
+declared as opaque structure pointers, e.g. <tt class="docutils literal"><span class="pre">CFStringRef</span></tt>, <tt class="docutils literal"><span class="pre">CFArrayRef</span></tt>,
+etc.  When used from C, however, these are still really objects and are the
+second case where that requires copy and dispose helper functions to be
+generated.  The copy helper functions generated by the compiler should use the
+<tt class="docutils literal"><span class="pre">_Block_object_assign</span></tt> runtime helper function and in the dispose helper the
+<tt class="docutils literal"><span class="pre">_Block_object_dispose</span></tt> runtime helper function should be called.</p>
+<p>For example, <tt class="docutils literal"><span class="pre">Block</span></tt> foo in the following:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">__block</span></tt> marked variables</a><a class="headerlink" href="#imported-block-marked-variables" title="Permalink to this headline">Â¶</a></h3>
+<div class="section" id="layout-of-block-marked-variables">
+<h4><a class="toc-backref" href="#id8">Layout of <tt class="docutils literal"><span class="pre">__block</span></tt> marked variables</a><a class="headerlink" href="#layout-of-block-marked-variables" title="Permalink to this headline">Â¶</a></h4>
+<p>The compiler must embed variables that are marked <tt class="docutils literal"><span class="pre">__block</span></tt> in a specialized
+structure of the form:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">Block_copy()</span></tt>
+and <tt class="docutils literal"><span class="pre">Block_release()</span></tt> are performed upon a referencing <tt class="docutils literal"><span class="pre">Block</span></tt>.  At the “C”
+level only variables that are of type <tt class="docutils literal"><span class="pre">Block</span></tt> or ones that have
+<tt class="docutils literal"><span class="pre">__attribute__((NSObject))</span></tt> marked require helper functions.  In Objective-C
+objects require helper functions and in C++ stack based objects require helper
+functions. Variables that require helper functions use the form:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">forwarding</span></tt> pointer is set to the beginning of its enclosing
+structure.</p>
+<p>b. The <tt class="docutils literal"><span class="pre">size</span></tt> field is initialized to the total size of the enclosing
+structure.</p>
+<p>c. The <tt class="docutils literal"><span class="pre">flags</span></tt> field is set to either 0 if no helper functions are needed
+or (1<<25) if they are.</p>
+<ol class="loweralpha simple" start="4">
+<li>The helper functions are initialized (if present).</li>
+<li>The variable itself is set to its initial value.</li>
+<li>The <tt class="docutils literal"><span class="pre">isa</span></tt> field is set to <tt class="docutils literal"><span class="pre">NULL</span></tt>.</li>
+</ol>
+</div></blockquote>
+</div>
+<div class="section" id="access-to-block-variables-from-within-its-lexical-scope">
+<h4><a class="toc-backref" href="#id9">Access to <tt class="docutils literal"><span class="pre">__block</span></tt> variables from within its lexical scope</a><a class="headerlink" href="#access-to-block-variables-from-within-its-lexical-scope" title="Permalink to this headline">Â¶</a></h4>
+<p>In order to “move” the variable to the heap upon a <tt class="docutils literal"><span class="pre">copy_helper</span></tt> operation the
+compiler must rewrite access to such a variable to be indirect through the
+structures <tt class="docutils literal"><span class="pre">forwarding</span></tt> pointer.  For example:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">Block</span></tt> reference variable being marked <tt class="docutils literal"><span class="pre">__block</span></tt> the
+helper code generated must use the <tt class="docutils literal"><span class="pre">_Block_object_assign</span></tt> and
+<tt class="docutils literal"><span class="pre">_Block_object_dispose</span></tt> routines supplied by the runtime to make the
+copies. For example:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">__block</span></tt> variables into <tt class="docutils literal"><span class="pre">Blocks</span></tt></a><a class="headerlink" href="#importing-block-variables-into-blocks" title="Permalink to this headline">Â¶</a></h4>
+<p>A <tt class="docutils literal"><span class="pre">Block</span></tt> that uses a <tt class="docutils literal"><span class="pre">__block</span></tt> variable in its compound statement body must
+import the variable and emit <tt class="docutils literal"><span class="pre">copy_helper</span></tt> and <tt class="docutils literal"><span class="pre">dispose_helper</span></tt> helper
+functions that, in turn, call back into the runtime to actually copy or release
+the <tt class="docutils literal"><span class="pre">byref</span></tt> data block using the functions <tt class="docutils literal"><span class="pre">_Block_object_assign</span></tt> and
+<tt class="docutils literal"><span class="pre">_Block_object_dispose</span></tt>.</p>
+<p>For example:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">__attribute__((NSObject))</span></tt> <tt class="docutils literal"><span class="pre">__block</span></tt> variables</a><a class="headerlink" href="#importing-attribute-nsobject-block-variables" title="Permalink to this headline">Â¶</a></h4>
+<p>A <tt class="docutils literal"><span class="pre">__block</span></tt> variable that is also marked <tt class="docutils literal"><span class="pre">__attribute__((NSObject))</span></tt> should
+have <tt class="docutils literal"><span class="pre">byref_keep</span></tt> and <tt class="docutils literal"><span class="pre">byref_dispose</span></tt> helper functions that use
+<tt class="docutils literal"><span class="pre">_Block_object_assign</span></tt> and <tt class="docutils literal"><span class="pre">_Block_object_dispose</span></tt>.</p>
+</div>
+<div class="section" id="block-escapes">
+<h4><a class="toc-backref" href="#id12"><tt class="docutils literal"><span class="pre">__block</span></tt> escapes</a><a class="headerlink" href="#block-escapes" title="Permalink to this headline">Â¶</a></h4>
+<p>Because <tt class="docutils literal"><span class="pre">Blocks</span></tt> referencing <tt class="docutils literal"><span class="pre">__block</span></tt> variables may have <tt class="docutils literal"><span class="pre">Block_copy()</span></tt>
+performed upon them the underlying storage for the variables may move to the
+heap.  In Objective-C Garbage Collection Only compilation environments the heap
+used is the garbage collected one and no further action is required.  Otherwise
+the compiler must issue a call to potentially release any heap storage for
+<tt class="docutils literal"><span class="pre">__block</span></tt> variables at all escapes or terminations of their scope.  The call
+should be:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></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><tt class="docutils literal"><span class="pre">Blocks</span></tt> may contain <tt class="docutils literal"><span class="pre">Block</span></tt> literal expressions.  Any variables used within
+inner blocks are imported into all enclosing <tt class="docutils literal"><span class="pre">Block</span></tt> scopes even if the
+variables are not used. This includes <tt class="docutils literal"><span class="pre">const</span></tt> imports as well as <tt class="docutils literal"><span class="pre">__block</span></tt>
+variables.</p>
+</div>
+</div>
+</div>
+<div class="section" id="objective-c-extensions-to-blocks">
+<h2><a class="toc-backref" href="#id14">Objective C Extensions to <tt class="docutils literal"><span class="pre">Blocks</span></tt></a><a class="headerlink" href="#objective-c-extensions-to-blocks" title="Permalink to this headline">Â¶</a></h2>
+<div class="section" id="importing-objects">
+<h3><a class="toc-backref" href="#id15">Importing Objects</a><a class="headerlink" href="#importing-objects" title="Permalink to this headline">Â¶</a></h3>
+<p>Objects should be treated as <tt class="docutils literal"><span class="pre">__attribute__((NSObject))</span></tt> variables; all
+<tt class="docutils literal"><span class="pre">copy_helper</span></tt>, <tt class="docutils literal"><span class="pre">dispose_helper</span></tt>, <tt class="docutils literal"><span class="pre">byref_keep</span></tt>, and <tt class="docutils literal"><span class="pre">byref_dispose</span></tt>
+helper functions should use <tt class="docutils literal"><span class="pre">_Block_object_assign</span></tt> and
+<tt class="docutils literal"><span class="pre">_Block_object_dispose</span></tt>.  There should be no code generated that uses
+<tt class="docutils literal"><span class="pre">*-retain</span></tt> or <tt class="docutils literal"><span class="pre">*-release</span></tt> methods.</p>
+</div>
+<div class="section" id="blocks-as-objects">
+<h3><a class="toc-backref" href="#id16"><tt class="docutils literal"><span class="pre">Blocks</span></tt> as Objects</a><a class="headerlink" href="#blocks-as-objects" title="Permalink to this headline">Â¶</a></h3>
+<p>The compiler will treat <tt class="docutils literal"><span class="pre">Blocks</span></tt> as objects when synthesizing property setters
+and getters, will characterize them as objects when generating garbage
+collection strong and weak layout information in the same manner as objects, and
+will issue strong and weak write-barrier assignments in the same manner as
+objects.</p>
+</div>
+<div class="section" id="weak-block-support">
+<h3><a class="toc-backref" href="#id17"><tt class="docutils literal"><span class="pre">__weak</span> <span class="pre">__block</span></tt> Support</a><a class="headerlink" href="#weak-block-support" title="Permalink to this headline">Â¶</a></h3>
+<p>Objective-C (and Objective-C++) support the <tt class="docutils literal"><span class="pre">__weak</span></tt> attribute on <tt class="docutils literal"><span class="pre">__block</span></tt>
+variables.  Under normal circumstances the compiler uses the Objective-C runtime
+helper support functions <tt class="docutils literal"><span class="pre">objc_assign_weak</span></tt> and <tt class="docutils literal"><span class="pre">objc_read_weak</span></tt>.  Both
+should continue to be used for all reads and writes of <tt class="docutils literal"><span class="pre">__weak</span> <span class="pre">__block</span></tt>
+variables:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">__weak</span></tt> variable is stored in a <tt class="docutils literal"><span class="pre">_block_byref_foo</span></tt> structure and the
+<tt class="docutils literal"><span class="pre">Block</span></tt> has copy and dispose helpers for this structure that call:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">block_byref</span></tt> copy support helpers distinguish between whether
+the <tt class="docutils literal"><span class="pre">__block</span></tt> variable is a <tt class="docutils literal"><span class="pre">Block</span></tt> or not and should either call:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">Block</span></tt>.</p>
+<p>A full example follows:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">byref</span></tt> 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 <tt class="docutils literal"><span class="pre">const</span></tt> copies using
+the copy constructor.  It is an error if a stack based C++ object is used within
+a block if it does not have a copy constructor.  In addition both copy and
+destroy helper routines must be synthesized for the block to support the
+<tt class="docutils literal"><span class="pre">Block_copy()</span></tt> operation, and the flags work marked with the (1<<26) bit in
+addition to the (1<<25) bit.  The copy helper should call the constructor using
+appropriate offsets of the variable within the supplied stack based block source
+and heap based destination for all <tt class="docutils literal"><span class="pre">const</span></tt> constructed copies, and similarly
+should call the destructor in the destroy routine.</p>
+<p>As an example, suppose a C++ class <tt class="docutils literal"><span class="pre">FOO</span></tt> existed with a copy constructor.
+Within a code block a stack version of a <tt class="docutils literal"><span class="pre">FOO</span></tt> object is declared and used
+within a <tt class="docutils literal"><span class="pre">Block</span></tt> literal expression:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">__block</span></tt> storage start out on the stack in a
+<tt class="docutils literal"><span class="pre">block_byref</span></tt> data structure as do other variables.  Such objects (if not
+<tt class="docutils literal"><span class="pre">const</span></tt> objects) must support a regular copy constructor.  The <tt class="docutils literal"><span class="pre">block_byref</span></tt>
+data structure will have copy and destroy helper routines synthesized by the
+compiler.  The copy helper will have code created to perform the copy
+constructor based on the initial stack <tt class="docutils literal"><span class="pre">block_byref</span></tt> data structure, and will
+also set the (1<<26) bit in addition to the (1<<25) bit.  The destroy helper
+will have code to do the destructor on the object stored within the supplied
+<tt class="docutils literal"><span class="pre">block_byref</span></tt> heap data structure.  For example,</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">blockStorageFoo</span></tt> 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
+<tt class="docutils literal"><span class="pre">FOO</span></tt>.</p>
+<p>To support member variable and function access the compiler will synthesize a
+<tt class="docutils literal"><span class="pre">const</span></tt> pointer to a block version of the <tt class="docutils literal"><span class="pre">this</span></tt> pointer.</p>
+</div>
+<div class="section" id="runtime-helper-functions">
+<span id="runtimehelperfunctions"></span><h2><a class="toc-backref" href="#id19">Runtime Helper Functions</a><a class="headerlink" href="#runtime-helper-functions" title="Permalink to this headline">Â¶</a></h2>
+<p>The runtime helper functions are described in
+<tt class="docutils literal"><span class="pre">/usr/local/include/Block_private.h</span></tt>.  To summarize their use, a <tt class="docutils literal"><span class="pre">Block</span></tt>
+requires copy/dispose helpers if it imports any block variables, <tt class="docutils literal"><span class="pre">__block</span></tt>
+storage variables, <tt class="docutils literal"><span class="pre">__attribute__((NSObject))</span></tt> variables, or C++ <tt class="docutils literal"><span class="pre">const</span></tt>
+copied objects with constructor/destructors.  The (1<<26) bit is set and
+functions are generated.</p>
+<p>The block copy helper function should, for each of the variables of the type
+mentioned above, call:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre"><apropos></span></tt> 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 <tt class="docutils literal"><span class="pre">const</span></tt> copied C++ objects.</p>
+<p>The <tt class="docutils literal"><span class="pre">block_byref</span></tt> data structure similarly requires copy/dispose helpers for
+block variables, <tt class="docutils literal"><span class="pre">__attribute__((NSObject))</span></tt> variables, or C++ <tt class="docutils literal"><span class="pre">const</span></tt>
+copied objects with constructor/destructors, and again the (1<<26) bit is set
+and functions are generated in the same manner.</p>
+<p>Under ObjC we allow <tt class="docutils literal"><span class="pre">__weak</span></tt> as an attribute on <tt class="docutils literal"><span class="pre">__block</span></tt> variables, and
+this causes the addition of <tt class="docutils literal"><span class="pre">BLOCK_FIELD_IS_WEAK</span></tt> orred onto the
+<tt class="docutils literal"><span class="pre">BLOCK_FIELD_IS_BYREF</span></tt> flag when copying the <tt class="docutils literal"><span class="pre">block_byref</span></tt> structure in the
+<tt class="docutils literal"><span class="pre">Block</span></tt> copy helper, and onto the <tt class="docutils literal"><span class="pre">BLOCK_FIELD_<apropos></span></tt> field within the
+<tt class="docutils literal"><span class="pre">block_byref</span></tt> copy/dispose helper calls.</p>
+<p>The prototypes, and summary, of the helper functions are:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></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">
+      
+        <p>
+        Â«  <a href="BlockLanguageSpec.html">Language Specification for Blocks</a>
+          ::  
+        <a class="uplink" href="index.html">Contents</a>
+          ::  
+        <a href="AutomaticReferenceCounting.html">Objective-C Automatic Reference Counting (ARC)</a>  Â»
+        </p>
+
+      </div>
+
+    <div class="footer">
+        © Copyright 2007-2017, The Clang Team.
+      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.2.2.
+    </div>
+  </body>
+</html>
\ No newline at end of file

Added: www-releases/trunk/5.0.0/tools/clang/docs/BlockLanguageSpec.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/5.0.0/tools/clang/docs/BlockLanguageSpec.html?rev=312731&view=auto
==============================================================================
--- www-releases/trunk/5.0.0/tools/clang/docs/BlockLanguageSpec.html (added)
+++ www-releases/trunk/5.0.0/tools/clang/docs/BlockLanguageSpec.html Thu Sep  7 10:47:16 2017
@@ -0,0 +1,372 @@
+<!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 5 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:     '5',
+        COLLAPSE_INDEX: false,
+        FILE_SUFFIX: '.html',
+        HAS_SOURCE:  true
+      };
+    </script>
+    <script type="text/javascript" src="_static/jquery.js"></script>
+    <script type="text/javascript" src="_static/underscore.js"></script>
+    <script type="text/javascript" src="_static/doctools.js"></script>
+    <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+    <link rel="top" title="Clang 5 documentation" href="index.html" />
+    <link rel="up" title="Clang Language Extensions" href="LanguageExtensions.html" />
+    <link rel="next" title="Block Implementation Specification" href="Block-ABI-Apple.html" />
+    <link rel="prev" title="Objective-C Literals" href="ObjectiveCLiterals.html" /> 
+  </head>
+  <body>
+      <div class="header"><h1 class="heading"><a href="index.html">
+          <span>Clang 5 documentation</span></a></h1>
+        <h2 class="heading"><span>Language Specification for Blocks</span></h2>
+      </div>
+      <div class="topnav">
+      
+        <p>
+        Â«  <a href="ObjectiveCLiterals.html">Objective-C Literals</a>
+          ::  
+        <a class="uplink" href="index.html">Contents</a>
+          ::  
+        <a href="Block-ABI-Apple.html">Block Implementation Specification</a>  Â»
+        </p>
+
+      </div>
+      <div class="content">
+        
+        
+  <div class="section" id="language-specification-for-blocks">
+<h1>Language Specification for Blocks<a class="headerlink" href="#language-specification-for-blocks" title="Permalink to this headline">Â¶</a></h1>
+<div class="contents local topic" id="contents">
+<ul class="simple">
+<li><a class="reference internal" href="#revisions" id="id1">Revisions</a></li>
+<li><a class="reference internal" href="#overview" id="id2">Overview</a></li>
+<li><a class="reference internal" href="#the-block-type" id="id3">The Block Type</a></li>
+<li><a class="reference internal" href="#block-variable-declarations" id="id4">Block Variable Declarations</a></li>
+<li><a class="reference internal" href="#block-literal-expressions" id="id5">Block Literal Expressions</a></li>
+<li><a class="reference internal" href="#the-invoke-operator" id="id6">The Invoke Operator</a></li>
+<li><a class="reference internal" href="#the-copy-and-release-operations" id="id7">The Copy and Release Operations</a></li>
+<li><a class="reference internal" href="#the-block-storage-qualifier" id="id8">The <tt class="docutils literal"><span class="pre">__block</span></tt> Storage Qualifier</a></li>
+<li><a class="reference internal" href="#control-flow" id="id9">Control Flow</a></li>
+<li><a class="reference internal" href="#objective-c-extensions" id="id10">Objective-C Extensions</a></li>
+<li><a class="reference internal" href="#c-extensions" id="id11">C++ Extensions</a></li>
+</ul>
+</div>
+<div class="section" id="revisions">
+<h2><a class="toc-backref" href="#id1">Revisions</a><a class="headerlink" href="#revisions" title="Permalink to this headline">Â¶</a></h2>
+<ul class="simple">
+<li>2008/2/25 — created</li>
+<li>2008/7/28 — revised, <tt class="docutils literal"><span class="pre">__block</span></tt> syntax</li>
+<li>2008/8/13 — revised, Block globals</li>
+<li>2008/8/21 — revised, C++ elaboration</li>
+<li>2008/11/1 — revised, <tt class="docutils literal"><span class="pre">__weak</span></tt> support</li>
+<li>2009/1/12 — revised, explicit return types</li>
+<li>2009/2/10 — revised, <tt class="docutils literal"><span class="pre">__block</span></tt> objects need retain</li>
+</ul>
+</div>
+<div class="section" id="overview">
+<h2><a class="toc-backref" href="#id2">Overview</a><a class="headerlink" href="#overview" title="Permalink to this headline">Â¶</a></h2>
+<p>A new derived type is introduced to C and, by extension, Objective-C,
+C++, and Objective-C++</p>
+</div>
+<div class="section" id="the-block-type">
+<h2><a class="toc-backref" href="#id3">The Block Type</a><a class="headerlink" href="#the-block-type" title="Permalink to this headline">Â¶</a></h2>
+<p>Like function types, the <span class="block-term">Block type</span> is a pair consisting
+of a result value type and a list of parameter types very similar to a
+function type. Blocks are intended to be used much like functions with
+the key distinction being that in addition to executable code they
+also contain various variable bindings to automatic (stack) or managed
+(heap) memory.</p>
+<p>The abstract declarator,</p>
+<div class="highlight-c"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">^</span></tt> for <tt class="docutils literal"><span class="pre">*</span></tt>. The following are
+valid Block variable declarations:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">...</span></tt> arguments are supported. [variadic.c] A Block that
+takes no arguments must specify void in the argument list [voidarg.c].
+An empty parameter list does not represent, as K&R provide, an
+unspecified argument list.  Note: both gcc and clang support K&R style
+as a convenience.</p>
+<p>A Block reference may be cast to a pointer of arbitrary type and vice
+versa. [cast.c] A Block reference may not be dereferenced via the
+pointer dereference operator <tt class="docutils literal"><span class="pre">*</span></tt>, and thus a Block’s size may not be
+computed at compile time. [sizeof.c]</p>
+</div>
+<div class="section" id="block-literal-expressions">
+<h2><a class="toc-backref" href="#id5">Block Literal Expressions</a><a class="headerlink" href="#block-literal-expressions" title="Permalink to this headline">Â¶</a></h2>
+<p>A <span class="block-term">Block literal expression</span> produces a reference to a
+Block. It is introduced by the use of the <tt class="docutils literal"><span class="pre">^</span></tt> token as a unary
+operator.</p>
+<div class="highlight-c"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">^</span></tt> as a Block reference
+(pointer) where <tt class="docutils literal"><span class="pre">*</span></tt> is allowed as a function reference (pointer).</p>
+<p>The following Block literal:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">(</span> <span class="pre">void</span> <span class="pre">)</span></tt>,
+the <tt class="docutils literal"><span class="pre">(</span> <span class="pre">void</span> <span class="pre">)</span></tt> argument list may also be omitted.</p>
+<p>So:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">Block_copy()</span></tt> is styled as a function that takes
+an arbitrary Block reference and returns a Block reference of the same
+type. The release operation, <tt class="docutils literal"><span class="pre">Block_release()</span></tt>, is styled as a
+function that takes an arbitrary Block reference and, if dynamically
+matched to a Block copy operation, allows recovery of the referenced
+allocated memory.</p>
+</div>
+<div class="section" id="the-block-storage-qualifier">
+<h2><a class="toc-backref" href="#id8">The <tt class="docutils literal"><span class="pre">__block</span></tt> Storage Qualifier</a><a class="headerlink" href="#the-block-storage-qualifier" title="Permalink to this headline">Â¶</a></h2>
+<p>In addition to the new Block type we also introduce a new storage
+qualifier, <span class="block-term">__block</span>, for local variables. [testme: a
+__block declaration within a block literal] The <tt class="docutils literal"><span class="pre">__block</span></tt> storage
+qualifier is mutually exclusive to the existing local storage
+qualifiers auto, register, and static. [testme] Variables qualified by
+<tt class="docutils literal"><span class="pre">__block</span></tt> act as if they were in allocated storage and this storage
+is automatically recovered after last use of said variable.  An
+implementation may choose an optimization where the storage is
+initially automatic and only “moved” to allocated (heap) storage upon
+a Block_copy of a referencing Block.  Such variables may be mutated as
+normal variables are.</p>
+<p>In the case where a <tt class="docutils literal"><span class="pre">__block</span></tt> variable is a Block one must assume
+that the <tt class="docutils literal"><span class="pre">__block</span></tt> variable resides in allocated storage and as such
+is assumed to reference a Block that is also in allocated storage
+(that it is the result of a <tt class="docutils literal"><span class="pre">Block_copy</span></tt> operation).  Despite this
+there is no provision to do a <tt class="docutils literal"><span class="pre">Block_copy</span></tt> or a <tt class="docutils literal"><span class="pre">Block_release</span></tt> if
+an implementation provides initial automatic storage for Blocks.  This
+is due to the inherent race condition of potentially several threads
+trying to update the shared variable and the need for synchronization
+around disposing of older values and copying new ones.  Such
+synchronization is beyond the scope of this language specification.</p>
+</div>
+<div class="section" id="control-flow">
+<h2><a class="toc-backref" href="#id9">Control Flow</a><a class="headerlink" href="#control-flow" title="Permalink to this headline">Â¶</a></h2>
+<p>The compound statement of a Block is treated much like a function body
+with respect to control flow in that goto, break, and continue do not
+escape the Block.  Exceptions are treated <em>normally</em> in that when
+thrown they pop stack frames until a catch clause is found.</p>
+</div>
+<div class="section" id="objective-c-extensions">
+<h2><a class="toc-backref" href="#id10">Objective-C Extensions</a><a class="headerlink" href="#objective-c-extensions" title="Permalink to this headline">Â¶</a></h2>
+<p>Objective-C extends the definition of a Block reference type to be
+that also of id.  A variable or expression of Block type may be
+messaged or used as a parameter wherever an id may be. The converse is
+also true. Block references may thus appear as properties and are
+subject to the assign, retain, and copy attribute logic that is
+reserved for objects.</p>
+<p>All Blocks are constructed to be Objective-C objects regardless of
+whether the Objective-C runtime is operational in the program or
+not. Blocks using automatic (stack) memory are objects and may be
+messaged, although they may not be assigned into <tt class="docutils literal"><span class="pre">__weak</span></tt> locations
+if garbage collection is enabled.</p>
+<p>Within a Block literal expression within a method definition
+references to instance variables are also imported into the lexical
+scope of the compound statement. These variables are implicitly
+qualified as references from self, and so self is imported as a const
+copy. The net effect is that instance variables can be mutated.</p>
+<p>The <span class="block-term">Block_copy</span> operator retains all objects held in
+variables of automatic storage referenced within the Block expression
+(or form strong references if running under garbage collection).
+Object variables of <tt class="docutils literal"><span class="pre">__block</span></tt> storage type are assumed to hold
+normal pointers with no provision for retain and release messages.</p>
+<p>Foundation defines (and supplies) <tt class="docutils literal"><span class="pre">-copy</span></tt> and <tt class="docutils literal"><span class="pre">-release</span></tt> methods for
+Blocks.</p>
+<p>In the Objective-C and Objective-C++ languages, we allow the
+<tt class="docutils literal"><span class="pre">__weak</span></tt> specifier for <tt class="docutils literal"><span class="pre">__block</span></tt> variables of object type.  If
+garbage collection is not enabled, this qualifier causes these
+variables to be kept without retain messages being sent. This
+knowingly leads to dangling pointers if the Block (or a copy) outlives
+the lifetime of this object.</p>
+<p>In garbage collected environments, the <tt class="docutils literal"><span class="pre">__weak</span></tt> variable is set to
+nil when the object it references is collected, as long as the
+<tt class="docutils literal"><span class="pre">__block</span></tt> variable resides in the heap (either by default or via
+<tt class="docutils literal"><span class="pre">Block_copy()</span></tt>).  The initial Apple implementation does in fact
+start <tt class="docutils literal"><span class="pre">__block</span></tt> variables on the stack and migrate them to the heap
+only as a result of a <tt class="docutils literal"><span class="pre">Block_copy()</span></tt> operation.</p>
+<p>It is a runtime error to attempt to assign a reference to a
+stack-based Block into any storage marked <tt class="docutils literal"><span class="pre">__weak</span></tt>, including
+<tt class="docutils literal"><span class="pre">__weak</span></tt> <tt class="docutils literal"><span class="pre">__block</span></tt> variables.</p>
+</div>
+<div class="section" id="c-extensions">
+<h2><a class="toc-backref" href="#id11">C++ Extensions</a><a class="headerlink" href="#c-extensions" title="Permalink to this headline">Â¶</a></h2>
+<p>Block literal expressions within functions are extended to allow const
+use of C++ objects, pointers, or references held in automatic storage.</p>
+<p>As usual, within the block, references to captured variables become
+const-qualified, as if they were references to members of a const
+object.  Note that this does not change the type of a variable of
+reference type.</p>
+<p>For example, given a class Foo:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">Block_copy()</span></tt> on a Block allocated on the stack.  In both
+cases, they are copied as if the variable were const-qualified, and
+it’s an error if there’s no such constructor.</p>
+<p>Captured variables in Blocks on the stack are destroyed when control
+leaves the compound statement that contains the Block literal
+expression.  Captured variables in Blocks on the heap are destroyed
+when the reference count of the Block drops to zero.</p>
+<p>Variables declared as residing in <tt class="docutils literal"><span class="pre">__block</span></tt> storage may be initially
+allocated in the heap or may first appear on the stack and be copied
+to the heap as a result of a <tt class="docutils literal"><span class="pre">Block_copy()</span></tt> operation. When copied
+from the stack, <tt class="docutils literal"><span class="pre">__block</span></tt> variables are copied using their normal
+qualification (i.e. without adding const).  In C++11, <tt class="docutils literal"><span class="pre">__block</span></tt>
+variables are copied as x-values if that is possible, then as l-values
+if not; if both fail, it’s an error.  The destructor for any initial
+stack-based version is called at the variable’s normal end of scope.</p>
+<p>References to <tt class="docutils literal"><span class="pre">this</span></tt>, as well as references to non-static members of
+any enclosing class, are evaluated by capturing <tt class="docutils literal"><span class="pre">this</span></tt> just like a
+normal variable of C pointer type.</p>
+<p>Member variables that are Blocks may not be overloaded by the types of
+their arguments.</p>
+</div>
+</div>
+
+
+      </div>
+      <div class="bottomnav">
+      
+        <p>
+        Â«  <a href="ObjectiveCLiterals.html">Objective-C Literals</a>
+          ::  
+        <a class="uplink" href="index.html">Contents</a>
+          ::  
+        <a href="Block-ABI-Apple.html">Block Implementation Specification</a>  Â»
+        </p>
+
+      </div>
+
+    <div class="footer">
+        © Copyright 2007-2017, The Clang Team.
+      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.2.2.
+    </div>
+  </body>
+</html>
\ No newline at end of file

Added: www-releases/trunk/5.0.0/tools/clang/docs/ClangCheck.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/5.0.0/tools/clang/docs/ClangCheck.html?rev=312731&view=auto
==============================================================================
--- www-releases/trunk/5.0.0/tools/clang/docs/ClangCheck.html (added)
+++ www-releases/trunk/5.0.0/tools/clang/docs/ClangCheck.html Thu Sep  7 10:47:16 2017
@@ -0,0 +1,103 @@
+<!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 5 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:     '5',
+        COLLAPSE_INDEX: false,
+        FILE_SUFFIX: '.html',
+        HAS_SOURCE:  true
+      };
+    </script>
+    <script type="text/javascript" src="_static/jquery.js"></script>
+    <script type="text/javascript" src="_static/underscore.js"></script>
+    <script type="text/javascript" src="_static/doctools.js"></script>
+    <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+    <link rel="top" title="Clang 5 documentation" href="index.html" />
+    <link rel="next" title="ClangFormat" href="ClangFormat.html" />
+    <link rel="prev" title="Overview" href="ClangTools.html" /> 
+  </head>
+  <body>
+      <div class="header"><h1 class="heading"><a href="index.html">
+          <span>Clang 5 documentation</span></a></h1>
+        <h2 class="heading"><span>ClangCheck</span></h2>
+      </div>
+      <div class="topnav">
+      
+        <p>
+        Â«  <a href="ClangTools.html">Overview</a>
+          ::  
+        <a class="uplink" href="index.html">Contents</a>
+          ::  
+        <a href="ClangFormat.html">ClangFormat</a>  Â»
+        </p>
+
+      </div>
+      <div class="content">
+        
+        
+  <div class="section" id="clangcheck">
+<h1>ClangCheck<a class="headerlink" href="#clangcheck" title="Permalink to this headline">Â¶</a></h1>
+<p><cite>ClangCheck</cite> is a small wrapper around <a class="reference internal" href="LibTooling.html"><em>LibTooling</em></a> which can be used to
+do basic error checking and AST dumping.</p>
+<div class="highlight-console"><div class="highlight"><pre><span></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"><em>How To Setup Clang Tooling For LLVM</em></a>.</p>
+</div>
+
+
+      </div>
+      <div class="bottomnav">
+      
+        <p>
+        Â«  <a href="ClangTools.html">Overview</a>
+          ::  
+        <a class="uplink" href="index.html">Contents</a>
+          ::  
+        <a href="ClangFormat.html">ClangFormat</a>  Â»
+        </p>
+
+      </div>
+
+    <div class="footer">
+        © Copyright 2007-2017, The Clang Team.
+      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.2.2.
+    </div>
+  </body>
+</html>
\ No newline at end of file

Added: www-releases/trunk/5.0.0/tools/clang/docs/ClangCommandLineReference.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/5.0.0/tools/clang/docs/ClangCommandLineReference.html?rev=312731&view=auto
==============================================================================
--- www-releases/trunk/5.0.0/tools/clang/docs/ClangCommandLineReference.html (added)
+++ www-releases/trunk/5.0.0/tools/clang/docs/ClangCommandLineReference.html Thu Sep  7 10:47:16 2017
@@ -0,0 +1,4883 @@
+<!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 5 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:     '5',
+        COLLAPSE_INDEX: false,
+        FILE_SUFFIX: '.html',
+        HAS_SOURCE:  true
+      };
+    </script>
+    <script type="text/javascript" src="_static/jquery.js"></script>
+    <script type="text/javascript" src="_static/underscore.js"></script>
+    <script type="text/javascript" src="_static/doctools.js"></script>
+    <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+    <link rel="top" title="Clang 5 documentation" href="index.html" />
+    <link rel="next" title="Attributes in Clang" href="AttributeReference.html" />
+    <link rel="prev" title="Objective-C Automatic Reference Counting (ARC)" href="AutomaticReferenceCounting.html" /> 
+  </head>
+  <body>
+      <div class="header"><h1 class="heading"><a href="index.html">
+          <span>Clang 5 documentation</span></a></h1>
+        <h2 class="heading"><span>Clang command line argument reference</span></h2>
+      </div>
+      <div class="topnav">
+      
+        <p>
+        Â«  <a href="AutomaticReferenceCounting.html">Objective-C Automatic Reference Counting (ARC)</a>
+          ::  
+        <a class="uplink" href="index.html">Contents</a>
+          ::  
+        <a href="AttributeReference.html">Attributes in Clang</a>  Â»
+        </p>
+
+      </div>
+      <div class="content">
+        
+        
+  <div class="section" id="clang-command-line-argument-reference">
+<h1>Clang command line argument reference<a class="headerlink" href="#clang-command-line-argument-reference" title="Permalink to this headline">Â¶</a></h1>
+<div class="contents local topic" id="contents">
+<ul class="simple">
+<li><a class="reference internal" href="#introduction" id="id1">Introduction</a></li>
+<li><a class="reference internal" href="#actions" id="id2">Actions</a></li>
+<li><a class="reference internal" href="#compilation-flags" id="id3">Compilation flags</a><ul>
+<li><a class="reference internal" href="#preprocessor-flags" id="id4">Preprocessor flags</a><ul>
+<li><a class="reference internal" href="#include-path-management" id="id5">Include path management</a></li>
+<li><a class="reference internal" href="#dependency-file-generation" id="id6">Dependency file generation</a></li>
+<li><a class="reference internal" href="#dumping-preprocessor-state" id="id7">Dumping preprocessor state</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#diagnostic-flags" id="id8">Diagnostic flags</a></li>
+<li><a class="reference internal" href="#target-independent-compilation-options" id="id9">Target-independent compilation options</a><ul>
+<li><a class="reference internal" href="#opencl-flags" id="id10">OpenCL flags</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#target-dependent-compilation-options" id="id11">Target-dependent compilation options</a><ul>
+<li><a class="reference internal" href="#aarch64" id="id12">AARCH64</a></li>
+<li><a class="reference internal" href="#amdgpu" id="id13">AMDGPU</a></li>
+<li><a class="reference internal" href="#arm" id="id14">ARM</a></li>
+<li><a class="reference internal" href="#hexagon" id="id15">Hexagon</a></li>
+<li><a class="reference internal" href="#powerpc" id="id16">PowerPC</a></li>
+<li><a class="reference internal" href="#webassembly" id="id17">WebAssembly</a></li>
+<li><a class="reference internal" href="#x86" id="id18">X86</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#optimization-level" id="id19">Optimization level</a></li>
+<li><a class="reference internal" href="#debug-information-generation" id="id20">Debug information generation</a><ul>
+<li><a class="reference internal" href="#kind-and-level-of-debug-information" id="id21">Kind and level of debug information</a><ul>
+<li><a class="reference internal" href="#debug-level" id="id22">Debug level</a></li>
+<li><a class="reference internal" href="#debugger-to-tune-debug-information-for" id="id23">Debugger to tune debug information for</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#debug-information-flags" id="id24">Debug information flags</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#static-analyzer-flags" id="id25">Static analyzer flags</a></li>
+<li><a class="reference internal" href="#fortran-compilation-flags" id="id26">Fortran compilation flags</a></li>
+<li><a class="reference internal" href="#linker-flags" id="id27">Linker flags</a></li>
+</ul>
+</div>
+<div class="section" id="introduction">
+<h2><a class="toc-backref" href="#id1">Introduction</a><a class="headerlink" href="#introduction" title="Permalink to this headline">Â¶</a></h2>
+<p>This page lists the command line arguments currently supported by the
+GCC-compatible <tt class="docutils literal"><span class="pre">clang</span></tt> and <tt class="docutils literal"><span class="pre">clang++</span></tt> drivers.</p>
+<dl class="option">
+<dt id="cmdoption-clang-B">
+<span id="cmdoption-clang--prefix"></span><span id="cmdoption-clang--prefix"></span><tt class="descname">-B</tt><tt class="descclassname"><dir></tt><tt class="descclassname">, </tt><tt class="descname">--prefix</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--prefix</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-B" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Add <dir> to search path for binaries and object files used implicitly</p>
+<dl class="option">
+<dt id="cmdoption-clang-F">
+<tt class="descname">-F</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-F" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Add directory to framework include search path</p>
+<dl class="option">
+<dt id="cmdoption-clang-ObjC">
+<tt class="descname">-ObjC</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ObjC" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Treat source input files as Objective-C inputs</p>
+<dl class="option">
+<dt id="cmdoption-clang1-ObjC">
+<tt class="descname">-ObjC</tt><tt class="descclassname">++</tt><a class="headerlink" href="#cmdoption-clang1-ObjC" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Treat source input files as Objective-C++ inputs</p>
+<dl class="option">
+<dt id="cmdoption-clang-Qunused-arguments">
+<tt class="descname">-Qunused-arguments</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-Qunused-arguments" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Don’t emit warning for unused driver arguments</p>
+<dl class="option">
+<dt id="cmdoption-clang-Wa">
+<tt class="descname">-Wa</tt><tt class="descclassname">,<arg>,<arg2>...</tt><a class="headerlink" href="#cmdoption-clang-Wa" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Pass the comma separated arguments in <arg> to the assembler</p>
+<dl class="option">
+<dt id="cmdoption-clang-Wlarge-by-value-copy">
+<tt class="descname">-Wlarge-by-value-copy</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-Wlarge-by-value-copy" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-Xarch_">
+<tt class="descname">-Xarch_</tt><tt class="descclassname"><arg1> <arg2></tt><a class="headerlink" href="#cmdoption-clang-Xarch_" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-Xcuda-fatbinary">
+<tt class="descname">-Xcuda-fatbinary</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-Xcuda-fatbinary" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Pass <arg> to fatbinary invocation</p>
+<dl class="option">
+<dt id="cmdoption-clang-Xcuda-ptxas">
+<tt class="descname">-Xcuda-ptxas</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-Xcuda-ptxas" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Pass <arg> to the ptxas assembler</p>
+<dl class="option">
+<dt id="cmdoption-clang-Z">
+<tt class="descname">-Z</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-Z" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-a">
+<span id="cmdoption-clang--profile-blocks"></span><tt class="descname">-a</tt><tt class="descclassname"><arg></tt><tt class="descclassname">, </tt><tt class="descname">--profile-blocks</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-a" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-all_load">
+<tt class="descname">-all_load</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-all_load" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-allowable_client">
+<tt class="descname">-allowable_client</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-allowable_client" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang--analyze">
+<tt class="descname">--analyze</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--analyze" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Run the static analyzer</p>
+<dl class="option">
+<dt id="cmdoption-clang--analyze-auto">
+<tt class="descname">--analyze-auto</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--analyze-auto" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang--analyzer-no-default-checks">
+<tt class="descname">--analyzer-no-default-checks</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--analyzer-no-default-checks" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang--analyzer-output">
+<tt class="descname">--analyzer-output</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang--analyzer-output" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Static analyzer report output format (html|plist|plist-multi-file|plist-html|text).</p>
+<dl class="option">
+<dt id="cmdoption-clang-ansi">
+<span id="cmdoption-clang--ansi"></span><tt class="descname">-ansi</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--ansi</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ansi" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-arch">
+<tt class="descname">-arch</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-arch" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-arch_errors_fatal">
+<tt class="descname">-arch_errors_fatal</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang1-arch_errors_fatal" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang2-arch_only">
+<tt class="descname">-arch_only</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang2-arch_only" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-arcmt-migrate-emit-errors">
+<tt class="descname">-arcmt-migrate-emit-errors</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-arcmt-migrate-emit-errors" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Emit ARC errors even if the migrator can fix them</p>
+<dl class="option">
+<dt id="cmdoption-clang-arcmt-migrate-report-output">
+<tt class="descname">-arcmt-migrate-report-output</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-arcmt-migrate-report-output" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Output path for the plist report</p>
+<dl class="option">
+<dt id="cmdoption-clang--autocomplete">
+<tt class="descname">--autocomplete</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang--autocomplete" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-bind_at_load">
+<tt class="descname">-bind_at_load</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-bind_at_load" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-bundle">
+<tt class="descname">-bundle</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-bundle" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-bundle_loader">
+<tt class="descname">-bundle_loader</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang1-bundle_loader" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-client_name">
+<tt class="descname">-client_name</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-client_name" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-compatibility_version">
+<tt class="descname">-compatibility_version</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-compatibility_version" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang--constant-cfstrings">
+<tt class="descname">--constant-cfstrings</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--constant-cfstrings" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-coverage">
+<span id="cmdoption-clang--coverage"></span><tt class="descname">-coverage</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--coverage</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-coverage" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang--cuda-compile-host-device">
+<tt class="descname">--cuda-compile-host-device</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--cuda-compile-host-device" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Compile CUDA code for both host and device (default).  Has no effect on non-CUDA compilations.</p>
+<dl class="option">
+<dt id="cmdoption-clang--cuda-device-only">
+<tt class="descname">--cuda-device-only</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--cuda-device-only" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Compile CUDA code for device only</p>
+<dl class="option">
+<dt id="cmdoption-clang--cuda-gpu-arch">
+<span id="cmdoption-clang--no-cuda-gpu-arch"></span><tt class="descname">--cuda-gpu-arch</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--no-cuda-gpu-arch</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang--cuda-gpu-arch" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>CUDA GPU architecture (e.g. sm_35).  May be specified more than once.</p>
+<dl class="option">
+<dt id="cmdoption-clang--cuda-host-only">
+<tt class="descname">--cuda-host-only</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--cuda-host-only" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Compile CUDA code for host only.  Has no effect on non-CUDA compilations.</p>
+<dl class="option">
+<dt id="cmdoption-clang--cuda-noopt-device-debug">
+<span id="cmdoption-clang--no-cuda-noopt-device-debug"></span><tt class="descname">--cuda-noopt-device-debug</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--no-cuda-noopt-device-debug</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--cuda-noopt-device-debug" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable device-side debug info generation. Disables ptxas optimizations.</p>
+<dl class="option">
+<dt id="cmdoption-clang-current_version">
+<tt class="descname">-current_version</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-current_version" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-dead_strip">
+<tt class="descname">-dead_strip</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-dead_strip" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-dependency-dot">
+<tt class="descname">-dependency-dot</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-dependency-dot" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Filename to write DOT-formatted header dependencies to</p>
+<dl class="option">
+<dt id="cmdoption-clang-dependency-file">
+<tt class="descname">-dependency-file</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-dependency-file" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Filename (or -) to write dependency output to</p>
+<dl class="option">
+<dt id="cmdoption-clang-dumpmachine">
+<tt class="descname">-dumpmachine</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-dumpmachine" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-dumpversion">
+<tt class="descname">-dumpversion</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-dumpversion" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang--dyld-prefix">
+<span id="cmdoption-clang--dyld-prefix"></span><tt class="descname">--dyld-prefix</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--dyld-prefix</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang--dyld-prefix" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-dylib_file">
+<tt class="descname">-dylib_file</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-dylib_file" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-dylinker">
+<tt class="descname">-dylinker</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-dylinker" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-dylinker_install_name">
+<tt class="descname">-dylinker_install_name</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang1-dylinker_install_name" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-dynamic">
+<tt class="descname">-dynamic</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-dynamic" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-dynamiclib">
+<tt class="descname">-dynamiclib</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-dynamiclib" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-emit-ast">
+<tt class="descname">-emit-ast</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-emit-ast" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Emit Clang AST files for source inputs</p>
+<dl class="option">
+<dt id="cmdoption-clang-exported_symbols_list">
+<tt class="descname">-exported_symbols_list</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-exported_symbols_list" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-faligned-new">
+<tt class="descname">-faligned-new</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-faligned-new" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fcuda-approx-transcendentals">
+<span id="cmdoption-clang-fno-cuda-approx-transcendentals"></span><tt class="descname">-fcuda-approx-transcendentals</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-cuda-approx-transcendentals</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fcuda-approx-transcendentals" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Use approximate transcendental functions</p>
+<dl class="option">
+<dt id="cmdoption-clang-fcuda-flush-denormals-to-zero">
+<span id="cmdoption-clang-fno-cuda-flush-denormals-to-zero"></span><tt class="descname">-fcuda-flush-denormals-to-zero</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-cuda-flush-denormals-to-zero</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fcuda-flush-denormals-to-zero" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Flush denormal floating point values to zero in CUDA device mode.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fheinous-gnu-extensions">
+<tt class="descname">-fheinous-gnu-extensions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fheinous-gnu-extensions" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-flat_namespace">
+<tt class="descname">-flat_namespace</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-flat_namespace" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fopenmp-targets">
+<tt class="descname">-fopenmp-targets</tt><tt class="descclassname">=<arg1>,<arg2>...</tt><a class="headerlink" href="#cmdoption-clang-fopenmp-targets" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify comma-separated list of triples OpenMP offloading targets to be supported</p>
+<dl class="option">
+<dt id="cmdoption-clang-force_cpusubtype_ALL">
+<tt class="descname">-force_cpusubtype_ALL</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-force_cpusubtype_ALL" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-force_flat_namespace">
+<tt class="descname">-force_flat_namespace</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang1-force_flat_namespace" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang2-force_load">
+<tt class="descname">-force_load</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang2-force_load" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-framework">
+<tt class="descname">-framework</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-framework" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-frtlib-add-rpath">
+<span id="cmdoption-clang-fno-rtlib-add-rpath"></span><tt class="descname">-frtlib-add-rpath</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-rtlib-add-rpath</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-frtlib-add-rpath" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Add -rpath with architecture-specific resource directory to the linker flags</p>
+<dl class="option">
+<dt id="cmdoption-clang--gcc-toolchain">
+<span id="cmdoption-clang-gcc-toolchain"></span><tt class="descname">--gcc-toolchain</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">-gcc-toolchain</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang--gcc-toolchain" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Use the gcc toolchain at the given directory</p>
+<dl class="option">
+<dt id="cmdoption-clang-gcodeview">
+<tt class="descname">-gcodeview</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gcodeview" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate CodeView debug information</p>
+<dl class="option">
+<dt id="cmdoption-clang-headerpad_max_install_names">
+<tt class="descname">-headerpad_max_install_names</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-headerpad_max_install_names" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-help">
+<span id="cmdoption-clang--help"></span><tt class="descname">-help</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--help</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-help" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Display available options</p>
+<dl class="option">
+<dt id="cmdoption-clang--help-hidden">
+<tt class="descname">--help-hidden</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--help-hidden" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-image_base">
+<tt class="descname">-image_base</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-image_base" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-index-header-map">
+<tt class="descname">-index-header-map</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-index-header-map" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Make the next included directory (-I or -F) an indexer header map</p>
+<dl class="option">
+<dt id="cmdoption-clang-init">
+<tt class="descname">-init</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-init" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-install_name">
+<tt class="descname">-install_name</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-install_name" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-keep_private_externs">
+<tt class="descname">-keep_private_externs</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-keep_private_externs" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-lazy_framework">
+<tt class="descname">-lazy_framework</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-lazy_framework" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-lazy_library">
+<tt class="descname">-lazy_library</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang1-lazy_library" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mbig-endian">
+<span id="cmdoption-clang-EB"></span><tt class="descname">-mbig-endian</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-EB</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mbig-endian" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang--migrate">
+<tt class="descname">--migrate</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--migrate" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Run the migrator</p>
+<dl class="option">
+<dt id="cmdoption-clang-mios-simulator-version-min">
+<span id="cmdoption-clang-miphonesimulator-version-min"></span><tt class="descname">-mios-simulator-version-min</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">-miphonesimulator-version-min</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mios-simulator-version-min" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mlinker-version">
+<tt class="descname">-mlinker-version</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mlinker-version" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mlittle-endian">
+<span id="cmdoption-clang-EL"></span><tt class="descname">-mlittle-endian</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-EL</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mlittle-endian" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mllvm">
+<tt class="descname">-mllvm</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-mllvm" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Additional arguments to forward to LLVM’s option processing</p>
+<dl class="option">
+<dt id="cmdoption-clang-module-dependency-dir">
+<tt class="descname">-module-dependency-dir</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-module-dependency-dir" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Directory to dump module dependencies to</p>
+<dl class="option">
+<dt id="cmdoption-clang-mtvos-simulator-version-min">
+<span id="cmdoption-clang-mappletvsimulator-version-min"></span><tt class="descname">-mtvos-simulator-version-min</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">-mappletvsimulator-version-min</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mtvos-simulator-version-min" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-multi_module">
+<tt class="descname">-multi_module</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-multi_module" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-multiply_defined">
+<tt class="descname">-multiply_defined</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-multiply_defined" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-multiply_defined_unused">
+<tt class="descname">-multiply_defined_unused</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang1-multiply_defined_unused" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mwatchos-simulator-version-min">
+<span id="cmdoption-clang-mwatchsimulator-version-min"></span><tt class="descname">-mwatchos-simulator-version-min</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">-mwatchsimulator-version-min</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mwatchos-simulator-version-min" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang--no-cuda-version-check">
+<tt class="descname">--no-cuda-version-check</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--no-cuda-version-check" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Don’t error out if the detected version of the CUDA install is too low for the requested CUDA gpu architecture.</p>
+<dl class="option">
+<dt id="cmdoption-clang-no-integrated-cpp">
+<span id="cmdoption-clang--no-integrated-cpp"></span><tt class="descname">-no-integrated-cpp</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--no-integrated-cpp</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-no-integrated-cpp" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-no_dead_strip_inits_and_terms">
+<tt class="descname">-no_dead_strip_inits_and_terms</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-no_dead_strip_inits_and_terms" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-nobuiltininc">
+<tt class="descname">-nobuiltininc</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-nobuiltininc" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Disable builtin #include directories</p>
+<dl class="option">
+<dt id="cmdoption-clang-nocudainc">
+<tt class="descname">-nocudainc</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-nocudainc" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-nocudalib">
+<tt class="descname">-nocudalib</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-nocudalib" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-nodefaultlibs">
+<tt class="descname">-nodefaultlibs</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-nodefaultlibs" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-nofixprebinding">
+<tt class="descname">-nofixprebinding</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-nofixprebinding" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-nolibc">
+<tt class="descname">-nolibc</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-nolibc" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-nomultidefs">
+<tt class="descname">-nomultidefs</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-nomultidefs" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-nopie">
+<span id="cmdoption-clang-no-pie"></span><tt class="descname">-nopie</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-no-pie</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-nopie" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-noprebind">
+<tt class="descname">-noprebind</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-noprebind" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-noseglinkedit">
+<tt class="descname">-noseglinkedit</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-noseglinkedit" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-nostartfiles">
+<tt class="descname">-nostartfiles</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-nostartfiles" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-nostdinc">
+<span id="cmdoption-clang--no-standard-includes"></span><tt class="descname">-nostdinc</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--no-standard-includes</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-nostdinc" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-nostdinc">
+<tt class="descname">-nostdinc</tt><tt class="descclassname">++</tt><a class="headerlink" href="#cmdoption-clang1-nostdinc" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Disable standard #include directories for the C++ standard library</p>
+<dl class="option">
+<dt id="cmdoption-clang-nostdlib">
+<span id="cmdoption-clang--no-standard-libraries"></span><tt class="descname">-nostdlib</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--no-standard-libraries</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-nostdlib" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-nostdlibinc">
+<tt class="descname">-nostdlibinc</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-nostdlibinc" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-o">
+<span id="cmdoption-clang--output"></span><span id="cmdoption-clang--output"></span><tt class="descname">-o</tt><tt class="descclassname"><file></tt><tt class="descclassname">, </tt><tt class="descname">--output</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--output</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-o" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Write output to <file></p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-atomic-property">
+<tt class="descname">-objcmt-atomic-property</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-atomic-property" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Make migration to ‘atomic’ properties</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-migrate-all">
+<tt class="descname">-objcmt-migrate-all</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-migrate-all" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable migration to modern ObjC</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-migrate-annotation">
+<tt class="descname">-objcmt-migrate-annotation</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-migrate-annotation" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable migration to property and method annotations</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-migrate-designated-init">
+<tt class="descname">-objcmt-migrate-designated-init</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-migrate-designated-init" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable migration to infer NS_DESIGNATED_INITIALIZER for initializer methods</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-migrate-instancetype">
+<tt class="descname">-objcmt-migrate-instancetype</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-migrate-instancetype" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable migration to infer instancetype for method result type</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-migrate-literals">
+<tt class="descname">-objcmt-migrate-literals</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-migrate-literals" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable migration to modern ObjC literals</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-migrate-ns-macros">
+<tt class="descname">-objcmt-migrate-ns-macros</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-migrate-ns-macros" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable migration to NS_ENUM/NS_OPTIONS macros</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-migrate-property">
+<tt class="descname">-objcmt-migrate-property</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-migrate-property" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable migration to modern ObjC property</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-migrate-property-dot-syntax">
+<tt class="descname">-objcmt-migrate-property-dot-syntax</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-migrate-property-dot-syntax" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable migration of setter/getter messages to property-dot syntax</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-migrate-protocol-conformance">
+<tt class="descname">-objcmt-migrate-protocol-conformance</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-migrate-protocol-conformance" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable migration to add protocol conformance on classes</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-migrate-readonly-property">
+<tt class="descname">-objcmt-migrate-readonly-property</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-migrate-readonly-property" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable migration to modern ObjC readonly property</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-migrate-readwrite-property">
+<tt class="descname">-objcmt-migrate-readwrite-property</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-migrate-readwrite-property" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable migration to modern ObjC readwrite property</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-migrate-subscripting">
+<tt class="descname">-objcmt-migrate-subscripting</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-migrate-subscripting" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable migration to modern ObjC subscripting</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-ns-nonatomic-iosonly">
+<tt class="descname">-objcmt-ns-nonatomic-iosonly</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-ns-nonatomic-iosonly" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable migration to use NS_NONATOMIC_IOSONLY macro for setting property’s ‘atomic’ attribute</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-returns-innerpointer-property">
+<tt class="descname">-objcmt-returns-innerpointer-property</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-objcmt-returns-innerpointer-property" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable migration to annotate property with NS_RETURNS_INNER_POINTER</p>
+<dl class="option">
+<dt id="cmdoption-clang-objcmt-whitelist-dir-path">
+<span id="cmdoption-clang-objcmt-white-list-dir-path"></span><tt class="descname">-objcmt-whitelist-dir-path</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">-objcmt-white-list-dir-path</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-objcmt-whitelist-dir-path" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Only modify files with a filename contained in the provided directory path</p>
+<dl class="option">
+<dt id="cmdoption-clang-object">
+<tt class="descname">-object</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-object" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-p">
+<span id="cmdoption-clang--profile"></span><tt class="descname">-p</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--profile</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-p" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-pagezero_size">
+<tt class="descname">-pagezero_size</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-pagezero_size" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-pg">
+<tt class="descname">-pg</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-pg" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable mcount instrumentation</p>
+<dl class="option">
+<dt id="cmdoption-clang-pie">
+<tt class="descname">-pie</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-pie" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-pipe">
+<span id="cmdoption-clang--pipe"></span><tt class="descname">-pipe</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--pipe</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-pipe" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Use pipes between commands, when possible</p>
+<dl class="option">
+<dt id="cmdoption-clang-prebind">
+<tt class="descname">-prebind</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-prebind" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-prebind_all_twolevel_modules">
+<tt class="descname">-prebind_all_twolevel_modules</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang1-prebind_all_twolevel_modules" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-preload">
+<tt class="descname">-preload</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-preload" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang--print-diagnostic-categories">
+<tt class="descname">--print-diagnostic-categories</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--print-diagnostic-categories" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-print-file-name">
+<span id="cmdoption-clang--print-file-name"></span><span id="cmdoption-clang--print-file-name"></span><tt class="descname">-print-file-name</tt><tt class="descclassname">=<file></tt><tt class="descclassname">, </tt><tt class="descname">--print-file-name</tt><tt class="descclassname">=<file></tt><tt class="descclassname">, </tt><tt class="descname">--print-file-name</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-print-file-name" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Print the full library path of <file></p>
+<dl class="option">
+<dt id="cmdoption-clang-print-ivar-layout">
+<tt class="descname">-print-ivar-layout</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-print-ivar-layout" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable Objective-C Ivar layout bitmap print trace</p>
+<dl class="option">
+<dt id="cmdoption-clang-print-libgcc-file-name">
+<span id="cmdoption-clang--print-libgcc-file-name"></span><tt class="descname">-print-libgcc-file-name</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--print-libgcc-file-name</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-print-libgcc-file-name" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Print the library path for the currently used compiler runtime library (“libgcc.a” or “libclang_rt.builtins.*.a”)</p>
+<dl class="option">
+<dt id="cmdoption-clang-print-multi-directory">
+<span id="cmdoption-clang--print-multi-directory"></span><tt class="descname">-print-multi-directory</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--print-multi-directory</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-print-multi-directory" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-print-multi-lib">
+<span id="cmdoption-clang--print-multi-lib"></span><tt class="descname">-print-multi-lib</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--print-multi-lib</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-print-multi-lib" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-print-prog-name">
+<span id="cmdoption-clang--print-prog-name"></span><span id="cmdoption-clang--print-prog-name"></span><tt class="descname">-print-prog-name</tt><tt class="descclassname">=<name></tt><tt class="descclassname">, </tt><tt class="descname">--print-prog-name</tt><tt class="descclassname">=<name></tt><tt class="descclassname">, </tt><tt class="descname">--print-prog-name</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-print-prog-name" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Print the full program path of <name></p>
+<dl class="option">
+<dt id="cmdoption-clang-print-resource-dir">
+<span id="cmdoption-clang--print-resource-dir"></span><tt class="descname">-print-resource-dir</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--print-resource-dir</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-print-resource-dir" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Print the resource directory pathname</p>
+<dl class="option">
+<dt id="cmdoption-clang-print-search-dirs">
+<span id="cmdoption-clang--print-search-dirs"></span><tt class="descname">-print-search-dirs</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--print-search-dirs</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-print-search-dirs" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Print the paths used for finding libraries and programs</p>
+<dl class="option">
+<dt id="cmdoption-clang-private_bundle">
+<tt class="descname">-private_bundle</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-private_bundle" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-pthread">
+<span id="cmdoption-clang-no-pthread"></span><tt class="descname">-pthread</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-no-pthread</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-pthread" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Support POSIX threads in generated code</p>
+<dl class="option">
+<dt id="cmdoption-clang-pthreads">
+<tt class="descname">-pthreads</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-pthreads" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-rdynamic">
+<tt class="descname">-rdynamic</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-rdynamic" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-read_only_relocs">
+<tt class="descname">-read_only_relocs</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-read_only_relocs" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-relocatable-pch">
+<span id="cmdoption-clang--relocatable-pch"></span><tt class="descname">-relocatable-pch</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--relocatable-pch</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-relocatable-pch" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Whether to build a relocatable precompiled header</p>
+<dl class="option">
+<dt id="cmdoption-clang-remap">
+<tt class="descname">-remap</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-remap" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-rewrite-legacy-objc">
+<tt class="descname">-rewrite-legacy-objc</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-rewrite-legacy-objc" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Rewrite Legacy Objective-C source to C++</p>
+<dl class="option">
+<dt id="cmdoption-clang-rtlib">
+<span id="cmdoption-clang--rtlib"></span><span id="cmdoption-clang--rtlib"></span><tt class="descname">-rtlib</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--rtlib</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--rtlib</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-rtlib" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Compiler runtime library to use</p>
+<dl class="option">
+<dt id="cmdoption-clang-save-stats">
+<span id="cmdoption-clang--save-stats"></span><span id="cmdoption-clang-save-stats"></span><span id="cmdoption-clang--save-stats"></span><tt class="descname">-save-stats</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--save-stats</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">-save-stats</tt><tt class="descclassname"> (equivalent to -save-stats=cwd)</tt><tt class="descclassname">, </tt><tt class="descname">--save-stats</tt><tt class="descclassname"> (equivalent to -save-stats=cwd)</tt><a class="headerlink" href="#cmdoption-clang-save-stats" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Save llvm statistics.</p>
+<dl class="option">
+<dt id="cmdoption-clang-save-temps">
+<span id="cmdoption-clang--save-temps"></span><span id="cmdoption-clang-save-temps"></span><span id="cmdoption-clang--save-temps"></span><tt class="descname">-save-temps</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--save-temps</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">-save-temps</tt><tt class="descclassname"> (equivalent to -save-temps=cwd)</tt><tt class="descclassname">, </tt><tt class="descname">--save-temps</tt><tt class="descclassname"> (equivalent to -save-temps=cwd)</tt><a class="headerlink" href="#cmdoption-clang-save-temps" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Save intermediate compilation results.</p>
+<dl class="option">
+<dt id="cmdoption-clang-sectalign">
+<tt class="descname">-sectalign</tt><tt class="descclassname"> <arg1> <arg2> <arg3></tt><a class="headerlink" href="#cmdoption-clang-sectalign" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-sectcreate">
+<tt class="descname">-sectcreate</tt><tt class="descclassname"> <arg1> <arg2> <arg3></tt><a class="headerlink" href="#cmdoption-clang-sectcreate" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-sectobjectsymbols">
+<tt class="descname">-sectobjectsymbols</tt><tt class="descclassname"> <arg1> <arg2></tt><a class="headerlink" href="#cmdoption-clang-sectobjectsymbols" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-sectorder">
+<tt class="descname">-sectorder</tt><tt class="descclassname"> <arg1> <arg2> <arg3></tt><a class="headerlink" href="#cmdoption-clang-sectorder" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-seg1addr">
+<tt class="descname">-seg1addr</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-seg1addr" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-seg_addr_table">
+<tt class="descname">-seg_addr_table</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-seg_addr_table" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-seg_addr_table_filename">
+<tt class="descname">-seg_addr_table_filename</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang1-seg_addr_table_filename" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-segaddr">
+<tt class="descname">-segaddr</tt><tt class="descclassname"> <arg1> <arg2></tt><a class="headerlink" href="#cmdoption-clang-segaddr" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-segcreate">
+<tt class="descname">-segcreate</tt><tt class="descclassname"> <arg1> <arg2> <arg3></tt><a class="headerlink" href="#cmdoption-clang-segcreate" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-seglinkedit">
+<tt class="descname">-seglinkedit</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-seglinkedit" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-segprot">
+<tt class="descname">-segprot</tt><tt class="descclassname"> <arg1> <arg2> <arg3></tt><a class="headerlink" href="#cmdoption-clang-segprot" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-segs_read_">
+<tt class="descname">-segs_read_</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-segs_read_" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-segs_read_only_addr">
+<tt class="descname">-segs_read_only_addr</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang1-segs_read_only_addr" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang2-segs_read_write_addr">
+<tt class="descname">-segs_read_write_addr</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang2-segs_read_write_addr" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-serialize-diagnostics">
+<span id="cmdoption-clang--serialize-diagnostics"></span><tt class="descname">-serialize-diagnostics</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--serialize-diagnostics</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-serialize-diagnostics" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Serialize compiler diagnostics to a file</p>
+<dl class="option">
+<dt id="cmdoption-clang-shared">
+<span id="cmdoption-clang--shared"></span><tt class="descname">-shared</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--shared</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-shared" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-shared-libasan">
+<tt class="descname">-shared-libasan</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-shared-libasan" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-shared-libgcc">
+<tt class="descname">-shared-libgcc</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-shared-libgcc" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-single_module">
+<tt class="descname">-single_module</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-single_module" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-specs">
+<span id="cmdoption-clang--specs"></span><tt class="descname">-specs</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--specs</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-specs" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-static">
+<span id="cmdoption-clang--static"></span><tt class="descname">-static</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--static</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-static" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-static-libgcc">
+<tt class="descname">-static-libgcc</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-static-libgcc" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-static-libstdc">
+<tt class="descname">-static-libstdc</tt><tt class="descclassname">++</tt><a class="headerlink" href="#cmdoption-clang-static-libstdc" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-std-default">
+<tt class="descname">-std-default</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-std-default" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-stdlib">
+<span id="cmdoption-clang--stdlib"></span><span id="cmdoption-clang--stdlib"></span><tt class="descname">-stdlib</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--stdlib</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--stdlib</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-stdlib" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>C++ standard library to use</p>
+<dl class="option">
+<dt id="cmdoption-clang-sub_library">
+<tt class="descname">-sub_library</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-sub_library" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-sub_umbrella">
+<tt class="descname">-sub_umbrella</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang1-sub_umbrella" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang--sysroot">
+<span id="cmdoption-clang--sysroot"></span><tt class="descname">--sysroot</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--sysroot</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang--sysroot" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang--target-help">
+<tt class="descname">--target-help</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--target-help" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang--target">
+<span id="cmdoption-clang-target"></span><tt class="descname">--target</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">-target</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang--target" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate code for the given target</p>
+<dl class="option">
+<dt id="cmdoption-clang-time">
+<tt class="descname">-time</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-time" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Time individual commands</p>
+<dl class="option">
+<dt id="cmdoption-clang-traditional">
+<span id="cmdoption-clang--traditional"></span><tt class="descname">-traditional</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--traditional</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-traditional" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-traditional-cpp">
+<span id="cmdoption-clang--traditional-cpp"></span><tt class="descname">-traditional-cpp</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--traditional-cpp</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-traditional-cpp" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable some traditional CPP emulation</p>
+<dl class="option">
+<dt id="cmdoption-clang-twolevel_namespace">
+<tt class="descname">-twolevel_namespace</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-twolevel_namespace" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-twolevel_namespace_hints">
+<tt class="descname">-twolevel_namespace_hints</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang1-twolevel_namespace_hints" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-umbrella">
+<tt class="descname">-umbrella</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-umbrella" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-unexported_symbols_list">
+<tt class="descname">-unexported_symbols_list</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-unexported_symbols_list" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-v">
+<span id="cmdoption-clang--verbose"></span><tt class="descname">-v</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--verbose</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-v" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Show commands to run and use verbose output</p>
+<dl class="option">
+<dt id="cmdoption-clang--verify-debug-info">
+<tt class="descname">--verify-debug-info</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--verify-debug-info" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Verify the binary representation of debug output</p>
+<dl class="option">
+<dt id="cmdoption-clang--version">
+<tt class="descname">--version</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--version" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-w">
+<span id="cmdoption-clang--no-warnings"></span><tt class="descname">-w</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--no-warnings</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-w" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Suppress all warnings</p>
+<dl class="option">
+<dt id="cmdoption-clang-weak-l">
+<tt class="descname">-weak-l</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-weak-l" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-weak_framework">
+<tt class="descname">-weak_framework</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-weak_framework" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-weak_library">
+<tt class="descname">-weak_library</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang1-weak_library" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang2-weak_reference_mismatches">
+<tt class="descname">-weak_reference_mismatches</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang2-weak_reference_mismatches" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-whatsloaded">
+<tt class="descname">-whatsloaded</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-whatsloaded" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-whyload">
+<tt class="descname">-whyload</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-whyload" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-working-directory">
+<span id="cmdoption-clang-working-directory"></span><tt class="descname">-working-directory</tt><tt class="descclassname"><arg></tt><tt class="descclassname">, </tt><tt class="descname">-working-directory</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-working-directory" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Resolve file paths relative to the specified directory</p>
+<dl class="option">
+<dt id="cmdoption-clang-x">
+<span id="cmdoption-clang--language"></span><span id="cmdoption-clang--language"></span><tt class="descname">-x</tt><tt class="descclassname"><language></tt><tt class="descclassname">, </tt><tt class="descname">--language</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--language</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-x" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Treat subsequent input files as having type <language></p>
+<dl class="option">
+<dt id="cmdoption-clang-y">
+<tt class="descname">-y</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-y" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+</div>
+<div class="section" id="actions">
+<h2><a class="toc-backref" href="#id2">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">
+<span id="cmdoption-clang--preprocess"></span><tt class="descname">-E</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--preprocess</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-E" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Only run the preprocessor</p>
+<dl class="option">
+<dt id="cmdoption-clang-S">
+<span id="cmdoption-clang--assemble"></span><tt class="descname">-S</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--assemble</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-S" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Only run preprocess and compilation steps</p>
+<dl class="option">
+<dt id="cmdoption-clang-c">
+<span id="cmdoption-clang--compile"></span><tt class="descname">-c</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--compile</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-c" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Only run preprocess, compile, and assemble steps</p>
+<dl class="option">
+<dt id="cmdoption-clang-emit-llvm">
+<tt class="descname">-emit-llvm</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-emit-llvm" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Use the LLVM representation for assembler and object files</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsyntax-only">
+<tt class="descname">-fsyntax-only</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsyntax-only" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-module-file-info">
+<tt class="descname">-module-file-info</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-module-file-info" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Provide information about a particular module file</p>
+<dl class="option">
+<dt id="cmdoption-clang--precompile">
+<tt class="descname">--precompile</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang--precompile" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Only precompile the input</p>
+<dl class="option">
+<dt id="cmdoption-clang-rewrite-objc">
+<tt class="descname">-rewrite-objc</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-rewrite-objc" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Rewrite Objective-C source to C++</p>
+<dl class="option">
+<dt id="cmdoption-clang-verify-pch">
+<tt class="descname">-verify-pch</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-verify-pch" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Load and verify that a pre-compiled header file is not stale</p>
+</div>
+<div class="section" id="compilation-flags">
+<h2><a class="toc-backref" href="#id3">Compilation flags</a><a class="headerlink" href="#compilation-flags" title="Permalink to this headline">Â¶</a></h2>
+<p>Flags controlling the behavior of Clang during compilation. These flags have
+no effect during actions that do not perform compilation.</p>
+<dl class="option">
+<dt id="cmdoption-clang-Xassembler">
+<tt class="descname">-Xassembler</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-Xassembler" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Pass <arg> to the assembler</p>
+<dl class="option">
+<dt id="cmdoption-clang-Xclang">
+<tt class="descname">-Xclang</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-Xclang" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Pass <arg> to the clang compiler</p>
+<dl class="option">
+<dt id="cmdoption-clang-fclang-abi-compat">
+<tt class="descname">-fclang-abi-compat</tt><tt class="descclassname">=<version></tt><a class="headerlink" href="#cmdoption-clang-fclang-abi-compat" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Attempt to match the ABI of Clang <version></p>
+<dl class="option">
+<dt id="cmdoption-clang-fcomment-block-commands">
+<tt class="descname">-fcomment-block-commands</tt><tt class="descclassname">=<arg>,<arg2>...</tt><a class="headerlink" href="#cmdoption-clang-fcomment-block-commands" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Treat each comma separated argument in <arg> as a documentation comment block command</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdeclspec">
+<span id="cmdoption-clang-fno-declspec"></span><tt class="descname">-fdeclspec</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-declspec</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdeclspec" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Allow __declspec as a keyword</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdepfile-entry">
+<tt class="descname">-fdepfile-entry</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fdepfile-entry" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdiagnostics-fixit-info">
+<span id="cmdoption-clang-fno-diagnostics-fixit-info"></span><tt class="descname">-fdiagnostics-fixit-info</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-diagnostics-fixit-info</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdiagnostics-fixit-info" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdiagnostics-format">
+<tt class="descname">-fdiagnostics-format</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fdiagnostics-format" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdiagnostics-parseable-fixits">
+<tt class="descname">-fdiagnostics-parseable-fixits</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdiagnostics-parseable-fixits" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Print fix-its in machine parseable form</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdiagnostics-print-source-range-info">
+<tt class="descname">-fdiagnostics-print-source-range-info</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdiagnostics-print-source-range-info" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Print source range spans in numeric form</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdiagnostics-show-category">
+<tt class="descname">-fdiagnostics-show-category</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fdiagnostics-show-category" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fexperimental-new-pass-manager">
+<span id="cmdoption-clang-fno-experimental-new-pass-manager"></span><tt class="descname">-fexperimental-new-pass-manager</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-experimental-new-pass-manager</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fexperimental-new-pass-manager" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enables an experimental new pass manager in LLVM.</p>
+<dl class="option">
+<dt id="cmdoption-clang-finline-functions">
+<span id="cmdoption-clang-fno-inline-functions"></span><tt class="descname">-finline-functions</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-inline-functions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-finline-functions" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Inline suitable functions</p>
+<dl class="option">
+<dt id="cmdoption-clang-finline-hint-functions">
+<tt class="descname">-finline-hint-functions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-finline-hint-functions" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Inline functions which are (explicitly or implicitly) marked inline</p>
+<dl class="option">
+<dt id="cmdoption-clang-fno-crash-diagnostics">
+<tt class="descname">-fno-crash-diagnostics</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fno-crash-diagnostics" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Disable auto-generation of preprocessed source files and a script for reproduction during a clang crash</p>
+<dl class="option">
+<dt id="cmdoption-clang-fno-sanitize-blacklist">
+<tt class="descname">-fno-sanitize-blacklist</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fno-sanitize-blacklist" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Don’t use blacklist file for sanitizers</p>
+<dl class="option">
+<dt id="cmdoption-clang-fparse-all-comments">
+<tt class="descname">-fparse-all-comments</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fparse-all-comments" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-address-field-padding">
+<tt class="descname">-fsanitize-address-field-padding</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-address-field-padding" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Level of field padding for AddressSanitizer</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-address-globals-dead-stripping">
+<tt class="descname">-fsanitize-address-globals-dead-stripping</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-address-globals-dead-stripping" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable linker dead stripping of globals in AddressSanitizer</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-address-use-after-scope">
+<span id="cmdoption-clang-fno-sanitize-address-use-after-scope"></span><tt class="descname">-fsanitize-address-use-after-scope</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-sanitize-address-use-after-scope</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-address-use-after-scope" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable use-after-scope detection in AddressSanitizer</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-blacklist">
+<tt class="descname">-fsanitize-blacklist</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-blacklist" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Path to blacklist file for sanitizers</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-cfi-cross-dso">
+<span id="cmdoption-clang-fno-sanitize-cfi-cross-dso"></span><tt class="descname">-fsanitize-cfi-cross-dso</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-sanitize-cfi-cross-dso</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-cfi-cross-dso" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable control flow integrity (CFI) checks for cross-DSO calls.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-coverage">
+<span id="cmdoption-clang-fno-sanitize-coverage"></span><tt class="descname">-fsanitize-coverage</tt><tt class="descclassname">=<arg1>,<arg2>...</tt><tt class="descclassname">, </tt><tt class="descname">-fno-sanitize-coverage</tt><tt class="descclassname">=<arg1>,<arg2>...</tt><a class="headerlink" href="#cmdoption-clang-fsanitize-coverage" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify the type of coverage instrumentation for Sanitizers</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-link-c">
+<tt class="descname">-fsanitize-link-c</tt><tt class="descclassname">++-runtime</tt><a class="headerlink" href="#cmdoption-clang-fsanitize-link-c" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-memory-track-origins">
+<span id="cmdoption-clang-fno-sanitize-memory-track-origins"></span><tt class="descname">-fsanitize-memory-track-origins</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-sanitize-memory-track-origins</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-memory-track-origins" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable origins tracking in MemorySanitizer</p>
+<dl class="option">
+<dt id="cmdoption-clang1-fsanitize-memory-track-origins">
+<tt class="descname">-fsanitize-memory-track-origins</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang1-fsanitize-memory-track-origins" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable origins tracking in MemorySanitizer</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-memory-use-after-dtor">
+<tt class="descname">-fsanitize-memory-use-after-dtor</tt><tt class="descclassname"></tt><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-recover">
+<span id="cmdoption-clang-fno-sanitize-recover"></span><tt class="descname">-fsanitize-recover</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-sanitize-recover</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-recover" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-fsanitize-recover">
+<span id="cmdoption-clang1-fno-sanitize-recover"></span><tt class="descname">-fsanitize-recover</tt><tt class="descclassname">=<arg1>,<arg2>...</tt><tt class="descclassname">, </tt><tt class="descname">-fno-sanitize-recover</tt><tt class="descclassname">=<arg1>,<arg2>...</tt><a class="headerlink" href="#cmdoption-clang1-fsanitize-recover" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable recovery for specified sanitizers</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-stats">
+<span id="cmdoption-clang-fno-sanitize-stats"></span><tt class="descname">-fsanitize-stats</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-sanitize-stats</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-stats" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable sanitizer statistics gathering.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-thread-atomics">
+<span id="cmdoption-clang-fno-sanitize-thread-atomics"></span><tt class="descname">-fsanitize-thread-atomics</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-sanitize-thread-atomics</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-thread-atomics" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable atomic operations instrumentation in ThreadSanitizer (default)</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-thread-func-entry-exit">
+<span id="cmdoption-clang-fno-sanitize-thread-func-entry-exit"></span><tt class="descname">-fsanitize-thread-func-entry-exit</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-sanitize-thread-func-entry-exit</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-thread-func-entry-exit" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable function entry/exit instrumentation in ThreadSanitizer (default)</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-thread-memory-access">
+<span id="cmdoption-clang-fno-sanitize-thread-memory-access"></span><tt class="descname">-fsanitize-thread-memory-access</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-sanitize-thread-memory-access</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-thread-memory-access" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable memory access instrumentation in ThreadSanitizer (default)</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-trap">
+<span id="cmdoption-clang-fno-sanitize-trap"></span><tt class="descname">-fsanitize-trap</tt><tt class="descclassname">=<arg1>,<arg2>...</tt><tt class="descclassname">, </tt><tt class="descname">-fno-sanitize-trap</tt><tt class="descclassname">=<arg1>,<arg2>...</tt><a class="headerlink" href="#cmdoption-clang-fsanitize-trap" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable trapping for specified sanitizers</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-undefined-strip-path-components">
+<tt class="descname">-fsanitize-undefined-strip-path-components</tt><tt class="descclassname">=<number></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-undefined-strip-path-components" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Strip (or keep only, if negative) a given number of path components when emitting check metadata.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize-undefined-trap-on-error">
+<span id="cmdoption-clang-fno-sanitize-undefined-trap-on-error"></span><tt class="descname">-fsanitize-undefined-trap-on-error</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-sanitize-undefined-trap-on-error</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsanitize-undefined-trap-on-error" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fsanitize">
+<span id="cmdoption-clang-fno-sanitize"></span><tt class="descname">-fsanitize</tt><tt class="descclassname">=<check>,<arg2>...</tt><tt class="descclassname">, </tt><tt class="descname">-fno-sanitize</tt><tt class="descclassname">=<arg1>,<arg2>...</tt><a class="headerlink" href="#cmdoption-clang-fsanitize" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Turn on runtime checks for various forms of undefined or suspicious behavior. See user manual for available checks</p>
+<dl class="option">
+<dt id="cmdoption-clang--param">
+<span id="cmdoption-clang--param"></span><tt class="descname">--param</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--param</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang--param" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-std">
+<span id="cmdoption-clang--std"></span><span id="cmdoption-clang--std"></span><tt class="descname">-std</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--std</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--std</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-std" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Language standard to compile for</p>
+<div class="section" id="preprocessor-flags">
+<h3><a class="toc-backref" href="#id4">Preprocessor flags</a><a class="headerlink" href="#preprocessor-flags" title="Permalink to this headline">Â¶</a></h3>
+<p>Flags controlling the behavior of the Clang preprocessor.</p>
+<dl class="option">
+<dt id="cmdoption-clang-C">
+<span id="cmdoption-clang--comments"></span><tt class="descname">-C</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--comments</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-C" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Include comments in preprocessed output</p>
+<dl class="option">
+<dt id="cmdoption-clang-CC">
+<span id="cmdoption-clang--comments-in-macros"></span><tt class="descname">-CC</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--comments-in-macros</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-CC" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Include comments from within macros in preprocessed output</p>
+<dl class="option">
+<dt id="cmdoption-clang-D">
+<span id="cmdoption-clang--define-macro"></span><span id="cmdoption-clang--define-macro"></span><tt class="descname">-D</tt><tt class="descclassname"><macro>=<value></tt><tt class="descclassname">, </tt><tt class="descname">--define-macro</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--define-macro</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-D" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Define <macro> to <value> (or 1 if <value> omitted)</p>
+<dl class="option">
+<dt id="cmdoption-clang-H">
+<span id="cmdoption-clang--trace-includes"></span><tt class="descname">-H</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--trace-includes</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-H" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Show header includes and nesting depth</p>
+<dl class="option">
+<dt id="cmdoption-clang-P">
+<span id="cmdoption-clang--no-line-commands"></span><tt class="descname">-P</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--no-line-commands</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-P" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Disable linemarker output in -E mode</p>
+<dl class="option">
+<dt id="cmdoption-clang-U">
+<span id="cmdoption-clang--undefine-macro"></span><span id="cmdoption-clang--undefine-macro"></span><tt class="descname">-U</tt><tt class="descclassname"><macro></tt><tt class="descclassname">, </tt><tt class="descname">--undefine-macro</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--undefine-macro</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-U" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Undefine macro <macro></p>
+<dl class="option">
+<dt id="cmdoption-clang-Wp">
+<tt class="descname">-Wp</tt><tt class="descclassname">,<arg>,<arg2>...</tt><a class="headerlink" href="#cmdoption-clang-Wp" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Pass the comma separated arguments in <arg> to the preprocessor</p>
+<dl class="option">
+<dt id="cmdoption-clang-Xpreprocessor">
+<tt class="descname">-Xpreprocessor</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-Xpreprocessor" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Pass <arg> to the preprocessor</p>
+<div class="section" id="include-path-management">
+<h4><a class="toc-backref" href="#id5">Include path management</a><a class="headerlink" href="#include-path-management" title="Permalink to this headline">Â¶</a></h4>
+<p>Flags controlling how <tt class="docutils literal"><span class="pre">#include</span></tt>s are resolved to files.</p>
+<dl class="option">
+<dt id="cmdoption-clang-I">
+<span id="cmdoption-clang--include-directory"></span><span id="cmdoption-clang--include-directory"></span><tt class="descname">-I</tt><tt class="descclassname"><dir></tt><tt class="descclassname">, </tt><tt class="descname">--include-directory</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--include-directory</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-I" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Add directory to include search path</p>
+<dl class="option">
+<dt id="cmdoption-clang-I-">
+<span id="cmdoption-clang--include-barrier"></span><tt class="descname">-I-</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--include-barrier</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-I-" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Restrict all prior -I flags to double-quoted inclusion and remove current directory from include path</p>
+<dl class="option">
+<dt id="cmdoption-clang--cuda-path">
+<tt class="descname">--cuda-path</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang--cuda-path" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>CUDA installation path</p>
+<dl class="option">
+<dt id="cmdoption-clang-cxx-isystem">
+<tt class="descname">-cxx-isystem</tt><tt class="descclassname"><directory></tt><a class="headerlink" href="#cmdoption-clang-cxx-isystem" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Add directory to the C++ SYSTEM include search path</p>
+<dl class="option">
+<dt id="cmdoption-clang-fbuild-session-file">
+<tt class="descname">-fbuild-session-file</tt><tt class="descclassname">=<file></tt><a class="headerlink" href="#cmdoption-clang-fbuild-session-file" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Use the last modification time of <file> as the build session timestamp</p>
+<dl class="option">
+<dt id="cmdoption-clang-fbuild-session-timestamp">
+<tt class="descname">-fbuild-session-timestamp</tt><tt class="descclassname">=<time since Epoch in seconds></tt><a class="headerlink" href="#cmdoption-clang-fbuild-session-timestamp" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Time when the current build session started</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodules-cache-path">
+<tt class="descname">-fmodules-cache-path</tt><tt class="descclassname">=<directory></tt><a class="headerlink" href="#cmdoption-clang-fmodules-cache-path" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify the module cache path</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodules-disable-diagnostic-validation">
+<tt class="descname">-fmodules-disable-diagnostic-validation</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmodules-disable-diagnostic-validation" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Disable validation of the diagnostic options when loading the module</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodules-prune-after">
+<tt class="descname">-fmodules-prune-after</tt><tt class="descclassname">=<seconds></tt><a class="headerlink" href="#cmdoption-clang-fmodules-prune-after" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify the interval (in seconds) after which a module file will be considered unused</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodules-prune-interval">
+<tt class="descname">-fmodules-prune-interval</tt><tt class="descclassname">=<seconds></tt><a class="headerlink" href="#cmdoption-clang-fmodules-prune-interval" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify the interval (in seconds) between attempts to prune the module cache</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodules-user-build-path">
+<tt class="descname">-fmodules-user-build-path</tt><tt class="descclassname"> <directory></tt><a class="headerlink" href="#cmdoption-clang-fmodules-user-build-path" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify the module user build path</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodules-validate-once-per-build-session">
+<tt class="descname">-fmodules-validate-once-per-build-session</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmodules-validate-once-per-build-session" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Don’t verify input files for the modules if the module has been successfully validated or loaded during this build session</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodules-validate-system-headers">
+<tt class="descname">-fmodules-validate-system-headers</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmodules-validate-system-headers" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Validate the system headers that a module depends on when loading the module</p>
+<dl class="option">
+<dt id="cmdoption-clang-fprebuilt-module-path">
+<tt class="descname">-fprebuilt-module-path</tt><tt class="descclassname">=<directory></tt><a class="headerlink" href="#cmdoption-clang-fprebuilt-module-path" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify the prebuilt module path</p>
+<dl class="option">
+<dt id="cmdoption-clang-i">
+<tt class="descname">-i</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-i" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-idirafter">
+<span id="cmdoption-clang--include-directory-after"></span><span id="cmdoption-clang--include-directory-after"></span><tt class="descname">-idirafter</tt><tt class="descclassname"><arg></tt><tt class="descclassname">, </tt><tt class="descname">--include-directory-after</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--include-directory-after</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-idirafter" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Add directory to AFTER include search path</p>
+<dl class="option">
+<dt id="cmdoption-clang-iframework">
+<tt class="descname">-iframework</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-iframework" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Add directory to SYSTEM framework search path</p>
+<dl class="option">
+<dt id="cmdoption-clang-iframeworkwithsysroot">
+<tt class="descname">-iframeworkwithsysroot</tt><tt class="descclassname"><directory></tt><a class="headerlink" href="#cmdoption-clang-iframeworkwithsysroot" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Add directory to SYSTEM framework search path, absolute paths are relative to -isysroot</p>
+<dl class="option">
+<dt id="cmdoption-clang-imacros">
+<span id="cmdoption-clang--imacros"></span><span id="cmdoption-clang--imacros"></span><tt class="descname">-imacros</tt><tt class="descclassname"><file></tt><tt class="descclassname">, </tt><tt class="descname">--imacros</tt><tt class="descclassname"><file></tt><tt class="descclassname">, </tt><tt class="descname">--imacros</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-imacros" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Include macros from file before parsing</p>
+<dl class="option">
+<dt id="cmdoption-clang-include">
+<span id="cmdoption-clang--include"></span><span id="cmdoption-clang--include"></span><tt class="descname">-include</tt><tt class="descclassname"><file></tt><tt class="descclassname">, </tt><tt class="descname">--include</tt><tt class="descclassname"><file></tt><tt class="descclassname">, </tt><tt class="descname">--include</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-include" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Include file before parsing</p>
+<dl class="option">
+<dt id="cmdoption-clang-include-pch">
+<tt class="descname">-include-pch</tt><tt class="descclassname"> <file></tt><a class="headerlink" href="#cmdoption-clang-include-pch" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Include precompiled header file</p>
+<dl class="option">
+<dt id="cmdoption-clang-iprefix">
+<span id="cmdoption-clang--include-prefix"></span><span id="cmdoption-clang--include-prefix"></span><tt class="descname">-iprefix</tt><tt class="descclassname"><dir></tt><tt class="descclassname">, </tt><tt class="descname">--include-prefix</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--include-prefix</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-iprefix" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Set the -iwithprefix/-iwithprefixbefore prefix</p>
+<dl class="option">
+<dt id="cmdoption-clang-iquote">
+<tt class="descname">-iquote</tt><tt class="descclassname"><directory></tt><a class="headerlink" href="#cmdoption-clang-iquote" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Add directory to QUOTE include search path</p>
+<dl class="option">
+<dt id="cmdoption-clang-isysroot">
+<tt class="descname">-isysroot</tt><tt class="descclassname"><dir></tt><a class="headerlink" href="#cmdoption-clang-isysroot" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Set the system root directory (usually /)</p>
+<dl class="option">
+<dt id="cmdoption-clang-isystem">
+<tt class="descname">-isystem</tt><tt class="descclassname"><directory></tt><a class="headerlink" href="#cmdoption-clang-isystem" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Add directory to SYSTEM include search path</p>
+<dl class="option">
+<dt id="cmdoption-clang-isystem-after">
+<tt class="descname">-isystem-after</tt><tt class="descclassname"><directory></tt><a class="headerlink" href="#cmdoption-clang-isystem-after" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Add directory to end of the SYSTEM include search path</p>
+<dl class="option">
+<dt id="cmdoption-clang-ivfsoverlay">
+<tt class="descname">-ivfsoverlay</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-ivfsoverlay" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Overlay the virtual filesystem described by file over the real file system</p>
+<dl class="option">
+<dt id="cmdoption-clang-iwithprefix">
+<span id="cmdoption-clang--include-with-prefix"></span><span id="cmdoption-clang--include-with-prefix-after"></span><span id="cmdoption-clang--include-with-prefix-after"></span><span id="cmdoption-clang--include-with-prefix"></span><tt class="descname">-iwithprefix</tt><tt class="descclassname"><dir></tt><tt class="descclassname">, </tt><tt class="descname">--include-with-prefix</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--include-with-prefix-after</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--include-with-prefix-after</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--include-with-prefix</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-iwithprefix" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Set directory to SYSTEM include search path with prefix</p>
+<dl class="option">
+<dt id="cmdoption-clang-iwithprefixbefore">
+<span id="cmdoption-clang--include-with-prefix-before"></span><span id="cmdoption-clang--include-with-prefix-before"></span><tt class="descname">-iwithprefixbefore</tt><tt class="descclassname"><dir></tt><tt class="descclassname">, </tt><tt class="descname">--include-with-prefix-before</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--include-with-prefix-before</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-iwithprefixbefore" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Set directory to include search path with prefix</p>
+<dl class="option">
+<dt id="cmdoption-clang-iwithsysroot">
+<tt class="descname">-iwithsysroot</tt><tt class="descclassname"><directory></tt><a class="headerlink" href="#cmdoption-clang-iwithsysroot" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Add directory to SYSTEM include search path, absolute paths are relative to -isysroot</p>
+<dl class="option">
+<dt id="cmdoption-clang--ptxas-path">
+<tt class="descname">--ptxas-path</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang--ptxas-path" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Path to ptxas (used for compiling CUDA code)</p>
+<dl class="option">
+<dt id="cmdoption-clang--system-header-prefix">
+<span id="cmdoption-clang--no-system-header-prefix"></span><span id="cmdoption-clang--system-header-prefix"></span><tt class="descname">--system-header-prefix</tt><tt class="descclassname">=<prefix></tt><tt class="descclassname">, </tt><tt class="descname">--no-system-header-prefix</tt><tt class="descclassname">=<prefix></tt><tt class="descclassname">, </tt><tt class="descname">--system-header-prefix</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang--system-header-prefix" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Treat all #include paths starting with <prefix> as including a system header.</p>
+</div>
+<div class="section" id="dependency-file-generation">
+<h4><a class="toc-backref" href="#id6">Dependency file generation</a><a class="headerlink" href="#dependency-file-generation" title="Permalink to this headline">Â¶</a></h4>
+<p>Flags controlling generation of a dependency file for <tt class="docutils literal"><span class="pre">make</span></tt>-like build
+systems.</p>
+<dl class="option">
+<dt id="cmdoption-clang-M">
+<span id="cmdoption-clang--dependencies"></span><tt class="descname">-M</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--dependencies</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-M" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Like -MD, but also implies -E and writes to stdout by default</p>
+<dl class="option">
+<dt id="cmdoption-clang-MD">
+<span id="cmdoption-clang--write-dependencies"></span><tt class="descname">-MD</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--write-dependencies</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-MD" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Write a depfile containing user and system headers</p>
+<dl class="option">
+<dt id="cmdoption-clang-MF">
+<tt class="descname">-MF</tt><tt class="descclassname"><file></tt><a class="headerlink" href="#cmdoption-clang-MF" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Write depfile output from -MMD, -MD, -MM, or -M to <file></p>
+<dl class="option">
+<dt id="cmdoption-clang-MG">
+<span id="cmdoption-clang--print-missing-file-dependencies"></span><tt class="descname">-MG</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--print-missing-file-dependencies</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-MG" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Add missing headers to depfile</p>
+<dl class="option">
+<dt id="cmdoption-clang-MJ">
+<tt class="descname">-MJ</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-MJ" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Write a compilation database entry per input</p>
+<dl class="option">
+<dt id="cmdoption-clang-MM">
+<span id="cmdoption-clang--user-dependencies"></span><tt class="descname">-MM</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--user-dependencies</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-MM" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Like -MMD, but also implies -E and writes to stdout by default</p>
+<dl class="option">
+<dt id="cmdoption-clang-MMD">
+<span id="cmdoption-clang--write-user-dependencies"></span><tt class="descname">-MMD</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--write-user-dependencies</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-MMD" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Write a depfile containing user headers</p>
+<dl class="option">
+<dt id="cmdoption-clang-MP">
+<tt class="descname">-MP</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-MP" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Create phony target for each dependency (other than main file)</p>
+<dl class="option">
+<dt id="cmdoption-clang-MQ">
+<tt class="descname">-MQ</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-MQ" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify name of main file output to quote in depfile</p>
+<dl class="option">
+<dt id="cmdoption-clang-MT">
+<tt class="descname">-MT</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-MT" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify name of main file output in depfile</p>
+<dl class="option">
+<dt id="cmdoption-clang-MV">
+<tt class="descname">-MV</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-MV" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Use NMake/Jom format for the depfile</p>
+</div>
+<div class="section" id="dumping-preprocessor-state">
+<h4><a class="toc-backref" href="#id7">Dumping preprocessor state</a><a class="headerlink" href="#dumping-preprocessor-state" title="Permalink to this headline">Â¶</a></h4>
+<p>Flags allowing the state of the preprocessor to be dumped in various ways.</p>
+<dl class="option">
+<dt id="cmdoption-clang-d">
+<tt class="descname">-d</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-d" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-d">
+<tt class="descname">-d</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang1-d" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-dA">
+<tt class="descname">-dA</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-dA" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-dD">
+<tt class="descname">-dD</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-dD" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Print macro definitions in -E mode in addition to normal output</p>
+<dl class="option">
+<dt id="cmdoption-clang-dI">
+<tt class="descname">-dI</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-dI" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Print include directives in -E mode in addition to normal output</p>
+<dl class="option">
+<dt id="cmdoption-clang-dM">
+<tt class="descname">-dM</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-dM" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Print macro definitions in -E mode instead of normal output</p>
+</div>
+</div>
+<div class="section" id="diagnostic-flags">
+<h3><a class="toc-backref" href="#id8">Diagnostic flags</a><a class="headerlink" href="#diagnostic-flags" title="Permalink to this headline">Â¶</a></h3>
+<p>Flags controlling which warnings, errors, and remarks Clang will generate.
+See the <a class="reference internal" href="DiagnosticsReference.html"><em>full list of warning and remark flags</em></a>.</p>
+<dl class="option">
+<dt id="cmdoption-clang-R">
+<tt class="descname">-R</tt><tt class="descclassname"><remark></tt><a class="headerlink" href="#cmdoption-clang-R" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable the specified remark</p>
+<dl class="option">
+<dt id="cmdoption-clang-Rpass-analysis">
+<tt class="descname">-Rpass-analysis</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-Rpass-analysis" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Report transformation analysis from optimization passes whose name matches the given POSIX regular expression</p>
+<dl class="option">
+<dt id="cmdoption-clang-Rpass-missed">
+<tt class="descname">-Rpass-missed</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-Rpass-missed" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Report missed transformations by optimization passes whose name matches the given POSIX regular expression</p>
+<dl class="option">
+<dt id="cmdoption-clang-Rpass">
+<tt class="descname">-Rpass</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-Rpass" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Report transformations performed by optimization passes whose name matches the given POSIX regular expression</p>
+<dl class="option">
+<dt id="cmdoption-clang-W">
+<span id="cmdoption-clang--extra-warnings"></span><span id="cmdoption-clang--warn-"></span><span id="cmdoption-clang--warn-"></span><tt class="descname">-W</tt><tt class="descclassname"><warning></tt><tt class="descclassname">, </tt><tt class="descname">--extra-warnings</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--warn-</tt><tt class="descclassname"><arg></tt><tt class="descclassname">, </tt><tt class="descname">--warn-</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-W" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable the specified warning</p>
+<dl class="option">
+<dt id="cmdoption-clang-Wdeprecated">
+<span id="cmdoption-clang-Wno-deprecated"></span><tt class="descname">-Wdeprecated</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-Wno-deprecated</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-Wdeprecated" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable warnings for deprecated constructs and define __DEPRECATED</p>
+<dl class="option">
+<dt id="cmdoption-clang-Wnonportable-cfstrings">
+<span id="cmdoption-clang-Wno-nonportable-cfstrings"></span><tt class="descname">-Wnonportable-cfstrings</tt><tt class="descclassname"><arg></tt><tt class="descclassname">, </tt><tt class="descname">-Wno-nonportable-cfstrings</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-Wnonportable-cfstrings" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+</div>
+<div class="section" id="target-independent-compilation-options">
+<h3><a class="toc-backref" href="#id9">Target-independent compilation options</a><a class="headerlink" href="#target-independent-compilation-options" title="Permalink to this headline">Â¶</a></h3>
+<dl class="option">
+<dt id="cmdoption-clang-Wframe-larger-than">
+<tt class="descname">-Wframe-larger-than</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-Wframe-larger-than" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fPIC">
+<span id="cmdoption-clang-fno-PIC"></span><tt class="descname">-fPIC</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-PIC</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fPIC" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fPIE">
+<span id="cmdoption-clang-fno-PIE"></span><tt class="descname">-fPIE</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-PIE</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fPIE" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-faccess-control">
+<span id="cmdoption-clang-fno-access-control"></span><tt class="descname">-faccess-control</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-access-control</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-faccess-control" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-faligned-allocation">
+<span id="cmdoption-clang1-faligned-new"></span><span id="cmdoption-clang1-fno-aligned-allocation"></span><tt class="descname">-faligned-allocation</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-faligned-new</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-aligned-allocation</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang1-faligned-allocation" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable C++17 aligned allocation functions</p>
+<dl class="option">
+<dt id="cmdoption-clang-fallow-editor-placeholders">
+<span id="cmdoption-clang-fno-allow-editor-placeholders"></span><tt class="descname">-fallow-editor-placeholders</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-allow-editor-placeholders</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fallow-editor-placeholders" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Treat editor placeholders as valid source code</p>
+<dl class="option">
+<dt id="cmdoption-clang-fallow-unsupported">
+<tt class="descname">-fallow-unsupported</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fallow-unsupported" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-faltivec">
+<span id="cmdoption-clang-fno-altivec"></span><tt class="descname">-faltivec</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-altivec</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-faltivec" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fansi-escape-codes">
+<tt class="descname">-fansi-escape-codes</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fansi-escape-codes" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Use ANSI escape codes for diagnostics</p>
+<dl class="option">
+<dt id="cmdoption-clang-fapple-kext">
+<span id="cmdoption-clang-findirect-virtual-calls"></span><span id="cmdoption-clang-fterminated-vtables"></span><tt class="descname">-fapple-kext</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-findirect-virtual-calls</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fterminated-vtables</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fapple-kext" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Use Apple’s kernel extensions ABI</p>
+<dl class="option">
+<dt id="cmdoption-clang-fapple-pragma-pack">
+<span id="cmdoption-clang-fno-apple-pragma-pack"></span><tt class="descname">-fapple-pragma-pack</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-apple-pragma-pack</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fapple-pragma-pack" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable Apple gcc-compatible #pragma pack handling</p>
+<dl class="option">
+<dt id="cmdoption-clang-fapplication-extension">
+<span id="cmdoption-clang-fno-application-extension"></span><tt class="descname">-fapplication-extension</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-application-extension</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fapplication-extension" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Restrict code to those available for App Extensions</p>
+<dl class="option">
+<dt id="cmdoption-clang-fasm">
+<span id="cmdoption-clang-fno-asm"></span><tt class="descname">-fasm</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-asm</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fasm" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fasm-blocks">
+<span id="cmdoption-clang-fno-asm-blocks"></span><tt class="descname">-fasm-blocks</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-asm-blocks</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fasm-blocks" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fassociative-math">
+<span id="cmdoption-clang-fno-associative-math"></span><tt class="descname">-fassociative-math</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-associative-math</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fassociative-math" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fassume-sane-operator-new">
+<span id="cmdoption-clang-fno-assume-sane-operator-new"></span><tt class="descname">-fassume-sane-operator-new</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-assume-sane-operator-new</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fassume-sane-operator-new" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fast">
+<tt class="descname">-fast</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fast" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fastcp">
+<tt class="descname">-fastcp</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fastcp" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fastf">
+<tt class="descname">-fastf</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fastf" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fasynchronous-unwind-tables">
+<span id="cmdoption-clang-fno-asynchronous-unwind-tables"></span><tt class="descname">-fasynchronous-unwind-tables</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-asynchronous-unwind-tables</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fasynchronous-unwind-tables" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fautolink">
+<span id="cmdoption-clang-fno-autolink"></span><tt class="descname">-fautolink</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-autolink</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fautolink" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fblocks">
+<span id="cmdoption-clang-fno-blocks"></span><tt class="descname">-fblocks</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-blocks</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fblocks" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable the ‘blocks’ language feature</p>
+<dl class="option">
+<dt id="cmdoption-clang-fbootclasspath">
+<span id="cmdoption-clang--bootclasspath"></span><span id="cmdoption-clang--bootclasspath"></span><tt class="descname">-fbootclasspath</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--bootclasspath</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--bootclasspath</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fbootclasspath" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fborland-extensions">
+<span id="cmdoption-clang-fno-borland-extensions"></span><tt class="descname">-fborland-extensions</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-borland-extensions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fborland-extensions" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Accept non-standard constructs supported by the Borland compiler</p>
+<dl class="option">
+<dt id="cmdoption-clang-fbracket-depth">
+<tt class="descname">-fbracket-depth</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fbracket-depth" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fbuiltin">
+<span id="cmdoption-clang-fno-builtin"></span><tt class="descname">-fbuiltin</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-builtin</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fbuiltin" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fbuiltin-module-map">
+<tt class="descname">-fbuiltin-module-map</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fbuiltin-module-map" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Load the clang builtins module map file.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fcaret-diagnostics">
+<span id="cmdoption-clang-fno-caret-diagnostics"></span><tt class="descname">-fcaret-diagnostics</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-caret-diagnostics</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fcaret-diagnostics" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fclasspath">
+<span id="cmdoption-clang--CLASSPATH"></span><span id="cmdoption-clang--CLASSPATH"></span><span id="cmdoption-clang--classpath"></span><span id="cmdoption-clang--classpath"></span><tt class="descname">-fclasspath</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--CLASSPATH</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--CLASSPATH</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--classpath</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--classpath</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fclasspath" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fcolor-diagnostics">
+<span id="cmdoption-clang-fno-color-diagnostics"></span><tt class="descname">-fcolor-diagnostics</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-color-diagnostics</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fcolor-diagnostics" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Use colors in diagnostics</p>
+<dl class="option">
+<dt id="cmdoption-clang-fcommon">
+<span id="cmdoption-clang-fno-common"></span><tt class="descname">-fcommon</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-common</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fcommon" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fcompile-resource">
+<span id="cmdoption-clang--resource"></span><span id="cmdoption-clang--resource"></span><tt class="descname">-fcompile-resource</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--resource</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--resource</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fcompile-resource" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fconstant-cfstrings">
+<span id="cmdoption-clang-fno-constant-cfstrings"></span><tt class="descname">-fconstant-cfstrings</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-constant-cfstrings</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fconstant-cfstrings" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fconstant-string-class">
+<tt class="descname">-fconstant-string-class</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fconstant-string-class" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fconstexpr-backtrace-limit">
+<tt class="descname">-fconstexpr-backtrace-limit</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fconstexpr-backtrace-limit" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fconstexpr-depth">
+<tt class="descname">-fconstexpr-depth</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fconstexpr-depth" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fconstexpr-steps">
+<tt class="descname">-fconstexpr-steps</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fconstexpr-steps" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fcoroutines-ts">
+<span id="cmdoption-clang-fno-coroutines-ts"></span><tt class="descname">-fcoroutines-ts</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-coroutines-ts</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fcoroutines-ts" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable support for the C++ Coroutines TS</p>
+<dl class="option">
+<dt id="cmdoption-clang-fcoverage-mapping">
+<span id="cmdoption-clang-fno-coverage-mapping"></span><tt class="descname">-fcoverage-mapping</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-coverage-mapping</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fcoverage-mapping" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate coverage mapping to enable code coverage analysis</p>
+<dl class="option">
+<dt id="cmdoption-clang-fcreate-profile">
+<tt class="descname">-fcreate-profile</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fcreate-profile" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fcxx-exceptions">
+<span id="cmdoption-clang-fno-cxx-exceptions"></span><tt class="descname">-fcxx-exceptions</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-cxx-exceptions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fcxx-exceptions" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable C++ exceptions</p>
+<dl class="option">
+<dt id="cmdoption-clang-fcxx-modules">
+<span id="cmdoption-clang-fno-cxx-modules"></span><tt class="descname">-fcxx-modules</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-cxx-modules</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fcxx-modules" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdata-sections">
+<span id="cmdoption-clang-fno-data-sections"></span><tt class="descname">-fdata-sections</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-data-sections</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdata-sections" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Place each data in its own section (ELF Only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdebug-info-for-profiling">
+<span id="cmdoption-clang-fno-debug-info-for-profiling"></span><tt class="descname">-fdebug-info-for-profiling</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-debug-info-for-profiling</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdebug-info-for-profiling" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Emit extra debug info to make sample profile more accurate.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdebug-macro">
+<span id="cmdoption-clang-fno-debug-macro"></span><tt class="descname">-fdebug-macro</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-debug-macro</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdebug-macro" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Emit macro debug information</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdebug-pass-arguments">
+<tt class="descname">-fdebug-pass-arguments</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdebug-pass-arguments" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdebug-pass-structure">
+<tt class="descname">-fdebug-pass-structure</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdebug-pass-structure" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdebug-prefix-map">
+<tt class="descname">-fdebug-prefix-map</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fdebug-prefix-map" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>remap file source paths in debug info</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdebug-types-section">
+<span id="cmdoption-clang-fno-debug-types-section"></span><tt class="descname">-fdebug-types-section</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-debug-types-section</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdebug-types-section" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Place debug types in their own section (ELF Only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdelayed-template-parsing">
+<span id="cmdoption-clang-fno-delayed-template-parsing"></span><tt class="descname">-fdelayed-template-parsing</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-delayed-template-parsing</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdelayed-template-parsing" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Parse templated function definitions at the end of the translation unit</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdenormal-fp-math">
+<tt class="descname">-fdenormal-fp-math</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fdenormal-fp-math" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdiagnostics-absolute-paths">
+<tt class="descname">-fdiagnostics-absolute-paths</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdiagnostics-absolute-paths" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Print absolute paths in diagnostics</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdiagnostics-color">
+<span id="cmdoption-clang-fno-diagnostics-color"></span><tt class="descname">-fdiagnostics-color</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-diagnostics-color</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdiagnostics-color" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-fdiagnostics-color">
+<tt class="descname">-fdiagnostics-color</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang1-fdiagnostics-color" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdiagnostics-hotness-threshold">
+<tt class="descname">-fdiagnostics-hotness-threshold</tt><tt class="descclassname">=<number></tt><a class="headerlink" href="#cmdoption-clang-fdiagnostics-hotness-threshold" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Prevent optimization remarks from being output if they do not have at least this profile count</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdiagnostics-show-hotness">
+<span id="cmdoption-clang-fno-diagnostics-show-hotness"></span><tt class="descname">-fdiagnostics-show-hotness</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-diagnostics-show-hotness</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdiagnostics-show-hotness" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable profile hotness information in diagnostic line</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdiagnostics-show-note-include-stack">
+<span id="cmdoption-clang-fno-diagnostics-show-note-include-stack"></span><tt class="descname">-fdiagnostics-show-note-include-stack</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-diagnostics-show-note-include-stack</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdiagnostics-show-note-include-stack" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Display include stacks for diagnostic notes</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdiagnostics-show-option">
+<span id="cmdoption-clang-fno-diagnostics-show-option"></span><tt class="descname">-fdiagnostics-show-option</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-diagnostics-show-option</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdiagnostics-show-option" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Print option name with mappable diagnostics</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdiagnostics-show-template-tree">
+<tt class="descname">-fdiagnostics-show-template-tree</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdiagnostics-show-template-tree" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Print a template comparison tree for differing templates</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdollars-in-identifiers">
+<span id="cmdoption-clang-fno-dollars-in-identifiers"></span><tt class="descname">-fdollars-in-identifiers</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-dollars-in-identifiers</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdollars-in-identifiers" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Allow ‘$’ in identifiers</p>
+<dl class="option">
+<dt id="cmdoption-clang-fdwarf-directory-asm">
+<span id="cmdoption-clang-fno-dwarf-directory-asm"></span><tt class="descname">-fdwarf-directory-asm</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-dwarf-directory-asm</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdwarf-directory-asm" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-felide-constructors">
+<span id="cmdoption-clang-fno-elide-constructors"></span><tt class="descname">-felide-constructors</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-elide-constructors</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-felide-constructors" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-feliminate-unused-debug-symbols">
+<span id="cmdoption-clang-fno-eliminate-unused-debug-symbols"></span><tt class="descname">-feliminate-unused-debug-symbols</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-eliminate-unused-debug-symbols</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-feliminate-unused-debug-symbols" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fembed-bitcode">
+<span id="cmdoption-clang-fembed-bitcode"></span><span id="cmdoption-clang-fembed-bitcode-marker"></span><tt class="descname">-fembed-bitcode</tt><tt class="descclassname">=<option></tt><tt class="descclassname">, </tt><tt class="descname">-fembed-bitcode</tt><tt class="descclassname"> (equivalent to -fembed-bitcode=all)</tt><tt class="descclassname">, </tt><tt class="descname">-fembed-bitcode-marker</tt><tt class="descclassname"> (equivalent to -fembed-bitcode=marker)</tt><a class="headerlink" href="#cmdoption-clang-fembed-bitcode" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Embed LLVM bitcode (option: off, all, bitcode, marker)</p>
+<dl class="option">
+<dt id="cmdoption-clang-femit-all-decls">
+<tt class="descname">-femit-all-decls</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-femit-all-decls" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Emit all declarations, even if unused</p>
+<dl class="option">
+<dt id="cmdoption-clang-femulated-tls">
+<span id="cmdoption-clang-fno-emulated-tls"></span><tt class="descname">-femulated-tls</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-emulated-tls</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-femulated-tls" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Use emutls functions to access thread_local variables</p>
+<dl class="option">
+<dt id="cmdoption-clang-fencoding">
+<span id="cmdoption-clang--encoding"></span><span id="cmdoption-clang--encoding"></span><tt class="descname">-fencoding</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--encoding</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--encoding</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fencoding" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ferror-limit">
+<tt class="descname">-ferror-limit</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-ferror-limit" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fexceptions">
+<span id="cmdoption-clang-fno-exceptions"></span><tt class="descname">-fexceptions</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-exceptions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fexceptions" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable support for exception handling</p>
+<dl class="option">
+<dt id="cmdoption-clang-fexec-charset">
+<tt class="descname">-fexec-charset</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fexec-charset" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fextdirs">
+<span id="cmdoption-clang--extdirs"></span><span id="cmdoption-clang--extdirs"></span><tt class="descname">-fextdirs</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--extdirs</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--extdirs</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fextdirs" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ffast-math">
+<span id="cmdoption-clang-fno-fast-math"></span><tt class="descname">-ffast-math</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-fast-math</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ffast-math" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Allow aggressive, lossy floating-point optimizations</p>
+<dl class="option">
+<dt id="cmdoption-clang-ffinite-math-only">
+<span id="cmdoption-clang-fno-finite-math-only"></span><tt class="descname">-ffinite-math-only</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-finite-math-only</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ffinite-math-only" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ffor-scope">
+<span id="cmdoption-clang-fno-for-scope"></span><tt class="descname">-ffor-scope</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-for-scope</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ffor-scope" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ffp-contract">
+<tt class="descname">-ffp-contract</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-ffp-contract" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Form fused FP ops (e.g. FMAs): fast (everywhere) | on (according to FP_CONTRACT pragma, default) | off (never fuse)</p>
+<dl class="option">
+<dt id="cmdoption-clang-ffreestanding">
+<tt class="descname">-ffreestanding</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ffreestanding" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Assert that the compilation takes place in a freestanding environment</p>
+<dl class="option">
+<dt id="cmdoption-clang-ffunction-sections">
+<span id="cmdoption-clang-fno-function-sections"></span><tt class="descname">-ffunction-sections</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-function-sections</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ffunction-sections" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Place each function in its own section (ELF Only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-fgnu-inline-asm">
+<span id="cmdoption-clang-fno-gnu-inline-asm"></span><tt class="descname">-fgnu-inline-asm</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-gnu-inline-asm</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fgnu-inline-asm" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fgnu-keywords">
+<span id="cmdoption-clang-fno-gnu-keywords"></span><tt class="descname">-fgnu-keywords</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-gnu-keywords</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fgnu-keywords" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Allow GNU-extension keywords regardless of language standard</p>
+<dl class="option">
+<dt id="cmdoption-clang-fgnu-runtime">
+<tt class="descname">-fgnu-runtime</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fgnu-runtime" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate output compatible with the standard GNU Objective-C runtime</p>
+<dl class="option">
+<dt id="cmdoption-clang-fgnu89-inline">
+<span id="cmdoption-clang-fno-gnu89-inline"></span><tt class="descname">-fgnu89-inline</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-gnu89-inline</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fgnu89-inline" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Use the gnu89 inline semantics</p>
+<dl class="option">
+<dt id="cmdoption-clang-fhonor-infinities">
+<span id="cmdoption-clang-fhonor-infinites"></span><span id="cmdoption-clang-fno-honor-infinities"></span><tt class="descname">-fhonor-infinities</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fhonor-infinites</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-honor-infinities</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fhonor-infinities" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fhonor-nans">
+<span id="cmdoption-clang-fno-honor-nans"></span><tt class="descname">-fhonor-nans</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-honor-nans</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fhonor-nans" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fhosted">
+<tt class="descname">-fhosted</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fhosted" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fimplicit-module-maps">
+<span id="cmdoption-clang-fmodule-maps"></span><span id="cmdoption-clang-fno-implicit-module-maps"></span><tt class="descname">-fimplicit-module-maps</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fmodule-maps</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-implicit-module-maps</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fimplicit-module-maps" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Implicitly search the file system for module map files.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fimplicit-modules">
+<span id="cmdoption-clang-fno-implicit-modules"></span><tt class="descname">-fimplicit-modules</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-implicit-modules</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fimplicit-modules" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-finput-charset">
+<tt class="descname">-finput-charset</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-finput-charset" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-finstrument-functions">
+<tt class="descname">-finstrument-functions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-finstrument-functions" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate calls to instrument function entry and exit</p>
+<dl class="option">
+<dt id="cmdoption-clang-fintegrated-as">
+<span id="cmdoption-clang-fno-integrated-as"></span><span id="cmdoption-clang-integrated-as"></span><tt class="descname">-fintegrated-as</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-integrated-as</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-integrated-as</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fintegrated-as" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable the integrated assembler</p>
+<dl class="option">
+<dt id="cmdoption-clang-fjump-tables">
+<span id="cmdoption-clang-fno-jump-tables"></span><tt class="descname">-fjump-tables</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-jump-tables</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fjump-tables" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-flax-vector-conversions">
+<span id="cmdoption-clang-fno-lax-vector-conversions"></span><tt class="descname">-flax-vector-conversions</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-lax-vector-conversions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-flax-vector-conversions" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-flimited-precision">
+<tt class="descname">-flimited-precision</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-flimited-precision" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-flto">
+<span id="cmdoption-clang-fno-lto"></span><tt class="descname">-flto</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-lto</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-flto" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable LTO in ‘full’ mode</p>
+<dl class="option">
+<dt id="cmdoption-clang-flto-jobs">
+<tt class="descname">-flto-jobs</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-flto-jobs" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Controls the backend parallelism of -flto=thin (default of 0 means the number of threads will be derived from the number of CPUs detected)</p>
+<dl class="option">
+<dt id="cmdoption-clang1-flto">
+<tt class="descname">-flto</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang1-flto" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Set LTO mode to either ‘full’ or ‘thin’</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmacro-backtrace-limit">
+<tt class="descname">-fmacro-backtrace-limit</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fmacro-backtrace-limit" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fmath-errno">
+<span id="cmdoption-clang-fno-math-errno"></span><tt class="descname">-fmath-errno</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-math-errno</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmath-errno" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Require math functions to indicate errors by setting errno</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmax-type-align">
+<tt class="descname">-fmax-type-align</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fmax-type-align" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify the maximum alignment to enforce on pointers lacking an explicit alignment</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmerge-all-constants">
+<span id="cmdoption-clang-fno-merge-all-constants"></span><tt class="descname">-fmerge-all-constants</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-merge-all-constants</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmerge-all-constants" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fmessage-length">
+<tt class="descname">-fmessage-length</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fmessage-length" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fmodule-file-deps">
+<span id="cmdoption-clang-fno-module-file-deps"></span><tt class="descname">-fmodule-file-deps</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-module-file-deps</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmodule-file-deps" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fmodule-file">
+<tt class="descname">-fmodule-file</tt><tt class="descclassname">=<file></tt><a class="headerlink" href="#cmdoption-clang-fmodule-file" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Load this precompiled module file</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodule-map-file">
+<tt class="descname">-fmodule-map-file</tt><tt class="descclassname">=<file></tt><a class="headerlink" href="#cmdoption-clang-fmodule-map-file" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Load this module map file</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodule-name">
+<span id="cmdoption-clang-fmodule-implementation-of"></span><span id="cmdoption-clang-fmodule-name"></span><tt class="descname">-fmodule-name</tt><tt class="descclassname">=<name></tt><tt class="descclassname">, </tt><tt class="descname">-fmodule-implementation-of</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">-fmodule-name</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-fmodule-name" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify the name of the module to build</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodules">
+<span id="cmdoption-clang-fno-modules"></span><tt class="descname">-fmodules</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-modules</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmodules" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable the ‘modules’ language feature</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodules-decluse">
+<span id="cmdoption-clang-fno-modules-decluse"></span><tt class="descname">-fmodules-decluse</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-modules-decluse</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmodules-decluse" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Require declaration of modules used within a module</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodules-ignore-macro">
+<tt class="descname">-fmodules-ignore-macro</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fmodules-ignore-macro" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Ignore the definition of the given macro when building and loading modules</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodules-search-all">
+<span id="cmdoption-clang-fno-modules-search-all"></span><tt class="descname">-fmodules-search-all</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-modules-search-all</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmodules-search-all" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Search even non-imported modules to resolve references</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodules-strict-decluse">
+<tt class="descname">-fmodules-strict-decluse</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmodules-strict-decluse" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Like -fmodules-decluse but requires all headers to be in modules</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmodules-ts">
+<tt class="descname">-fmodules-ts</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmodules-ts" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable support for the C++ Modules TS</p>
+<dl class="option">
+<dt id="cmdoption-clang-fms-compatibility">
+<span id="cmdoption-clang-fno-ms-compatibility"></span><tt class="descname">-fms-compatibility</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-ms-compatibility</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fms-compatibility" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable full Microsoft Visual C++ compatibility</p>
+<dl class="option">
+<dt id="cmdoption-clang-fms-compatibility-version">
+<tt class="descname">-fms-compatibility-version</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fms-compatibility-version" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Dot-separated value representing the Microsoft compiler version number to report in _MSC_VER (0 = don’t define it (default))</p>
+<dl class="option">
+<dt id="cmdoption-clang-fms-extensions">
+<span id="cmdoption-clang-fno-ms-extensions"></span><tt class="descname">-fms-extensions</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-ms-extensions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fms-extensions" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Accept some non-standard constructs supported by the Microsoft compiler</p>
+<dl class="option">
+<dt id="cmdoption-clang-fms-memptr-rep">
+<tt class="descname">-fms-memptr-rep</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fms-memptr-rep" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fms-volatile">
+<tt class="descname">-fms-volatile</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-fms-volatile" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fmsc-version">
+<tt class="descname">-fmsc-version</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fmsc-version" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Microsoft compiler version number to report in _MSC_VER (0 = don’t define it (default))</p>
+<dl class="option">
+<dt id="cmdoption-clang-fmudflap">
+<tt class="descname">-fmudflap</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmudflap" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fmudflapth">
+<tt class="descname">-fmudflapth</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmudflapth" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fnested-functions">
+<tt class="descname">-fnested-functions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fnested-functions" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fnew-alignment">
+<span id="cmdoption-clang-fnew-alignment"></span><tt class="descname">-fnew-alignment</tt><tt class="descclassname">=<align></tt><tt class="descclassname">, </tt><tt class="descname">-fnew-alignment</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-fnew-alignment" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Specifies the largest alignment guaranteed by ‘::operator new(size_t)’</p>
+<dl class="option">
+<dt id="cmdoption-clang-fnext-runtime">
+<tt class="descname">-fnext-runtime</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fnext-runtime" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fno-builtin-">
+<tt class="descname">-fno-builtin-</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-fno-builtin-" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Disable implicit builtin knowledge of a specific function</p>
+<dl class="option">
+<dt id="cmdoption-clang-fno-elide-type">
+<tt class="descname">-fno-elide-type</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fno-elide-type" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Do not elide types when printing diagnostics</p>
+<dl class="option">
+<dt id="cmdoption-clang-fno-max-type-align">
+<tt class="descname">-fno-max-type-align</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fno-max-type-align" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fno-operator-names">
+<tt class="descname">-fno-operator-names</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fno-operator-names" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Do not treat C++ operator name keywords as synonyms for operators</p>
+<dl class="option">
+<dt id="cmdoption-clang-fno-strict-modules-decluse">
+<tt class="descname">-fno-strict-modules-decluse</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fno-strict-modules-decluse" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fno-working-directory">
+<tt class="descname">-fno-working-directory</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fno-working-directory" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fnoopenmp-use-tls">
+<tt class="descname">-fnoopenmp-use-tls</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fnoopenmp-use-tls" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fobjc-abi-version">
+<tt class="descname">-fobjc-abi-version</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fobjc-abi-version" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fobjc-arc">
+<span id="cmdoption-clang-fno-objc-arc"></span><tt class="descname">-fobjc-arc</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-objc-arc</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fobjc-arc" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Synthesize retain and release calls for Objective-C pointers</p>
+<dl class="option">
+<dt id="cmdoption-clang-fobjc-arc-exceptions">
+<span id="cmdoption-clang-fno-objc-arc-exceptions"></span><tt class="descname">-fobjc-arc-exceptions</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-objc-arc-exceptions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fobjc-arc-exceptions" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Use EH-safe code when synthesizing retains and releases in -fobjc-arc</p>
+<dl class="option">
+<dt id="cmdoption-clang-fobjc-exceptions">
+<span id="cmdoption-clang-fno-objc-exceptions"></span><tt class="descname">-fobjc-exceptions</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-objc-exceptions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fobjc-exceptions" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable Objective-C exceptions</p>
+<dl class="option">
+<dt id="cmdoption-clang-fobjc-infer-related-result-type">
+<span id="cmdoption-clang-fno-objc-infer-related-result-type"></span><tt class="descname">-fobjc-infer-related-result-type</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-objc-infer-related-result-type</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fobjc-infer-related-result-type" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fobjc-legacy-dispatch">
+<span id="cmdoption-clang-fno-objc-legacy-dispatch"></span><tt class="descname">-fobjc-legacy-dispatch</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-objc-legacy-dispatch</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fobjc-legacy-dispatch" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fobjc-link-runtime">
+<tt class="descname">-fobjc-link-runtime</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fobjc-link-runtime" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fobjc-nonfragile-abi">
+<span id="cmdoption-clang-fno-objc-nonfragile-abi"></span><tt class="descname">-fobjc-nonfragile-abi</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-objc-nonfragile-abi</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fobjc-nonfragile-abi" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fobjc-nonfragile-abi-version">
+<tt class="descname">-fobjc-nonfragile-abi-version</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fobjc-nonfragile-abi-version" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fobjc-runtime">
+<tt class="descname">-fobjc-runtime</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fobjc-runtime" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify the target Objective-C runtime kind and version</p>
+<dl class="option">
+<dt id="cmdoption-clang-fobjc-sender-dependent-dispatch">
+<tt class="descname">-fobjc-sender-dependent-dispatch</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fobjc-sender-dependent-dispatch" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fobjc-weak">
+<span id="cmdoption-clang-fno-objc-weak"></span><tt class="descname">-fobjc-weak</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-objc-weak</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fobjc-weak" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable ARC-style weak references in Objective-C</p>
+<dl class="option">
+<dt id="cmdoption-clang-fomit-frame-pointer">
+<span id="cmdoption-clang-fno-omit-frame-pointer"></span><tt class="descname">-fomit-frame-pointer</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-omit-frame-pointer</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fomit-frame-pointer" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fopenmp">
+<span id="cmdoption-clang-fno-openmp"></span><tt class="descname">-fopenmp</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-openmp</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fopenmp" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fopenmp-dump-offload-linker-script">
+<tt class="descname">-fopenmp-dump-offload-linker-script</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fopenmp-dump-offload-linker-script" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fopenmp-use-tls">
+<tt class="descname">-fopenmp-use-tls</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fopenmp-use-tls" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fopenmp-version">
+<tt class="descname">-fopenmp-version</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fopenmp-version" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-fopenmp">
+<tt class="descname">-fopenmp</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang1-fopenmp" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-foperator-arrow-depth">
+<tt class="descname">-foperator-arrow-depth</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-foperator-arrow-depth" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-foptimization-record-file">
+<tt class="descname">-foptimization-record-file</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-foptimization-record-file" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify the file name of any generated YAML optimization record</p>
+<dl class="option">
+<dt id="cmdoption-clang-foptimize-sibling-calls">
+<span id="cmdoption-clang-fno-optimize-sibling-calls"></span><tt class="descname">-foptimize-sibling-calls</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-optimize-sibling-calls</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-foptimize-sibling-calls" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-foutput-class-dir">
+<span id="cmdoption-clang--output-class-directory"></span><span id="cmdoption-clang--output-class-directory"></span><tt class="descname">-foutput-class-dir</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--output-class-directory</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--output-class-directory</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-foutput-class-dir" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fpack-struct">
+<span id="cmdoption-clang-fno-pack-struct"></span><tt class="descname">-fpack-struct</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-pack-struct</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fpack-struct" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-fpack-struct">
+<tt class="descname">-fpack-struct</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang1-fpack-struct" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify the default maximum struct packing alignment</p>
+<dl class="option">
+<dt id="cmdoption-clang-fpascal-strings">
+<span id="cmdoption-clang-fno-pascal-strings"></span><span id="cmdoption-clang-mpascal-strings"></span><tt class="descname">-fpascal-strings</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-pascal-strings</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mpascal-strings</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fpascal-strings" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Recognize and construct Pascal-style string literals</p>
+<dl class="option">
+<dt id="cmdoption-clang-fpcc-struct-return">
+<tt class="descname">-fpcc-struct-return</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fpcc-struct-return" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Override the default ABI to return all structs on the stack</p>
+<dl class="option">
+<dt id="cmdoption-clang-fpch-preprocess">
+<tt class="descname">-fpch-preprocess</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fpch-preprocess" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fpic">
+<span id="cmdoption-clang-fno-pic"></span><tt class="descname">-fpic</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-pic</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fpic" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fpie">
+<span id="cmdoption-clang-fno-pie"></span><tt class="descname">-fpie</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-pie</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fpie" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fplugin">
+<tt class="descname">-fplugin</tt><tt class="descclassname">=<dsopath></tt><a class="headerlink" href="#cmdoption-clang-fplugin" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Load the named plugin (dynamic shared object)</p>
+<dl class="option">
+<dt id="cmdoption-clang-fpreserve-as-comments">
+<span id="cmdoption-clang-fno-preserve-as-comments"></span><tt class="descname">-fpreserve-as-comments</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-preserve-as-comments</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fpreserve-as-comments" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fprofile-arcs">
+<span id="cmdoption-clang-fno-profile-arcs"></span><tt class="descname">-fprofile-arcs</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-profile-arcs</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fprofile-arcs" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fprofile-dir">
+<tt class="descname">-fprofile-dir</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fprofile-dir" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fprofile-generate">
+<span id="cmdoption-clang-fno-profile-generate"></span><tt class="descname">-fprofile-generate</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-profile-generate</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fprofile-generate" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate instrumented code to collect execution counts into default.profraw (overridden by LLVM_PROFILE_FILE env var)</p>
+<dl class="option">
+<dt id="cmdoption-clang1-fprofile-generate">
+<tt class="descname">-fprofile-generate</tt><tt class="descclassname">=<directory></tt><a class="headerlink" href="#cmdoption-clang1-fprofile-generate" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate instrumented code to collect execution counts into <directory>/default.profraw (overridden by LLVM_PROFILE_FILE env var)</p>
+<dl class="option">
+<dt id="cmdoption-clang-fprofile-instr-generate">
+<span id="cmdoption-clang-fno-profile-instr-generate"></span><tt class="descname">-fprofile-instr-generate</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-profile-instr-generate</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fprofile-instr-generate" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate instrumented code to collect execution counts into default.profraw file (overridden by ‘=’ form of option or LLVM_PROFILE_FILE env var)</p>
+<dl class="option">
+<dt id="cmdoption-clang1-fprofile-instr-generate">
+<tt class="descname">-fprofile-instr-generate</tt><tt class="descclassname">=<file></tt><a class="headerlink" href="#cmdoption-clang1-fprofile-instr-generate" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate instrumented code to collect execution counts into <file> (overridden by LLVM_PROFILE_FILE env var)</p>
+<dl class="option">
+<dt id="cmdoption-clang-fprofile-instr-use">
+<span id="cmdoption-clang-fno-profile-instr-use"></span><span id="cmdoption-clang-fprofile-use"></span><tt class="descname">-fprofile-instr-use</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-profile-instr-use</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fprofile-use</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fprofile-instr-use" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-fprofile-instr-use">
+<tt class="descname">-fprofile-instr-use</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang1-fprofile-instr-use" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Use instrumentation data for profile-guided optimization</p>
+<dl class="option">
+<dt id="cmdoption-clang-fprofile-sample-use">
+<span id="cmdoption-clang-fauto-profile"></span><span id="cmdoption-clang-fno-profile-sample-use"></span><tt class="descname">-fprofile-sample-use</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fauto-profile</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-profile-sample-use</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fprofile-sample-use" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-fprofile-sample-use">
+<span id="cmdoption-clang1-fauto-profile"></span><tt class="descname">-fprofile-sample-use</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">-fauto-profile</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang1-fprofile-sample-use" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable sample-based profile guided optimizations</p>
+<dl class="option">
+<dt id="cmdoption-clang1-fprofile-use">
+<tt class="descname">-fprofile-use</tt><tt class="descclassname">=<pathname></tt><a class="headerlink" href="#cmdoption-clang1-fprofile-use" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Use instrumentation data for profile-guided optimization. If pathname is a directory, it reads from <pathname>/default.profdata. Otherwise, it reads from file <pathname>.</p>
+<dl class="option">
+<dt id="cmdoption-clang-freciprocal-math">
+<span id="cmdoption-clang-fno-reciprocal-math"></span><tt class="descname">-freciprocal-math</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-reciprocal-math</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-freciprocal-math" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Allow division operations to be reassociated</p>
+<dl class="option">
+<dt id="cmdoption-clang-freg-struct-return">
+<tt class="descname">-freg-struct-return</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-freg-struct-return" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Override the default ABI to return small structs in registers</p>
+<dl class="option">
+<dt id="cmdoption-clang-frelaxed-template-template-args">
+<span id="cmdoption-clang-fno-relaxed-template-template-args"></span><tt class="descname">-frelaxed-template-template-args</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-relaxed-template-template-args</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-frelaxed-template-template-args" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable C++17 relaxed template template argument matching</p>
+<dl class="option">
+<dt id="cmdoption-clang-freroll-loops">
+<span id="cmdoption-clang-fno-reroll-loops"></span><tt class="descname">-freroll-loops</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-reroll-loops</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-freroll-loops" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Turn on loop reroller</p>
+<dl class="option">
+<dt id="cmdoption-clang-fretain-comments-from-system-headers">
+<tt class="descname">-fretain-comments-from-system-headers</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fretain-comments-from-system-headers" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-frewrite-imports">
+<span id="cmdoption-clang-fno-rewrite-imports"></span><tt class="descname">-frewrite-imports</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-rewrite-imports</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-frewrite-imports" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-frewrite-includes">
+<span id="cmdoption-clang-fno-rewrite-includes"></span><tt class="descname">-frewrite-includes</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-rewrite-includes</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-frewrite-includes" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-frewrite-map-file">
+<tt class="descname">-frewrite-map-file</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-frewrite-map-file" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-frewrite-map-file">
+<tt class="descname">-frewrite-map-file</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang1-frewrite-map-file" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fropi">
+<span id="cmdoption-clang-fno-ropi"></span><tt class="descname">-fropi</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-ropi</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fropi" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-frtti">
+<span id="cmdoption-clang-fno-rtti"></span><tt class="descname">-frtti</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-rtti</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-frtti" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-frwpi">
+<span id="cmdoption-clang-fno-rwpi"></span><tt class="descname">-frwpi</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-rwpi</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-frwpi" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fsave-optimization-record">
+<span id="cmdoption-clang-fno-save-optimization-record"></span><tt class="descname">-fsave-optimization-record</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-save-optimization-record</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsave-optimization-record" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate a YAML optimization record file</p>
+<dl class="option">
+<dt id="cmdoption-clang-fshort-enums">
+<span id="cmdoption-clang-fno-short-enums"></span><tt class="descname">-fshort-enums</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-short-enums</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fshort-enums" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Allocate to an enum type only as many bytes as it needs for the declared range of possible values</p>
+<dl class="option">
+<dt id="cmdoption-clang-fshort-wchar">
+<span id="cmdoption-clang-fno-short-wchar"></span><tt class="descname">-fshort-wchar</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-short-wchar</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fshort-wchar" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Force wchar_t to be a short unsigned int</p>
+<dl class="option">
+<dt id="cmdoption-clang-fshow-column">
+<span id="cmdoption-clang-fno-show-column"></span><tt class="descname">-fshow-column</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-show-column</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fshow-column" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fshow-overloads">
+<tt class="descname">-fshow-overloads</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fshow-overloads" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Which overload candidates to show when overload resolution fails: best|all; defaults to all</p>
+<dl class="option">
+<dt id="cmdoption-clang-fshow-source-location">
+<span id="cmdoption-clang-fno-show-source-location"></span><tt class="descname">-fshow-source-location</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-show-source-location</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fshow-source-location" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fsignaling-math">
+<span id="cmdoption-clang-fno-signaling-math"></span><tt class="descname">-fsignaling-math</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-signaling-math</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsignaling-math" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fsigned-bitfields">
+<tt class="descname">-fsigned-bitfields</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsigned-bitfields" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fsigned-char">
+<span id="cmdoption-clang-fno-signed-char"></span><span id="cmdoption-clang--signed-char"></span><tt class="descname">-fsigned-char</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-signed-char</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--signed-char</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsigned-char" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fsigned-zeros">
+<span id="cmdoption-clang-fno-signed-zeros"></span><tt class="descname">-fsigned-zeros</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-signed-zeros</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsigned-zeros" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fsized-deallocation">
+<span id="cmdoption-clang-fno-sized-deallocation"></span><tt class="descname">-fsized-deallocation</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-sized-deallocation</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsized-deallocation" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable C++14 sized global deallocation functions</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsjlj-exceptions">
+<tt class="descname">-fsjlj-exceptions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsjlj-exceptions" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Use SjLj style exceptions</p>
+<dl class="option">
+<dt id="cmdoption-clang-fslp-vectorize">
+<span id="cmdoption-clang-fno-slp-vectorize"></span><span id="cmdoption-clang-ftree-slp-vectorize"></span><tt class="descname">-fslp-vectorize</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-slp-vectorize</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-ftree-slp-vectorize</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fslp-vectorize" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable the superword-level parallelism vectorization passes</p>
+<dl class="option">
+<dt id="cmdoption-clang-fspell-checking">
+<span id="cmdoption-clang-fno-spell-checking"></span><tt class="descname">-fspell-checking</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-spell-checking</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fspell-checking" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fspell-checking-limit">
+<tt class="descname">-fspell-checking-limit</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fspell-checking-limit" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fsplit-dwarf-inlining">
+<span id="cmdoption-clang-fno-split-dwarf-inlining"></span><tt class="descname">-fsplit-dwarf-inlining</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-split-dwarf-inlining</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsplit-dwarf-inlining" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Place debug types in their own section (ELF Only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-fsplit-stack">
+<tt class="descname">-fsplit-stack</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsplit-stack" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fstack-protector">
+<span id="cmdoption-clang-fno-stack-protector"></span><tt class="descname">-fstack-protector</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-stack-protector</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fstack-protector" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable stack protectors for functions potentially vulnerable to stack smashing</p>
+<dl class="option">
+<dt id="cmdoption-clang-fstack-protector-all">
+<tt class="descname">-fstack-protector-all</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fstack-protector-all" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Force the usage of stack protectors for all functions</p>
+<dl class="option">
+<dt id="cmdoption-clang-fstack-protector-strong">
+<tt class="descname">-fstack-protector-strong</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fstack-protector-strong" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Use a strong heuristic to apply stack protectors to functions</p>
+<dl class="option">
+<dt id="cmdoption-clang-fstandalone-debug">
+<span id="cmdoption-clang-fno-limit-debug-info"></span><span id="cmdoption-clang-fno-standalone-debug"></span><tt class="descname">-fstandalone-debug</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-limit-debug-info</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-standalone-debug</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fstandalone-debug" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Emit full debug info for all types used by the program</p>
+<dl class="option">
+<dt id="cmdoption-clang-fstrict-aliasing">
+<span id="cmdoption-clang-fno-strict-aliasing"></span><tt class="descname">-fstrict-aliasing</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-strict-aliasing</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fstrict-aliasing" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fstrict-enums">
+<span id="cmdoption-clang-fno-strict-enums"></span><tt class="descname">-fstrict-enums</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-strict-enums</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fstrict-enums" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable optimizations based on the strict definition of an enum’s value range</p>
+<dl class="option">
+<dt id="cmdoption-clang-fstrict-overflow">
+<span id="cmdoption-clang-fno-strict-overflow"></span><tt class="descname">-fstrict-overflow</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-strict-overflow</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fstrict-overflow" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fstrict-return">
+<span id="cmdoption-clang-fno-strict-return"></span><tt class="descname">-fstrict-return</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-strict-return</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fstrict-return" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Always treat control flow paths that fall off the end of a non-void function as unreachable</p>
+<dl class="option">
+<dt id="cmdoption-clang-fstrict-vtable-pointers">
+<span id="cmdoption-clang-fno-strict-vtable-pointers"></span><tt class="descname">-fstrict-vtable-pointers</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-strict-vtable-pointers</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fstrict-vtable-pointers" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable optimizations based on the strict rules for overwriting polymorphic C++ objects</p>
+<dl class="option">
+<dt id="cmdoption-clang-fstruct-path-tbaa">
+<span id="cmdoption-clang-fno-struct-path-tbaa"></span><tt class="descname">-fstruct-path-tbaa</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-struct-path-tbaa</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fstruct-path-tbaa" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ftabstop">
+<tt class="descname">-ftabstop</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-ftabstop" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ftemplate-backtrace-limit">
+<tt class="descname">-ftemplate-backtrace-limit</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-ftemplate-backtrace-limit" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ftemplate-depth-">
+<tt class="descname">-ftemplate-depth-</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-ftemplate-depth-" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ftemplate-depth">
+<tt class="descname">-ftemplate-depth</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-ftemplate-depth" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ftest-coverage">
+<tt class="descname">-ftest-coverage</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ftest-coverage" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fthinlto-index">
+<tt class="descname">-fthinlto-index</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fthinlto-index" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Perform ThinLTO importing using provided function summary index</p>
+<dl class="option">
+<dt id="cmdoption-clang-fthreadsafe-statics">
+<span id="cmdoption-clang-fno-threadsafe-statics"></span><tt class="descname">-fthreadsafe-statics</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-threadsafe-statics</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fthreadsafe-statics" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ftime-report">
+<tt class="descname">-ftime-report</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ftime-report" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ftls-model">
+<tt class="descname">-ftls-model</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-ftls-model" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ftrap-function">
+<tt class="descname">-ftrap-function</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-ftrap-function" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Issue call to specified function rather than a trap instruction</p>
+<dl class="option">
+<dt id="cmdoption-clang-ftrapping-math">
+<span id="cmdoption-clang-fno-trapping-math"></span><tt class="descname">-ftrapping-math</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-trapping-math</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ftrapping-math" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ftrapv">
+<tt class="descname">-ftrapv</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ftrapv" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Trap on integer overflow</p>
+<dl class="option">
+<dt id="cmdoption-clang-ftrapv-handler">
+<tt class="descname">-ftrapv-handler</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-ftrapv-handler" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-ftrapv-handler">
+<tt class="descname">-ftrapv-handler</tt><tt class="descclassname">=<function name></tt><a class="headerlink" href="#cmdoption-clang1-ftrapv-handler" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify the function to be called on overflow</p>
+<dl class="option">
+<dt id="cmdoption-clang-ftrigraphs">
+<span id="cmdoption-clang-fno-trigraphs"></span><span id="cmdoption-clang-trigraphs"></span><span id="cmdoption-clang--trigraphs"></span><tt class="descname">-ftrigraphs</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-trigraphs</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-trigraphs</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--trigraphs</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ftrigraphs" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Process trigraph sequences</p>
+<dl class="option">
+<dt id="cmdoption-clang-funique-section-names">
+<span id="cmdoption-clang-fno-unique-section-names"></span><tt class="descname">-funique-section-names</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-unique-section-names</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-funique-section-names" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Use unique names for text and data sections (ELF Only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-funit-at-a-time">
+<span id="cmdoption-clang-fno-unit-at-a-time"></span><tt class="descname">-funit-at-a-time</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-unit-at-a-time</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-funit-at-a-time" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-funroll-loops">
+<span id="cmdoption-clang-fno-unroll-loops"></span><tt class="descname">-funroll-loops</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-unroll-loops</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-funroll-loops" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Turn on loop unroller</p>
+<dl class="option">
+<dt id="cmdoption-clang-funsafe-math-optimizations">
+<span id="cmdoption-clang-fno-unsafe-math-optimizations"></span><tt class="descname">-funsafe-math-optimizations</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-unsafe-math-optimizations</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-funsafe-math-optimizations" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-funsigned-bitfields">
+<tt class="descname">-funsigned-bitfields</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-funsigned-bitfields" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-funsigned-char">
+<span id="cmdoption-clang-fno-unsigned-char"></span><span id="cmdoption-clang--unsigned-char"></span><tt class="descname">-funsigned-char</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-unsigned-char</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--unsigned-char</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-funsigned-char" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-funwind-tables">
+<span id="cmdoption-clang-fno-unwind-tables"></span><tt class="descname">-funwind-tables</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-unwind-tables</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-funwind-tables" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fuse-cxa-atexit">
+<span id="cmdoption-clang-fno-use-cxa-atexit"></span><tt class="descname">-fuse-cxa-atexit</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-use-cxa-atexit</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fuse-cxa-atexit" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fuse-init-array">
+<span id="cmdoption-clang-fno-use-init-array"></span><tt class="descname">-fuse-init-array</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-use-init-array</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fuse-init-array" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Use .init_array instead of .ctors</p>
+<dl class="option">
+<dt id="cmdoption-clang-fuse-ld">
+<tt class="descname">-fuse-ld</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fuse-ld" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fuse-line-directives">
+<span id="cmdoption-clang-fno-use-line-directives"></span><tt class="descname">-fuse-line-directives</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-use-line-directives</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fuse-line-directives" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fveclib">
+<tt class="descname">-fveclib</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fveclib" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Use the given vector functions library</p>
+<dl class="option">
+<dt id="cmdoption-clang-fvectorize">
+<span id="cmdoption-clang-fno-vectorize"></span><span id="cmdoption-clang-ftree-vectorize"></span><tt class="descname">-fvectorize</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-vectorize</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-ftree-vectorize</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fvectorize" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable the loop vectorization passes</p>
+<dl class="option">
+<dt id="cmdoption-clang-fverbose-asm">
+<span id="cmdoption-clang-fno-verbose-asm"></span><tt class="descname">-fverbose-asm</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-verbose-asm</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fverbose-asm" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fvisibility-inlines-hidden">
+<tt class="descname">-fvisibility-inlines-hidden</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fvisibility-inlines-hidden" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Give inline C++ member functions default visibility by default</p>
+<dl class="option">
+<dt id="cmdoption-clang-fvisibility-ms-compat">
+<tt class="descname">-fvisibility-ms-compat</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fvisibility-ms-compat" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Give global types ‘default’ visibility and global functions and variables ‘hidden’ visibility by default</p>
+<dl class="option">
+<dt id="cmdoption-clang-fvisibility">
+<tt class="descname">-fvisibility</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fvisibility" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Set the default symbol visibility for all global declarations</p>
+<dl class="option">
+<dt id="cmdoption-clang-fwhole-program-vtables">
+<span id="cmdoption-clang-fno-whole-program-vtables"></span><tt class="descname">-fwhole-program-vtables</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-whole-program-vtables</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fwhole-program-vtables" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enables whole-program vtable optimization. Requires -flto</p>
+<dl class="option">
+<dt id="cmdoption-clang-fwrapv">
+<span id="cmdoption-clang-fno-wrapv"></span><tt class="descname">-fwrapv</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-wrapv</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fwrapv" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Treat signed integer overflow as two’s complement</p>
+<dl class="option">
+<dt id="cmdoption-clang-fwritable-strings">
+<tt class="descname">-fwritable-strings</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fwritable-strings" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Store string literals as writable data</p>
+<dl class="option">
+<dt id="cmdoption-clang-fxray-always-instrument">
+<tt class="descname">-fxray-always-instrument</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fxray-always-instrument" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Filename defining the whitelist for imbuing the ‘always instrument’ XRay attribute.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fxray-instruction-threshold">
+<tt class="descname">-fxray-instruction-threshold</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-fxray-instruction-threshold" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-fxray-instruction-threshold">
+<tt class="descname">-fxray-instruction-threshold</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang1-fxray-instruction-threshold" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Sets the minimum function size to instrument with XRay</p>
+<dl class="option">
+<dt id="cmdoption-clang-fxray-instrument">
+<span id="cmdoption-clang-fno-xray-instrument"></span><tt class="descname">-fxray-instrument</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-xray-instrument</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fxray-instrument" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate XRay instrumentation sleds on function entry and exit</p>
+<dl class="option">
+<dt id="cmdoption-clang-fxray-never-instrument">
+<tt class="descname">-fxray-never-instrument</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fxray-never-instrument" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Filename defining the whitelist for imbuing the ‘never instrument’ XRay attribute.</p>
+<dl class="option">
+<dt id="cmdoption-clang-fzero-initialized-in-bss">
+<span id="cmdoption-clang-fno-zero-initialized-in-bss"></span><tt class="descname">-fzero-initialized-in-bss</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-zero-initialized-in-bss</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fzero-initialized-in-bss" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fzvector">
+<span id="cmdoption-clang-fno-zvector"></span><span id="cmdoption-clang-mzvector"></span><tt class="descname">-fzvector</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-zvector</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mzvector</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fzvector" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable System z vector language extension</p>
+<dl class="option">
+<dt id="cmdoption-clang-pedantic">
+<span id="cmdoption-clang--pedantic"></span><span id="cmdoption-clang-no-pedantic"></span><span id="cmdoption-clang--no-pedantic"></span><tt class="descname">-pedantic</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--pedantic</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-no-pedantic</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--no-pedantic</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-pedantic" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-pedantic-errors">
+<span id="cmdoption-clang--pedantic-errors"></span><tt class="descname">-pedantic-errors</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--pedantic-errors</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-pedantic-errors" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<div class="section" id="opencl-flags">
+<h4><a class="toc-backref" href="#id10">OpenCL flags</a><a class="headerlink" href="#opencl-flags" title="Permalink to this headline">Â¶</a></h4>
+<dl class="option">
+<dt id="cmdoption-clang-cl-denorms-are-zero">
+<tt class="descname">-cl-denorms-are-zero</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-cl-denorms-are-zero" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>OpenCL only. Allow denormals to be flushed to zero.</p>
+<dl class="option">
+<dt id="cmdoption-clang-cl-fast-relaxed-math">
+<tt class="descname">-cl-fast-relaxed-math</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-cl-fast-relaxed-math" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>OpenCL only. Sets -cl-finite-math-only and -cl-unsafe-math-optimizations, and defines __FAST_RELAXED_MATH__.</p>
+<dl class="option">
+<dt id="cmdoption-clang-cl-finite-math-only">
+<tt class="descname">-cl-finite-math-only</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-cl-finite-math-only" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>OpenCL only. Allow floating-point optimizations that assume arguments and results are not NaNs or +-Inf.</p>
+<dl class="option">
+<dt id="cmdoption-clang-cl-fp32-correctly-rounded-divide-sqrt">
+<tt class="descname">-cl-fp32-correctly-rounded-divide-sqrt</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-cl-fp32-correctly-rounded-divide-sqrt" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>OpenCL only. Specify that single precision floating-point divide and sqrt used in the program source are correctly rounded.</p>
+<dl class="option">
+<dt id="cmdoption-clang-cl-kernel-arg-info">
+<tt class="descname">-cl-kernel-arg-info</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-cl-kernel-arg-info" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>OpenCL only. Generate kernel argument metadata.</p>
+<dl class="option">
+<dt id="cmdoption-clang-cl-mad-enable">
+<tt class="descname">-cl-mad-enable</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-cl-mad-enable" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>OpenCL only. Allow use of less precise MAD computations in the generated binary.</p>
+<dl class="option">
+<dt id="cmdoption-clang-cl-no-signed-zeros">
+<tt class="descname">-cl-no-signed-zeros</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-cl-no-signed-zeros" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>OpenCL only. Allow use of less precise no signed zeros computations in the generated binary.</p>
+<dl class="option">
+<dt id="cmdoption-clang-cl-opt-disable">
+<tt class="descname">-cl-opt-disable</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-cl-opt-disable" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>OpenCL only. This option disables all optimizations. By default optimizations are enabled.</p>
+<dl class="option">
+<dt id="cmdoption-clang-cl-single-precision-constant">
+<tt class="descname">-cl-single-precision-constant</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-cl-single-precision-constant" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>OpenCL only. Treat double precision floating-point constant as single precision constant.</p>
+<dl class="option">
+<dt id="cmdoption-clang-cl-std">
+<tt class="descname">-cl-std</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-cl-std" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>OpenCL language standard to compile for.</p>
+<dl class="option">
+<dt id="cmdoption-clang-cl-strict-aliasing">
+<tt class="descname">-cl-strict-aliasing</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-cl-strict-aliasing" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>OpenCL only. This option is added for compatibility with OpenCL 1.0.</p>
+<dl class="option">
+<dt id="cmdoption-clang-cl-unsafe-math-optimizations">
+<tt class="descname">-cl-unsafe-math-optimizations</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-cl-unsafe-math-optimizations" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>OpenCL only. Allow unsafe floating-point optimizations.  Also implies -cl-no-signed-zeros and -cl-mad-enable.</p>
+</div>
+</div>
+<div class="section" id="target-dependent-compilation-options">
+<h3><a class="toc-backref" href="#id11">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">
+<span id="cmdoption-clang-G"></span><span id="cmdoption-clang-msmall-data-threshold"></span><tt class="descname">-G</tt><tt class="descclassname"><size></tt><tt class="descclassname">, </tt><tt class="descname">-G</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">-msmall-data-threshold</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-G" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Put objects of at most <size> bytes into small data section (MIPS / Hexagon)</p>
+<dl class="option">
+<dt id="cmdoption-clang-m16">
+<tt class="descname">-m16</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-m16" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-m32">
+<tt class="descname">-m32</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-m32" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-m64">
+<tt class="descname">-m64</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-m64" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mabi">
+<tt class="descname">-mabi</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mabi" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mabicalls">
+<span id="cmdoption-clang-mno-abicalls"></span><tt class="descname">-mabicalls</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-abicalls</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mabicalls" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable SVR4-style position-independent code (Mips only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-malign-double">
+<tt class="descname">-malign-double</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-malign-double" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Align doubles to two words in structs (x86 only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-march">
+<tt class="descname">-march</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-march" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-masm">
+<tt class="descname">-masm</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-masm" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mbackchain">
+<span id="cmdoption-clang-mno-backchain"></span><tt class="descname">-mbackchain</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-backchain</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mbackchain" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Link stack frames through backchain on System Z</p>
+<dl class="option">
+<dt id="cmdoption-clang-mcheck-zero-division">
+<span id="cmdoption-clang-mno-check-zero-division"></span><tt class="descname">-mcheck-zero-division</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-check-zero-division</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mcheck-zero-division" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mcmodel">
+<tt class="descname">-mcmodel</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mcmodel" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mcompact-branches">
+<tt class="descname">-mcompact-branches</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mcompact-branches" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mconsole">
+<tt class="descname">-mconsole</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-mconsole" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mcpu">
+<span id="cmdoption-clang-mv4"></span><span id="cmdoption-clang-mv5"></span><span id="cmdoption-clang-mv55"></span><span id="cmdoption-clang-mv60"></span><span id="cmdoption-clang-mv62"></span><tt class="descname">-mcpu</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">-mv4</tt><tt class="descclassname"> (equivalent to -mcpu=hexagonv4)</tt><tt class="descclassname">, </tt><tt class="descname">-mv5</tt><tt class="descclassname"> (equivalent to -mcpu=hexagonv5)</tt><tt class="descclassname">, </tt><tt class="descname">-mv55</tt><tt class="descclassname"> (equivalent to -mcpu=hexagonv55)</tt><tt class="descclassname">, </tt><tt class="descname">-mv60</tt><tt class="descclassname"> (equivalent to -mcpu=hexagonv60)</tt><tt class="descclassname">, </tt><tt class="descname">-mv62</tt><tt class="descclassname"> (equivalent to -mcpu=hexagonv62)</tt><a class="headerlink" href="#cmdoption-clang-mcpu" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mdefault-build-attributes">
+<span id="cmdoption-clang-mno-default-build-attributes"></span><tt class="descname">-mdefault-build-attributes</tt><tt class="descclassname"><arg></tt><tt class="descclassname">, </tt><tt class="descname">-mno-default-build-attributes</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-mdefault-build-attributes" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mdll">
+<tt class="descname">-mdll</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-mdll" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mdouble-float">
+<tt class="descname">-mdouble-float</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mdouble-float" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mdsp">
+<span id="cmdoption-clang-mno-dsp"></span><tt class="descname">-mdsp</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-dsp</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mdsp" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mdspr2">
+<span id="cmdoption-clang-mno-dspr2"></span><tt class="descname">-mdspr2</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-dspr2</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mdspr2" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mdynamic-no-pic">
+<tt class="descname">-mdynamic-no-pic</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-mdynamic-no-pic" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-meabi">
+<tt class="descname">-meabi</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-meabi" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Set EABI type, e.g. 4, 5 or gnu (default depends on triple)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mfentry">
+<tt class="descname">-mfentry</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mfentry" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Insert calls to fentry at function entry (x86 only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mfloat-abi">
+<tt class="descname">-mfloat-abi</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mfloat-abi" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mfp32">
+<tt class="descname">-mfp32</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mfp32" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Use 32-bit floating point registers (MIPS only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mfp64">
+<tt class="descname">-mfp64</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mfp64" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Use 64-bit floating point registers (MIPS only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mfpmath">
+<tt class="descname">-mfpmath</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mfpmath" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mfpu">
+<tt class="descname">-mfpu</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mfpu" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mglobal-merge">
+<span id="cmdoption-clang-mno-global-merge"></span><tt class="descname">-mglobal-merge</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-global-merge</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mglobal-merge" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable merging of globals</p>
+<dl class="option">
+<dt id="cmdoption-clang-mhard-float">
+<tt class="descname">-mhard-float</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mhard-float" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mhwdiv">
+<span id="cmdoption-clang--mhwdiv"></span><span id="cmdoption-clang--mhwdiv"></span><tt class="descname">-mhwdiv</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">--mhwdiv</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--mhwdiv</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mhwdiv" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-miamcu">
+<span id="cmdoption-clang-mno-iamcu"></span><tt class="descname">-miamcu</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-iamcu</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-miamcu" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Use Intel MCU ABI</p>
+<dl class="option">
+<dt id="cmdoption-clang-mimplicit-float">
+<span id="cmdoption-clang-mno-implicit-float"></span><tt class="descname">-mimplicit-float</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-implicit-float</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mimplicit-float" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mimplicit-it">
+<tt class="descname">-mimplicit-it</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mimplicit-it" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mincremental-linker-compatible">
+<span id="cmdoption-clang-mno-incremental-linker-compatible"></span><tt class="descname">-mincremental-linker-compatible</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-incremental-linker-compatible</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mincremental-linker-compatible" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>(integrated-as) Emit an object file which can be used with an incremental linker</p>
+<dl class="option">
+<dt id="cmdoption-clang-miphoneos-version-min">
+<span id="cmdoption-clang-mios-version-min"></span><tt class="descname">-miphoneos-version-min</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">-mios-version-min</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-miphoneos-version-min" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mips16">
+<tt class="descname">-mips16</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mips16" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mkernel">
+<tt class="descname">-mkernel</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mkernel" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mldc1-sdc1">
+<span id="cmdoption-clang-mno-ldc1-sdc1"></span><tt class="descname">-mldc1-sdc1</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-ldc1-sdc1</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mldc1-sdc1" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mlong-calls">
+<span id="cmdoption-clang-mno-long-calls"></span><tt class="descname">-mlong-calls</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-long-calls</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mlong-calls" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate branches with extended addressability, usually via indirect jumps.</p>
+<dl class="option">
+<dt id="cmdoption-clang-mmacosx-version-min">
+<span id="cmdoption-clang-mmacos-version-min"></span><tt class="descname">-mmacosx-version-min</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">-mmacos-version-min</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mmacosx-version-min" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Set Mac OS X deployment target</p>
+<dl class="option">
+<dt id="cmdoption-clang-mmadd4">
+<span id="cmdoption-clang-mno-madd4"></span><tt class="descname">-mmadd4</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-madd4</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mmadd4" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable the generation of 4-operand madd.s, madd.d and related instructions.</p>
+<dl class="option">
+<dt id="cmdoption-clang-mmcu">
+<tt class="descname">-mmcu</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mmcu" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mmicromips">
+<span id="cmdoption-clang-mno-micromips"></span><tt class="descname">-mmicromips</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-micromips</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mmicromips" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mms-bitfields">
+<span id="cmdoption-clang-mno-ms-bitfields"></span><tt class="descname">-mms-bitfields</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-ms-bitfields</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mms-bitfields" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Set the default structure layout to be compatible with the Microsoft compiler standard</p>
+<dl class="option">
+<dt id="cmdoption-clang-mmsa">
+<span id="cmdoption-clang-mno-msa"></span><tt class="descname">-mmsa</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-msa</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mmsa" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable MSA ASE (MIPS only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mmt">
+<span id="cmdoption-clang-mno-mt"></span><tt class="descname">-mmt</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-mt</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mmt" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable MT ASE (MIPS only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mnan">
+<tt class="descname">-mnan</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mnan" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mno-mips16">
+<tt class="descname">-mno-mips16</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mno-mips16" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-momit-leaf-frame-pointer">
+<span id="cmdoption-clang-mno-omit-leaf-frame-pointer"></span><tt class="descname">-momit-leaf-frame-pointer</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-omit-leaf-frame-pointer</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-momit-leaf-frame-pointer" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Omit frame pointer setup for leaf functions</p>
+<dl class="option">
+<dt id="cmdoption-clang-moslib">
+<tt class="descname">-moslib</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-moslib" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mpie-copy-relocations">
+<span id="cmdoption-clang-mno-pie-copy-relocations"></span><tt class="descname">-mpie-copy-relocations</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-pie-copy-relocations</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mpie-copy-relocations" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Use copy relocations support for PIE builds</p>
+<dl class="option">
+<dt id="cmdoption-clang-mqdsp6-compat">
+<tt class="descname">-mqdsp6-compat</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mqdsp6-compat" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable hexagon-qdsp6 backward compatibility</p>
+<dl class="option">
+<dt id="cmdoption-clang-mrecip">
+<tt class="descname">-mrecip</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mrecip" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-mrecip">
+<tt class="descname">-mrecip</tt><tt class="descclassname">=<arg1>,<arg2>...</tt><a class="headerlink" href="#cmdoption-clang1-mrecip" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mred-zone">
+<span id="cmdoption-clang-mno-red-zone"></span><tt class="descname">-mred-zone</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-red-zone</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mred-zone" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mregparm">
+<tt class="descname">-mregparm</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mregparm" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mrelax-all">
+<span id="cmdoption-clang-mno-relax-all"></span><tt class="descname">-mrelax-all</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-relax-all</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mrelax-all" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>(integrated-as) Relax all machine instructions</p>
+<dl class="option">
+<dt id="cmdoption-clang-mrtd">
+<span id="cmdoption-clang-mno-rtd"></span><tt class="descname">-mrtd</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-rtd</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mrtd" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Make StdCall calling convention the default</p>
+<dl class="option">
+<dt id="cmdoption-clang-msingle-float">
+<tt class="descname">-msingle-float</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-msingle-float" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-msoft-float">
+<span id="cmdoption-clang-mno-soft-float"></span><tt class="descname">-msoft-float</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-soft-float</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-msoft-float" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Use software floating point</p>
+<dl class="option">
+<dt id="cmdoption-clang-mstack-alignment">
+<tt class="descname">-mstack-alignment</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mstack-alignment" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Set the stack alignment</p>
+<dl class="option">
+<dt id="cmdoption-clang-mstack-probe-size">
+<tt class="descname">-mstack-probe-size</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mstack-probe-size" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Set the stack probe size</p>
+<dl class="option">
+<dt id="cmdoption-clang-mstackrealign">
+<span id="cmdoption-clang-mno-stackrealign"></span><tt class="descname">-mstackrealign</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-stackrealign</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mstackrealign" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Force realign the stack at entry to every function</p>
+<dl class="option">
+<dt id="cmdoption-clang-mthread-model">
+<tt class="descname">-mthread-model</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-mthread-model" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>The thread model to use, e.g. posix, single (posix by default)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mthreads">
+<tt class="descname">-mthreads</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-mthreads" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mthumb">
+<span id="cmdoption-clang-mno-thumb"></span><tt class="descname">-mthumb</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-thumb</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mthumb" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mtune">
+<tt class="descname">-mtune</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mtune" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mtvos-version-min">
+<span id="cmdoption-clang-mappletvos-version-min"></span><tt class="descname">-mtvos-version-min</tt><tt class="descclassname">=<arg></tt><tt class="descclassname">, </tt><tt class="descname">-mappletvos-version-min</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mtvos-version-min" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-municode">
+<tt class="descname">-municode</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-municode" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mvx">
+<span id="cmdoption-clang-mno-vx"></span><tt class="descname">-mvx</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-vx</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mvx" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mwarn-nonportable-cfstrings">
+<span id="cmdoption-clang-mno-warn-nonportable-cfstrings"></span><tt class="descname">-mwarn-nonportable-cfstrings</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-warn-nonportable-cfstrings</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mwarn-nonportable-cfstrings" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mwatchos-version-min">
+<tt class="descname">-mwatchos-version-min</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-mwatchos-version-min" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mwindows">
+<tt class="descname">-mwindows</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-mwindows" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mx32">
+<tt class="descname">-mx32</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mx32" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mxgot">
+<span id="cmdoption-clang-mno-xgot"></span><tt class="descname">-mxgot</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-xgot</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mxgot" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<div class="section" id="aarch64">
+<h4><a class="toc-backref" href="#id12">AARCH64</a><a class="headerlink" href="#aarch64" title="Permalink to this headline">Â¶</a></h4>
+<dl class="option">
+<dt id="cmdoption-clang-ffixed-x18">
+<tt class="descname">-ffixed-x18</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ffixed-x18" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Reserve the x18 register (AArch64 only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mfix-cortex-a53-835769">
+<span id="cmdoption-clang-mno-fix-cortex-a53-835769"></span><tt class="descname">-mfix-cortex-a53-835769</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-fix-cortex-a53-835769</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mfix-cortex-a53-835769" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Workaround Cortex-A53 erratum 835769 (AArch64 only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mgeneral-regs-only">
+<tt class="descname">-mgeneral-regs-only</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mgeneral-regs-only" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate code which only uses the general purpose registers (AArch64 only)</p>
+</div>
+<div class="section" id="amdgpu">
+<h4><a class="toc-backref" href="#id13">AMDGPU</a><a class="headerlink" href="#amdgpu" title="Permalink to this headline">Â¶</a></h4>
+</div>
+<div class="section" id="arm">
+<h4><a class="toc-backref" href="#id14">ARM</a><a class="headerlink" href="#arm" title="Permalink to this headline">Â¶</a></h4>
+<dl class="option">
+<dt id="cmdoption-clang-ffixed-r9">
+<tt class="descname">-ffixed-r9</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ffixed-r9" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Reserve the r9 register (ARM only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mcrc">
+<tt class="descname">-mcrc</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mcrc" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Allow use of CRC instructions (ARM only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mexecute-only">
+<span id="cmdoption-clang-mno-execute-only"></span><span id="cmdoption-clang-mpure-code"></span><tt class="descname">-mexecute-only</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-execute-only</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mpure-code</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mexecute-only" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Disallow generation of data access to code sections (ARM only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mno-movt">
+<tt class="descname">-mno-movt</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mno-movt" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Disallow use of movt/movw pairs (ARM only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mno-neg-immediates">
+<tt class="descname">-mno-neg-immediates</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mno-neg-immediates" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Disallow converting instructions with negative immediates to their negation or inversion.</p>
+<dl class="option">
+<dt id="cmdoption-clang-mnocrc">
+<tt class="descname">-mnocrc</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mnocrc" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Disallow use of CRC instructions (ARM only)</p>
+<dl class="option">
+<dt id="cmdoption-clang-mrestrict-it">
+<span id="cmdoption-clang-mno-restrict-it"></span><tt class="descname">-mrestrict-it</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-restrict-it</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mrestrict-it" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Disallow generation of deprecated IT blocks for ARMv8. It is on by default for ARMv8 Thumb mode.</p>
+<dl class="option">
+<dt id="cmdoption-clang-munaligned-access">
+<span id="cmdoption-clang-mno-unaligned-access"></span><tt class="descname">-munaligned-access</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-unaligned-access</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-munaligned-access" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Allow memory accesses to be unaligned (AArch32/AArch64 only)</p>
+</div>
+<div class="section" id="hexagon">
+<h4><a class="toc-backref" href="#id15">Hexagon</a><a class="headerlink" href="#hexagon" title="Permalink to this headline">Â¶</a></h4>
+<dl class="option">
+<dt id="cmdoption-clang-mhvx">
+<span id="cmdoption-clang-mno-hvx"></span><tt class="descname">-mhvx</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-hvx</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mhvx" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable Hexagon Vector eXtensions</p>
+<dl class="option">
+<dt id="cmdoption-clang-mhvx-double">
+<span id="cmdoption-clang-mno-hvx-double"></span><tt class="descname">-mhvx-double</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-hvx-double</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mhvx-double" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Enable Hexagon Double Vector eXtensions</p>
+<dl class="option">
+<dt id="cmdoption-clang-mieee-rnd-near">
+<tt class="descname">-mieee-rnd-near</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mieee-rnd-near" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+</div>
+<div class="section" id="powerpc">
+<h4><a class="toc-backref" href="#id16">PowerPC</a><a class="headerlink" href="#powerpc" title="Permalink to this headline">Â¶</a></h4>
+<dl class="option">
+<dt id="cmdoption-clang-maltivec">
+<span id="cmdoption-clang-mno-altivec"></span><tt class="descname">-maltivec</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-altivec</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-maltivec" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mcmpb">
+<span id="cmdoption-clang-mno-cmpb"></span><tt class="descname">-mcmpb</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-cmpb</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mcmpb" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mcrbits">
+<span id="cmdoption-clang-mno-crbits"></span><tt class="descname">-mcrbits</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-crbits</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mcrbits" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mcrypto">
+<span id="cmdoption-clang-mno-crypto"></span><tt class="descname">-mcrypto</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-crypto</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mcrypto" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mdirect-move">
+<span id="cmdoption-clang-mno-direct-move"></span><tt class="descname">-mdirect-move</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-direct-move</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mdirect-move" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mfloat128">
+<span id="cmdoption-clang-mno-float128"></span><tt class="descname">-mfloat128</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-float128</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mfloat128" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mfprnd">
+<span id="cmdoption-clang-mno-fprnd"></span><tt class="descname">-mfprnd</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-fprnd</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mfprnd" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mhtm">
+<span id="cmdoption-clang-mno-htm"></span><tt class="descname">-mhtm</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-htm</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mhtm" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-minvariant-function-descriptors">
+<span id="cmdoption-clang-mno-invariant-function-descriptors"></span><tt class="descname">-minvariant-function-descriptors</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-invariant-function-descriptors</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-minvariant-function-descriptors" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-misel">
+<span id="cmdoption-clang-mno-isel"></span><tt class="descname">-misel</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-isel</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-misel" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mlongcall">
+<span id="cmdoption-clang-mno-longcall"></span><tt class="descname">-mlongcall</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-longcall</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mlongcall" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mmfocrf">
+<span id="cmdoption-clang-mmfcrf"></span><span id="cmdoption-clang-mno-mfocrf"></span><tt class="descname">-mmfocrf</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mmfcrf</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-mfocrf</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mmfocrf" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mpopcntd">
+<span id="cmdoption-clang-mno-popcntd"></span><tt class="descname">-mpopcntd</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-popcntd</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mpopcntd" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mpower8-vector">
+<span id="cmdoption-clang-mno-power8-vector"></span><tt class="descname">-mpower8-vector</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-power8-vector</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mpower8-vector" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mpower9-vector">
+<span id="cmdoption-clang-mno-power9-vector"></span><tt class="descname">-mpower9-vector</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-power9-vector</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mpower9-vector" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mqpx">
+<span id="cmdoption-clang-mno-qpx"></span><tt class="descname">-mqpx</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-qpx</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mqpx" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mvsx">
+<span id="cmdoption-clang-mno-vsx"></span><tt class="descname">-mvsx</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-vsx</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mvsx" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+</div>
+<div class="section" id="webassembly">
+<h4><a class="toc-backref" href="#id17">WebAssembly</a><a class="headerlink" href="#webassembly" title="Permalink to this headline">Â¶</a></h4>
+<dl class="option">
+<dt id="cmdoption-clang-msimd128">
+<span id="cmdoption-clang-mno-simd128"></span><tt class="descname">-msimd128</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-simd128</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-msimd128" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+</div>
+<div class="section" id="x86">
+<h4><a class="toc-backref" href="#id18">X86</a><a class="headerlink" href="#x86" title="Permalink to this headline">Â¶</a></h4>
+<dl class="option">
+<dt id="cmdoption-clang-m3dnow">
+<span id="cmdoption-clang-mno-3dnow"></span><tt class="descname">-m3dnow</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-3dnow</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-m3dnow" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-m3dnowa">
+<span id="cmdoption-clang-mno-3dnowa"></span><tt class="descname">-m3dnowa</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-3dnowa</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-m3dnowa" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-madx">
+<span id="cmdoption-clang-mno-adx"></span><tt class="descname">-madx</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-adx</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-madx" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-maes">
+<span id="cmdoption-clang-mno-aes"></span><tt class="descname">-maes</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-aes</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-maes" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mavx">
+<span id="cmdoption-clang-mno-avx"></span><tt class="descname">-mavx</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-avx</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mavx" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mavx2">
+<span id="cmdoption-clang-mno-avx2"></span><tt class="descname">-mavx2</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-avx2</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mavx2" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mavx512bw">
+<span id="cmdoption-clang-mno-avx512bw"></span><tt class="descname">-mavx512bw</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-avx512bw</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mavx512bw" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mavx512cd">
+<span id="cmdoption-clang-mno-avx512cd"></span><tt class="descname">-mavx512cd</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-avx512cd</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mavx512cd" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mavx512dq">
+<span id="cmdoption-clang-mno-avx512dq"></span><tt class="descname">-mavx512dq</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-avx512dq</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mavx512dq" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mavx512er">
+<span id="cmdoption-clang-mno-avx512er"></span><tt class="descname">-mavx512er</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-avx512er</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mavx512er" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mavx512f">
+<span id="cmdoption-clang-mno-avx512f"></span><tt class="descname">-mavx512f</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-avx512f</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mavx512f" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mavx512ifma">
+<span id="cmdoption-clang-mno-avx512ifma"></span><tt class="descname">-mavx512ifma</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-avx512ifma</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mavx512ifma" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mavx512pf">
+<span id="cmdoption-clang-mno-avx512pf"></span><tt class="descname">-mavx512pf</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-avx512pf</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mavx512pf" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mavx512vbmi">
+<span id="cmdoption-clang-mno-avx512vbmi"></span><tt class="descname">-mavx512vbmi</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-avx512vbmi</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mavx512vbmi" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mavx512vl">
+<span id="cmdoption-clang-mno-avx512vl"></span><tt class="descname">-mavx512vl</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-avx512vl</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mavx512vl" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mavx512vpopcntdq">
+<span id="cmdoption-clang-mno-avx512vpopcntdq"></span><tt class="descname">-mavx512vpopcntdq</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-avx512vpopcntdq</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mavx512vpopcntdq" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mbmi">
+<span id="cmdoption-clang-mno-bmi"></span><tt class="descname">-mbmi</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-bmi</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mbmi" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mbmi2">
+<span id="cmdoption-clang-mno-bmi2"></span><tt class="descname">-mbmi2</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-bmi2</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mbmi2" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mclflushopt">
+<span id="cmdoption-clang-mno-clflushopt"></span><tt class="descname">-mclflushopt</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-clflushopt</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mclflushopt" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mclwb">
+<span id="cmdoption-clang-mno-clwb"></span><tt class="descname">-mclwb</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-clwb</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mclwb" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mclzero">
+<span id="cmdoption-clang-mno-clzero"></span><tt class="descname">-mclzero</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-clzero</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mclzero" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mcx16">
+<span id="cmdoption-clang-mno-cx16"></span><tt class="descname">-mcx16</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-cx16</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mcx16" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mf16c">
+<span id="cmdoption-clang-mno-f16c"></span><tt class="descname">-mf16c</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-f16c</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mf16c" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mfma">
+<span id="cmdoption-clang-mno-fma"></span><tt class="descname">-mfma</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-fma</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mfma" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mfma4">
+<span id="cmdoption-clang-mno-fma4"></span><tt class="descname">-mfma4</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-fma4</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mfma4" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mfsgsbase">
+<span id="cmdoption-clang-mno-fsgsbase"></span><tt class="descname">-mfsgsbase</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-fsgsbase</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mfsgsbase" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mfxsr">
+<span id="cmdoption-clang-mno-fxsr"></span><tt class="descname">-mfxsr</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-fxsr</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mfxsr" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mlwp">
+<span id="cmdoption-clang-mno-lwp"></span><tt class="descname">-mlwp</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-lwp</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mlwp" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mlzcnt">
+<span id="cmdoption-clang-mno-lzcnt"></span><tt class="descname">-mlzcnt</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-lzcnt</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mlzcnt" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mmmx">
+<span id="cmdoption-clang-mno-mmx"></span><tt class="descname">-mmmx</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-mmx</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mmmx" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mmovbe">
+<span id="cmdoption-clang-mno-movbe"></span><tt class="descname">-mmovbe</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-movbe</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mmovbe" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mmpx">
+<span id="cmdoption-clang-mno-mpx"></span><tt class="descname">-mmpx</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-mpx</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mmpx" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mmwaitx">
+<span id="cmdoption-clang-mno-mwaitx"></span><tt class="descname">-mmwaitx</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-mwaitx</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mmwaitx" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mpclmul">
+<span id="cmdoption-clang-mno-pclmul"></span><tt class="descname">-mpclmul</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-pclmul</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mpclmul" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mpku">
+<span id="cmdoption-clang-mno-pku"></span><tt class="descname">-mpku</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-pku</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mpku" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mpopcnt">
+<span id="cmdoption-clang-mno-popcnt"></span><tt class="descname">-mpopcnt</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-popcnt</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mpopcnt" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mprefetchwt1">
+<span id="cmdoption-clang-mno-prefetchwt1"></span><tt class="descname">-mprefetchwt1</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-prefetchwt1</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mprefetchwt1" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mprfchw">
+<span id="cmdoption-clang-mno-prfchw"></span><tt class="descname">-mprfchw</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-prfchw</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mprfchw" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mrdrnd">
+<span id="cmdoption-clang-mno-rdrnd"></span><tt class="descname">-mrdrnd</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-rdrnd</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mrdrnd" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mrdseed">
+<span id="cmdoption-clang-mno-rdseed"></span><tt class="descname">-mrdseed</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-rdseed</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mrdseed" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mrtm">
+<span id="cmdoption-clang-mno-rtm"></span><tt class="descname">-mrtm</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-rtm</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mrtm" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-msgx">
+<span id="cmdoption-clang-mno-sgx"></span><tt class="descname">-msgx</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-sgx</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-msgx" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-msha">
+<span id="cmdoption-clang-mno-sha"></span><tt class="descname">-msha</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-sha</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-msha" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-msse">
+<span id="cmdoption-clang-mno-sse"></span><tt class="descname">-msse</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-sse</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-msse" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-msse2">
+<span id="cmdoption-clang-mno-sse2"></span><tt class="descname">-msse2</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-sse2</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-msse2" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-msse3">
+<span id="cmdoption-clang-mno-sse3"></span><tt class="descname">-msse3</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-sse3</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-msse3" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-msse4">
+<span id="cmdoption-clang-mno-sse4"></span><tt class="descname">-msse4</tt><tt class="descclassname">.1</tt><tt class="descclassname">, </tt><tt class="descname">-mno-sse4</tt><tt class="descclassname">.1</tt><a class="headerlink" href="#cmdoption-clang-msse4" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang1-msse4">
+<span id="cmdoption-clang1-mno-sse4"></span><span id="cmdoption-clang1-msse4"></span><tt class="descname">-msse4</tt><tt class="descclassname">.2</tt><tt class="descclassname">, </tt><tt class="descname">-mno-sse4</tt><tt class="descclassname">.2</tt><tt class="descclassname">, </tt><tt class="descname">-msse4</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang1-msse4" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-msse4a">
+<span id="cmdoption-clang-mno-sse4a"></span><tt class="descname">-msse4a</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-sse4a</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-msse4a" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mssse3">
+<span id="cmdoption-clang-mno-ssse3"></span><tt class="descname">-mssse3</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-ssse3</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mssse3" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mtbm">
+<span id="cmdoption-clang-mno-tbm"></span><tt class="descname">-mtbm</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-tbm</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mtbm" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mx87">
+<span id="cmdoption-clang-m80387"></span><span id="cmdoption-clang-mno-x87"></span><tt class="descname">-mx87</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-m80387</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-x87</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mx87" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mxop">
+<span id="cmdoption-clang-mno-xop"></span><tt class="descname">-mxop</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-xop</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mxop" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mxsave">
+<span id="cmdoption-clang-mno-xsave"></span><tt class="descname">-mxsave</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-xsave</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mxsave" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mxsavec">
+<span id="cmdoption-clang-mno-xsavec"></span><tt class="descname">-mxsavec</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-xsavec</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mxsavec" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mxsaveopt">
+<span id="cmdoption-clang-mno-xsaveopt"></span><tt class="descname">-mxsaveopt</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-xsaveopt</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mxsaveopt" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-mxsaves">
+<span id="cmdoption-clang-mno-xsaves"></span><tt class="descname">-mxsaves</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-mno-xsaves</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-mxsaves" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+</div>
+</div>
+<div class="section" id="optimization-level">
+<h3><a class="toc-backref" href="#id19">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">
+<span id="cmdoption-clang-O"></span><span id="cmdoption-clang--optimize"></span><span id="cmdoption-clang--optimize"></span><tt class="descname">-O</tt><tt class="descclassname"><arg></tt><tt class="descclassname">, </tt><tt class="descname">-O</tt><tt class="descclassname"> (equivalent to -O2)</tt><tt class="descclassname">, </tt><tt class="descname">--optimize</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--optimize</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-O" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-Ofast">
+<tt class="descname">-Ofast</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-Ofast" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+</div>
+<div class="section" id="debug-information-generation">
+<h3><a class="toc-backref" href="#id20">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="#id21">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">
+<span id="cmdoption-clang--debug"></span><span id="cmdoption-clang--debug"></span><tt class="descname">-g</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--debug</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">--debug</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-g" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate source-level debug information</p>
+<dl class="option">
+<dt id="cmdoption-clang-gdwarf-2">
+<tt class="descname">-gdwarf-2</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gdwarf-2" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate source-level debug information with dwarf version 2</p>
+<dl class="option">
+<dt id="cmdoption-clang-gdwarf-3">
+<tt class="descname">-gdwarf-3</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gdwarf-3" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate source-level debug information with dwarf version 3</p>
+<dl class="option">
+<dt id="cmdoption-clang-gdwarf-4">
+<span id="cmdoption-clang-gdwarf"></span><tt class="descname">-gdwarf-4</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-gdwarf</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gdwarf-4" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate source-level debug information with dwarf version 4</p>
+<dl class="option">
+<dt id="cmdoption-clang-gdwarf-5">
+<tt class="descname">-gdwarf-5</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gdwarf-5" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate source-level debug information with dwarf version 5</p>
+<dl class="option">
+<dt id="cmdoption-clang-gfull">
+<tt class="descname">-gfull</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gfull" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-gused">
+<tt class="descname">-gused</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gused" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<div class="section" id="debug-level">
+<h5><a class="toc-backref" href="#id22">Debug level</a><a class="headerlink" href="#debug-level" title="Permalink to this headline">Â¶</a></h5>
+<dl class="option">
+<dt id="cmdoption-clang-g0">
+<tt class="descname">-g0</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-g0" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-g2">
+<tt class="descname">-g2</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-g2" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-g3">
+<tt class="descname">-g3</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-g3" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ggdb0">
+<tt class="descname">-ggdb0</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ggdb0" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ggdb1">
+<tt class="descname">-ggdb1</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ggdb1" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ggdb2">
+<tt class="descname">-ggdb2</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ggdb2" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ggdb3">
+<tt class="descname">-ggdb3</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ggdb3" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-gline-tables-only">
+<span id="cmdoption-clang-g1"></span><span id="cmdoption-clang-gmlt"></span><tt class="descname">-gline-tables-only</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-g1</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-gmlt</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gline-tables-only" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Emit debug line number tables only</p>
+<dl class="option">
+<dt id="cmdoption-clang-gmodules">
+<tt class="descname">-gmodules</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gmodules" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Generate debug info with external references to clang modules or precompiled headers</p>
+</div>
+<div class="section" id="debugger-to-tune-debug-information-for">
+<h5><a class="toc-backref" href="#id23">Debugger to tune debug information for</a><a class="headerlink" href="#debugger-to-tune-debug-information-for" title="Permalink to this headline">Â¶</a></h5>
+<dl class="option">
+<dt id="cmdoption-clang-ggdb">
+<tt class="descname">-ggdb</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ggdb" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-glldb">
+<tt class="descname">-glldb</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-glldb" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-gsce">
+<tt class="descname">-gsce</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gsce" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+</div>
+</div>
+<div class="section" id="debug-information-flags">
+<h4><a class="toc-backref" href="#id24">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">
+<span id="cmdoption-clang-gno-column-info"></span><tt class="descname">-gcolumn-info</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-gno-column-info</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gcolumn-info" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-gdwarf-aranges">
+<tt class="descname">-gdwarf-aranges</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gdwarf-aranges" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ggnu-pubnames">
+<tt class="descname">-ggnu-pubnames</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ggnu-pubnames" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-grecord-gcc-switches">
+<span id="cmdoption-clang-gno-record-gcc-switches"></span><tt class="descname">-grecord-gcc-switches</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-gno-record-gcc-switches</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-grecord-gcc-switches" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-gsplit-dwarf">
+<tt class="descname">-gsplit-dwarf</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gsplit-dwarf" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-gstrict-dwarf">
+<span id="cmdoption-clang-gno-strict-dwarf"></span><tt class="descname">-gstrict-dwarf</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-gno-strict-dwarf</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gstrict-dwarf" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-gz">
+<tt class="descname">-gz</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-gz" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>DWARF debug sections compression type</p>
+<dl class="option">
+<dt id="cmdoption-clang1-gz">
+<tt class="descname">-gz</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang1-gz" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>DWARF debug sections compression type</p>
+</div>
+</div>
+</div>
+<div class="section" id="static-analyzer-flags">
+<h2><a class="toc-backref" href="#id25">Static analyzer flags</a><a class="headerlink" href="#static-analyzer-flags" title="Permalink to this headline">Â¶</a></h2>
+<p>Flags controlling the behavior of the Clang Static Analyzer.</p>
+<dl class="option">
+<dt id="cmdoption-clang-Xanalyzer">
+<tt class="descname">-Xanalyzer</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-Xanalyzer" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Pass <arg> to the static analyzer</p>
+</div>
+<div class="section" id="fortran-compilation-flags">
+<h2><a class="toc-backref" href="#id26">Fortran compilation flags</a><a class="headerlink" href="#fortran-compilation-flags" title="Permalink to this headline">Â¶</a></h2>
+<p>Flags that will be passed onto the <tt class="docutils literal"><span class="pre">gfortran</span></tt> compiler when Clang is given
+a Fortran input.</p>
+<dl class="option">
+<dt id="cmdoption-clang-A">
+<span id="cmdoption-clang--assert"></span><span id="cmdoption-clang--assert"></span><tt class="descname">-A</tt><tt class="descclassname"><arg></tt><tt class="descclassname">, </tt><tt class="descname">--assert</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--assert</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-A" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-A-">
+<tt class="descname">-A-</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-A-" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-J">
+<tt class="descname">-J</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-J" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-cpp">
+<tt class="descname">-cpp</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-cpp" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-faggressive-function-elimination">
+<span id="cmdoption-clang-fno-aggressive-function-elimination"></span><tt class="descname">-faggressive-function-elimination</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-aggressive-function-elimination</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-faggressive-function-elimination" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-falign-commons">
+<span id="cmdoption-clang-fno-align-commons"></span><tt class="descname">-falign-commons</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-align-commons</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-falign-commons" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fall-intrinsics">
+<span id="cmdoption-clang-fno-all-intrinsics"></span><tt class="descname">-fall-intrinsics</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-all-intrinsics</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fall-intrinsics" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fautomatic">
+<span id="cmdoption-clang-fno-automatic"></span><tt class="descname">-fautomatic</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-automatic</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fautomatic" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fbackslash">
+<span id="cmdoption-clang-fno-backslash"></span><tt class="descname">-fbackslash</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-backslash</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fbackslash" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fbacktrace">
+<span id="cmdoption-clang-fno-backtrace"></span><tt class="descname">-fbacktrace</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-backtrace</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fbacktrace" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fblas-matmul-limit">
+<tt class="descname">-fblas-matmul-limit</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fblas-matmul-limit" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fbounds-check">
+<span id="cmdoption-clang-fno-bounds-check"></span><tt class="descname">-fbounds-check</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-bounds-check</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fbounds-check" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fcheck-array-temporaries">
+<span id="cmdoption-clang-fno-check-array-temporaries"></span><tt class="descname">-fcheck-array-temporaries</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-check-array-temporaries</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fcheck-array-temporaries" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fcheck">
+<tt class="descname">-fcheck</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fcheck" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fcoarray">
+<tt class="descname">-fcoarray</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fcoarray" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fconvert">
+<tt class="descname">-fconvert</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fconvert" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fcray-pointer">
+<span id="cmdoption-clang-fno-cray-pointer"></span><tt class="descname">-fcray-pointer</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-cray-pointer</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fcray-pointer" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fd-lines-as-code">
+<span id="cmdoption-clang-fno-d-lines-as-code"></span><tt class="descname">-fd-lines-as-code</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-d-lines-as-code</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fd-lines-as-code" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fd-lines-as-comments">
+<span id="cmdoption-clang-fno-d-lines-as-comments"></span><tt class="descname">-fd-lines-as-comments</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-d-lines-as-comments</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fd-lines-as-comments" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdefault-double-8">
+<span id="cmdoption-clang-fno-default-double-8"></span><tt class="descname">-fdefault-double-8</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-default-double-8</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdefault-double-8" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdefault-integer-8">
+<span id="cmdoption-clang-fno-default-integer-8"></span><tt class="descname">-fdefault-integer-8</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-default-integer-8</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdefault-integer-8" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdefault-real-8">
+<span id="cmdoption-clang-fno-default-real-8"></span><tt class="descname">-fdefault-real-8</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-default-real-8</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdefault-real-8" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdollar-ok">
+<span id="cmdoption-clang-fno-dollar-ok"></span><tt class="descname">-fdollar-ok</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-dollar-ok</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdollar-ok" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdump-fortran-optimized">
+<span id="cmdoption-clang-fno-dump-fortran-optimized"></span><tt class="descname">-fdump-fortran-optimized</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-dump-fortran-optimized</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdump-fortran-optimized" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdump-fortran-original">
+<span id="cmdoption-clang-fno-dump-fortran-original"></span><tt class="descname">-fdump-fortran-original</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-dump-fortran-original</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdump-fortran-original" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fdump-parse-tree">
+<span id="cmdoption-clang-fno-dump-parse-tree"></span><tt class="descname">-fdump-parse-tree</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-dump-parse-tree</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fdump-parse-tree" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fexternal-blas">
+<span id="cmdoption-clang-fno-external-blas"></span><tt class="descname">-fexternal-blas</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-external-blas</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fexternal-blas" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ff2c">
+<span id="cmdoption-clang-fno-f2c"></span><tt class="descname">-ff2c</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-f2c</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ff2c" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ffixed-form">
+<span id="cmdoption-clang-fno-fixed-form"></span><tt class="descname">-ffixed-form</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-fixed-form</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ffixed-form" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ffixed-line-length-">
+<tt class="descname">-ffixed-line-length-</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-ffixed-line-length-" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ffpe-trap">
+<tt class="descname">-ffpe-trap</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-ffpe-trap" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ffree-form">
+<span id="cmdoption-clang-fno-free-form"></span><tt class="descname">-ffree-form</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-free-form</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ffree-form" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ffree-line-length-">
+<tt class="descname">-ffree-line-length-</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-ffree-line-length-" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-ffrontend-optimize">
+<span id="cmdoption-clang-fno-frontend-optimize"></span><tt class="descname">-ffrontend-optimize</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-frontend-optimize</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-ffrontend-optimize" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fimplicit-none">
+<span id="cmdoption-clang-fno-implicit-none"></span><tt class="descname">-fimplicit-none</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-implicit-none</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fimplicit-none" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-finit-character">
+<tt class="descname">-finit-character</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-finit-character" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-finit-integer">
+<tt class="descname">-finit-integer</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-finit-integer" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-finit-local-zero">
+<span id="cmdoption-clang-fno-init-local-zero"></span><tt class="descname">-finit-local-zero</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-init-local-zero</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-finit-local-zero" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-finit-logical">
+<tt class="descname">-finit-logical</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-finit-logical" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-finit-real">
+<tt class="descname">-finit-real</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-finit-real" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-finteger-4-integer-8">
+<span id="cmdoption-clang-fno-integer-4-integer-8"></span><tt class="descname">-finteger-4-integer-8</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-integer-4-integer-8</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-finteger-4-integer-8" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fintrinsic-modules-path">
+<span id="cmdoption-clang-fno-intrinsic-modules-path"></span><tt class="descname">-fintrinsic-modules-path</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-intrinsic-modules-path</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fintrinsic-modules-path" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fmax-array-constructor">
+<tt class="descname">-fmax-array-constructor</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fmax-array-constructor" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fmax-errors">
+<tt class="descname">-fmax-errors</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fmax-errors" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fmax-identifier-length">
+<span id="cmdoption-clang-fno-max-identifier-length"></span><tt class="descname">-fmax-identifier-length</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-max-identifier-length</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmax-identifier-length" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fmax-stack-var-size">
+<tt class="descname">-fmax-stack-var-size</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fmax-stack-var-size" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fmax-subrecord-length">
+<tt class="descname">-fmax-subrecord-length</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-fmax-subrecord-length" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fmodule-private">
+<span id="cmdoption-clang-fno-module-private"></span><tt class="descname">-fmodule-private</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-module-private</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fmodule-private" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fpack-derived">
+<span id="cmdoption-clang-fno-pack-derived"></span><tt class="descname">-fpack-derived</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-pack-derived</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fpack-derived" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fprotect-parens">
+<span id="cmdoption-clang-fno-protect-parens"></span><tt class="descname">-fprotect-parens</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-protect-parens</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fprotect-parens" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-frange-check">
+<span id="cmdoption-clang-fno-range-check"></span><tt class="descname">-frange-check</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-range-check</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-frange-check" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-freal-4-real-10">
+<span id="cmdoption-clang-fno-real-4-real-10"></span><tt class="descname">-freal-4-real-10</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-real-4-real-10</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-freal-4-real-10" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-freal-4-real-16">
+<span id="cmdoption-clang-fno-real-4-real-16"></span><tt class="descname">-freal-4-real-16</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-real-4-real-16</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-freal-4-real-16" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-freal-4-real-8">
+<span id="cmdoption-clang-fno-real-4-real-8"></span><tt class="descname">-freal-4-real-8</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-real-4-real-8</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-freal-4-real-8" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-freal-8-real-10">
+<span id="cmdoption-clang-fno-real-8-real-10"></span><tt class="descname">-freal-8-real-10</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-real-8-real-10</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-freal-8-real-10" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-freal-8-real-16">
+<span id="cmdoption-clang-fno-real-8-real-16"></span><tt class="descname">-freal-8-real-16</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-real-8-real-16</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-freal-8-real-16" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-freal-8-real-4">
+<span id="cmdoption-clang-fno-real-8-real-4"></span><tt class="descname">-freal-8-real-4</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-real-8-real-4</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-freal-8-real-4" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-frealloc-lhs">
+<span id="cmdoption-clang-fno-realloc-lhs"></span><tt class="descname">-frealloc-lhs</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-realloc-lhs</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-frealloc-lhs" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-frecord-marker">
+<tt class="descname">-frecord-marker</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-frecord-marker" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-frecursive">
+<span id="cmdoption-clang-fno-recursive"></span><tt class="descname">-frecursive</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-recursive</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-frecursive" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-frepack-arrays">
+<span id="cmdoption-clang-fno-repack-arrays"></span><tt class="descname">-frepack-arrays</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-repack-arrays</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-frepack-arrays" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fsecond-underscore">
+<span id="cmdoption-clang-fno-second-underscore"></span><tt class="descname">-fsecond-underscore</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-second-underscore</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsecond-underscore" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fsign-zero">
+<span id="cmdoption-clang-fno-sign-zero"></span><tt class="descname">-fsign-zero</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-sign-zero</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fsign-zero" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fstack-arrays">
+<span id="cmdoption-clang-fno-stack-arrays"></span><tt class="descname">-fstack-arrays</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-stack-arrays</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fstack-arrays" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-funderscoring">
+<span id="cmdoption-clang-fno-underscoring"></span><tt class="descname">-funderscoring</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-underscoring</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-funderscoring" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-fwhole-file">
+<span id="cmdoption-clang-fno-whole-file"></span><tt class="descname">-fwhole-file</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-whole-file</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-fwhole-file" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-nocpp">
+<tt class="descname">-nocpp</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-nocpp" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-static-libgfortran">
+<tt class="descname">-static-libgfortran</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-static-libgfortran" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+</div>
+<div class="section" id="linker-flags">
+<h2><a class="toc-backref" href="#id27">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">
+<span id="cmdoption-clang--library-directory"></span><span id="cmdoption-clang--library-directory"></span><tt class="descname">-L</tt><tt class="descclassname"><dir></tt><tt class="descclassname">, </tt><tt class="descname">--library-directory</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--library-directory</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-L" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Add directory to library search path</p>
+<dl class="option">
+<dt id="cmdoption-clang-Mach">
+<tt class="descname">-Mach</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-Mach" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-T">
+<tt class="descname">-T</tt><tt class="descclassname"><script></tt><a class="headerlink" href="#cmdoption-clang-T" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Specify <script> as linker script</p>
+<dl class="option">
+<dt id="cmdoption-clang-Tbss">
+<tt class="descname">-Tbss</tt><tt class="descclassname"><addr></tt><a class="headerlink" href="#cmdoption-clang-Tbss" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Set starting address of BSS to <addr></p>
+<dl class="option">
+<dt id="cmdoption-clang-Tdata">
+<tt class="descname">-Tdata</tt><tt class="descclassname"><addr></tt><a class="headerlink" href="#cmdoption-clang-Tdata" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Set starting address of BSS to <addr></p>
+<dl class="option">
+<dt id="cmdoption-clang-Ttext">
+<tt class="descname">-Ttext</tt><tt class="descclassname"><addr></tt><a class="headerlink" href="#cmdoption-clang-Ttext" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Set starting address of BSS to <addr></p>
+<dl class="option">
+<dt id="cmdoption-clang-Wl">
+<tt class="descname">-Wl</tt><tt class="descclassname">,<arg>,<arg2>...</tt><a class="headerlink" href="#cmdoption-clang-Wl" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Pass the comma separated arguments in <arg> to the linker</p>
+<dl class="option">
+<dt id="cmdoption-clang-X">
+<tt class="descname">-X</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-X" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-Xlinker">
+<span id="cmdoption-clang--for-linker"></span><span id="cmdoption-clang--for-linker"></span><tt class="descname">-Xlinker</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--for-linker</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--for-linker</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-Xlinker" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Pass <arg> to the linker</p>
+<dl class="option">
+<dt id="cmdoption-clang1-Z">
+<tt class="descname">-Z</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang1-Z" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-e">
+<span id="cmdoption-clang--entry"></span><tt class="descname">-e</tt><tt class="descclassname"><arg></tt><tt class="descclassname">, </tt><tt class="descname">--entry</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-e" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-filelist">
+<tt class="descname">-filelist</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-filelist" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-l">
+<tt class="descname">-l</tt><tt class="descclassname"><arg></tt><a class="headerlink" href="#cmdoption-clang-l" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-r">
+<tt class="descname">-r</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-r" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-rpath">
+<tt class="descname">-rpath</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-rpath" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-s">
+<tt class="descname">-s</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-s" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-t">
+<tt class="descname">-t</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-t" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-u">
+<span id="cmdoption-clang--force-link"></span><span id="cmdoption-clang--force-link"></span><tt class="descname">-u</tt><tt class="descclassname"><arg></tt><tt class="descclassname">, </tt><tt class="descname">--force-link</tt><tt class="descclassname"> <arg></tt><tt class="descclassname">, </tt><tt class="descname">--force-link</tt><tt class="descclassname">=<arg></tt><a class="headerlink" href="#cmdoption-clang-u" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-undef">
+<tt class="descname">-undef</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-undef" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>undef all system defines</p>
+<dl class="option">
+<dt id="cmdoption-clang-undefined">
+<span id="cmdoption-clang--no-undefined"></span><tt class="descname">-undefined</tt><tt class="descclassname"><arg></tt><tt class="descclassname">, </tt><tt class="descname">--no-undefined</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-clang-undefined" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-clang-z">
+<tt class="descname">-z</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-clang-z" title="Permalink to this definition">Â¶</a></dt>
+<dd></dd></dl>
+
+<p>Pass -z <arg> to the linker</p>
+</div>
+</div>
+
+
+      </div>
+      <div class="bottomnav">
+      
+        <p>
+        Â«  <a href="AutomaticReferenceCounting.html">Objective-C Automatic Reference Counting (ARC)</a>
+          ::  
+        <a class="uplink" href="index.html">Contents</a>
+          ::  
+        <a href="AttributeReference.html">Attributes in Clang</a>  Â»
+        </p>
+
+      </div>
+
+    <div class="footer">
+        © Copyright 2007-2017, The Clang Team.
+      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.2.2.
+    </div>
+  </body>
+</html>
\ No newline at end of file

Added: www-releases/trunk/5.0.0/tools/clang/docs/ClangFormat.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/5.0.0/tools/clang/docs/ClangFormat.html?rev=312731&view=auto
==============================================================================
--- www-releases/trunk/5.0.0/tools/clang/docs/ClangFormat.html (added)
+++ www-releases/trunk/5.0.0/tools/clang/docs/ClangFormat.html Thu Sep  7 10:47:16 2017
@@ -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 5 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:     '5',
+        COLLAPSE_INDEX: false,
+        FILE_SUFFIX: '.html',
+        HAS_SOURCE:  true
+      };
+    </script>
+    <script type="text/javascript" src="_static/jquery.js"></script>
+    <script type="text/javascript" src="_static/underscore.js"></script>
+    <script type="text/javascript" src="_static/doctools.js"></script>
+    <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+    <link rel="top" title="Clang 5 documentation" href="index.html" />
+    <link rel="next" title="Clang-Format Style Options" href="ClangFormatStyleOptions.html" />
+    <link rel="prev" title="ClangCheck" href="ClangCheck.html" /> 
+  </head>
+  <body>
+      <div class="header"><h1 class="heading"><a href="index.html">
+          <span>Clang 5 documentation</span></a></h1>
+        <h2 class="heading"><span>ClangFormat</span></h2>
+      </div>
+      <div class="topnav">
+      
+        <p>
+        Â«  <a href="ClangCheck.html">ClangCheck</a>
+          ::  
+        <a class="uplink" href="index.html">Contents</a>
+          ::  
+        <a href="ClangFormatStyleOptions.html">Clang-Format Style Options</a>  Â»
+        </p>
+
+      </div>
+      <div class="content">
+        
+        
+  <div class="section" id="clangformat">
+<h1>ClangFormat<a class="headerlink" href="#clangformat" title="Permalink to this headline">Â¶</a></h1>
+<p><cite>ClangFormat</cite> describes a set of tools that are built on top of
+<a class="reference internal" href="LibFormat.html"><em>LibFormat</em></a>. It can support your workflow in a variety of ways including a
+standalone tool and editor integrations.</p>
+<div class="section" id="standalone-tool">
+<h2>Standalone Tool<a class="headerlink" href="#standalone-tool" title="Permalink to this headline">Â¶</a></h2>
+<p><strong class="program">clang-format</strong> is located in <cite>clang/tools/clang-format</cite> and can be used
+to format C/C++/Obj-C 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">Generic Options:</span>
+
+<span class="go">  -help                     - Display available options (-help-hidden for more)</span>
+<span class="go">  -help-list                - Display list of available options (-help-list-hidden for more)</span>
+<span class="go">  -version                  - Display the version of this program</span>
+</pre></div>
+</div>
+<p>When the desired code formatting style is different from the available options,
+the style can be customized using the <tt class="docutils literal"><span class="pre">-style="{key:</span> <span class="pre">value,</span> <span class="pre">...}"</span></tt> option or
+by putting your style configuration in the <tt class="docutils literal"><span class="pre">.clang-format</span></tt> or <tt class="docutils literal"><span class="pre">_clang-format</span></tt>
+file in your project’s directory and using <tt class="docutils literal"><span class="pre">clang-format</span> <span class="pre">-style=file</span></tt>.</p>
+<p>An easy way to create the <tt class="docutils literal"><span class="pre">.clang-format</span></tt> file is:</p>
+<div class="highlight-console"><div class="highlight"><pre><span></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"><em>Clang-Format Style Options</em></a>.</p>
+</div>
+<div class="section" id="vim-integration">
+<h2>Vim Integration<a class="headerlink" href="#vim-integration" title="Permalink to this headline">Â¶</a></h2>
+<p>There is an integration for <strong class="program">vim</strong> which lets you run the
+<strong class="program">clang-format</strong> standalone tool on your current buffer, optionally
+selecting regions to reformat. The integration has the form of a <cite>python</cite>-file
+which can be found under <cite>clang/tools/clang-format/clang-format.py</cite>.</p>
+<p>This can be integrated by adding the following to your <cite>.vimrc</cite>:</p>
+<div class="highlight-vim"><div class="highlight"><pre><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">
+      
+        <p>
+        Â«  <a href="ClangCheck.html">ClangCheck</a>
+          ::  
+        <a class="uplink" href="index.html">Contents</a>
+          ::  
+        <a href="ClangFormatStyleOptions.html">Clang-Format Style Options</a>  Â»
+        </p>
+
+      </div>
+
+    <div class="footer">
+        © Copyright 2007-2017, The Clang Team.
+      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.2.2.
+    </div>
+  </body>
+</html>
\ No newline at end of file

Added: www-releases/trunk/5.0.0/tools/clang/docs/ClangFormatStyleOptions.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/5.0.0/tools/clang/docs/ClangFormatStyleOptions.html?rev=312731&view=auto
==============================================================================
--- www-releases/trunk/5.0.0/tools/clang/docs/ClangFormatStyleOptions.html (added)
+++ www-releases/trunk/5.0.0/tools/clang/docs/ClangFormatStyleOptions.html Thu Sep  7 10:47:16 2017
@@ -0,0 +1,1662 @@
+<!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 5 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:     '5',
+        COLLAPSE_INDEX: false,
+        FILE_SUFFIX: '.html',
+        HAS_SOURCE:  true
+      };
+    </script>
+    <script type="text/javascript" src="_static/jquery.js"></script>
+    <script type="text/javascript" src="_static/underscore.js"></script>
+    <script type="text/javascript" src="_static/doctools.js"></script>
+    <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+    <link rel="top" title="Clang 5 documentation" href="index.html" />
+    <link rel="next" title="âClangâ CFE Internals Manual" href="InternalsManual.html" />
+    <link rel="prev" title="ClangFormat" href="ClangFormat.html" /> 
+  </head>
+  <body>
+      <div class="header"><h1 class="heading"><a href="index.html">
+          <span>Clang 5 documentation</span></a></h1>
+        <h2 class="heading"><span>Clang-Format Style Options</span></h2>
+      </div>
+      <div class="topnav">
+      
+        <p>
+        Â«  <a href="ClangFormat.html">ClangFormat</a>
+          ::  
+        <a class="uplink" href="index.html">Contents</a>
+          ::  
+        <a href="InternalsManual.html">“Clang” CFE Internals Manual</a>  Â»
+        </p>
+
+      </div>
+      <div class="content">
+        
+        
+  <div class="section" id="clang-format-style-options">
+<h1>Clang-Format Style Options<a class="headerlink" href="#clang-format-style-options" title="Permalink to this headline">Â¶</a></h1>
+<p><a class="reference internal" href=""><em>Clang-Format Style Options</em></a> describes configurable formatting style options
+supported by <a class="reference internal" href="LibFormat.html"><em>LibFormat</em></a> and <a class="reference internal" href="ClangFormat.html"><em>ClangFormat</em></a>.</p>
+<p>When using <strong class="program">clang-format</strong> command line utility or
+<tt class="docutils literal"><span class="pre">clang::format::reformat(...)</span></tt> functions from code, one can either use one of
+the predefined styles (LLVM, Google, Chromium, Mozilla, WebKit) or create a
+custom style by configuring specific style options.</p>
+<div class="section" id="configuring-style-with-clang-format">
+<h2>Configuring Style with clang-format<a class="headerlink" href="#configuring-style-with-clang-format" title="Permalink to this headline">Â¶</a></h2>
+<p><strong class="program">clang-format</strong> supports two ways to provide custom style options:
+directly specify style configuration in the <tt class="docutils literal"><span class="pre">-style=</span></tt> command line option or
+use <tt class="docutils literal"><span class="pre">-style=file</span></tt> and put style configuration in the <tt class="docutils literal"><span class="pre">.clang-format</span></tt> or
+<tt class="docutils literal"><span class="pre">_clang-format</span></tt> file in the project directory.</p>
+<p>When using <tt class="docutils literal"><span class="pre">-style=file</span></tt>, <strong class="program">clang-format</strong> for each input file will
+try to find the <tt class="docutils literal"><span class="pre">.clang-format</span></tt> file located in the closest parent directory
+of the input file. When the standard input is used, the search is started from
+the current directory.</p>
+<p>The <tt class="docutils literal"><span class="pre">.clang-format</span></tt> file uses YAML format:</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span></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
+<tt class="docutils literal"><span class="pre">Language:</span></tt> parameter denoting the programming language this section of the
+configuration is targeted at. See the description of the <strong>Language</strong> option
+below for the list of supported languages. The first section may have no
+language set, it will set the default style options for all lanugages.
+Configuration sections for specific language will override options set in the
+default section.</p>
+<p>When <strong class="program">clang-format</strong> formats a file, it auto-detects the language using
+the file name. When formatting standard input or a file that doesn’t have the
+extension corresponding to its language, <tt class="docutils literal"><span class="pre">-assume-filename=</span></tt> option can be
+used to override the file name <strong class="program">clang-format</strong> uses to detect the
+language.</p>
+<p>An example of a configuration file for multiple languages:</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">.clang-format</span></tt> file containing all configuration
+options of a certain predefined style is:</p>
+<div class="highlight-console"><div class="highlight"><pre><span></span><span class="go">clang-format -style=llvm -dump-config > .clang-format</span>
+</pre></div>
+</div>
+<p>When specifying configuration in the <tt class="docutils literal"><span class="pre">-style=</span></tt> option, the same configuration
+is applied for all input files. The format of the configuration is:</p>
+<div class="highlight-console"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">//</span> <span class="pre">clang-format</span> <span class="pre">off</span></tt> or
+<tt class="docutils literal"><span class="pre">/*</span> <span class="pre">clang-format</span> <span class="pre">off</span> <span class="pre">*/</span></tt> up to a comment <tt class="docutils literal"><span class="pre">//</span> <span class="pre">clang-format</span> <span class="pre">on</span></tt> or
+<tt class="docutils literal"><span class="pre">/*</span> <span class="pre">clang-format</span> <span class="pre">on</span> <span class="pre">*/</span></tt> will not be formatted. The comments themselves
+will be formatted (aligned) normally.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">clang::format::reformat(...)</span></tt> functions, the format is specified
+by supplying the <a class="reference external" href="http://clang.llvm.org/doxygen/structclang_1_1format_1_1FormatStyle.html">clang::format::FormatStyle</a>
+structure.</p>
+</div>
+<div class="section" id="configurable-format-style-options">
+<h2>Configurable Format Style Options<a class="headerlink" href="#configurable-format-style-options" title="Permalink to this headline">Â¶</a></h2>
+<p>This section lists the supported style options. Value type is specified for
+each option. For enumeration types possible values are specified both as a C++
+enumeration member (with a prefix, e.g. <tt class="docutils literal"><span class="pre">LS_Auto</span></tt>), and as a value usable in
+the configuration (without a prefix: <tt class="docutils literal"><span class="pre">Auto</span></tt>).</p>
+<dl class="docutils">
+<dt><strong>BasedOnStyle</strong> (<tt class="docutils literal"><span class="pre">string</span></tt>)</dt>
+<dd><p class="first">The style used for all options not specifically set in the configuration.</p>
+<p>This option is supported only in the <strong class="program">clang-format</strong> configuration
+(both within <tt class="docutils literal"><span class="pre">-style='{...}'</span></tt> and the <tt class="docutils literal"><span class="pre">.clang-format</span></tt> file).</p>
+<p>Possible values:</p>
+<ul class="last simple">
+<li><tt class="docutils literal"><span class="pre">LLVM</span></tt>
+A style complying with the <a class="reference external" href="http://llvm.org/docs/CodingStandards.html">LLVM coding standards</a></li>
+<li><tt class="docutils literal"><span class="pre">Google</span></tt>
+A style complying with <a class="reference external" href="http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml">Google’s C++ style guide</a></li>
+<li><tt class="docutils literal"><span class="pre">Chromium</span></tt>
+A style complying with <a class="reference external" href="http://www.chromium.org/developers/coding-style">Chromium’s style guide</a></li>
+<li><tt class="docutils literal"><span class="pre">Mozilla</span></tt>
+A style complying with <a class="reference external" href="https://developer.mozilla.org/en-US/docs/Developer_Guide/Coding_Style">Mozilla’s style guide</a></li>
+<li><tt class="docutils literal"><span class="pre">WebKit</span></tt>
+A style complying with <a class="reference external" href="http://www.webkit.org/coding/coding-style.html">WebKit’s style guide</a></li>
+</ul>
+</dd>
+</dl>
+<dl class="docutils">
+<dt><strong>AccessModifierOffset</strong> (<tt class="docutils literal"><span class="pre">int</span></tt>)</dt>
+<dd>The extra indent or outdent of access modifiers, e.g. <tt class="docutils literal"><span class="pre">public:</span></tt>.</dd>
+<dt><strong>AlignAfterOpenBracket</strong> (<tt class="docutils literal"><span class="pre">BracketAlignmentStyle</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, horizontally aligns arguments after an open bracket.</p>
+<p>This applies to round brackets (parentheses), angle brackets and square
+brackets.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><tt class="docutils literal"><span class="pre">BAS_Align</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Align</span></tt>)
+Align parameters on the open bracket, e.g.:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">BAS_DontAlign</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">DontAlign</span></tt>)
+Don’t align, instead use <tt class="docutils literal"><span class="pre">ContinuationIndentWidth</span></tt>, e.g.:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">BAS_AlwaysBreak</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">AlwaysBreak</span></tt>)
+Always break after an open bracket, if the parameters don’t fit
+on a single line, e.g.:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, aligns consecutive assignments.</p>
+<p>This will align the assignment operators of consecutive lines. This
+will result in formattings like</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, aligns consecutive declarations.</p>
+<p>This will align the declaration names of consecutive lines. This
+will result in formattings like</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">EscapedNewlineAlignmentStyle</span></tt>)</dt>
+<dd><p class="first">Options for aligning backslashes in escaped newlines.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><tt class="docutils literal"><span class="pre">ENAS_DontAlign</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">DontAlign</span></tt>)
+Don’t align escaped newlines.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">ENAS_Left</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Left</span></tt>)
+Align escaped newlines as far left as possible.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">ENAS_Right</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Right</span></tt>)
+Align escaped newlines in the right-most column.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, horizontally align operands of binary and ternary
+expressions.</p>
+<p>Specifically, this aligns operands of a single expression that needs to be
+split over multiple lines, e.g.:</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, aligns trailing comments.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">Allow putting all parameters of a function declaration onto
+the next line even if <tt class="docutils literal"><span class="pre">BinPackParameters</span></tt> is <tt class="docutils literal"><span class="pre">false</span></tt>.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></span><span class="nb">true</span><span class="o">:</span>                                   <span class="nb">false</span><span class="o">:</span>
+<span class="n">myFunction</span><span class="p">(</span><span class="n">foo</span><span class="p">,</span>                 <span class="n">vs</span><span class="p">.</span>     <span class="n">myFunction</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="n">plop</span><span class="p">);</span>
+           <span class="n">bar</span><span class="p">,</span>
+           <span class="n">plop</span><span class="p">);</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>AllowShortBlocksOnASingleLine</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">Allows contracting simple braced statements to a single line.</p>
+<p class="last">E.g., this allows <tt class="docutils literal"><span class="pre">if</span> <span class="pre">(a)</span> <span class="pre">{</span> <span class="pre">return;</span> <span class="pre">}</span></tt> to be put on a single line.</p>
+</dd>
+<dt><strong>AllowShortCaseLabelsOnASingleLine</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, short case labels will be contracted to a single line.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">ShortFunctionStyle</span></tt>)</dt>
+<dd><p class="first">Dependent on the value, <tt class="docutils literal"><span class="pre">int</span> <span class="pre">f()</span> <span class="pre">{</span> <span class="pre">return</span> <span class="pre">0;</span> <span class="pre">}</span></tt> can be put on a
+single line.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><tt class="docutils literal"><span class="pre">SFS_None</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">None</span></tt>)
+Never merge functions into a single line.</p>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">SFS_InlineOnly</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">InlineOnly</span></tt>)
+Only merge functions defined inside a class. Same as “inline”,
+except it does not implies “empty”: i.e. top level empty functions
+are not merged either.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">SFS_Empty</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Empty</span></tt>)
+Only merge empty functions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">SFS_Inline</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Inline</span></tt>)
+Only merge functions defined inside a class. Implies “empty”.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">SFS_All</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">All</span></tt>)
+Merge all functions fitting on a single line.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd>If <tt class="docutils literal"><span class="pre">true</span></tt>, <tt class="docutils literal"><span class="pre">if</span> <span class="pre">(a)</span> <span class="pre">return;</span></tt> can be put on a single line.</dd>
+<dt><strong>AllowShortLoopsOnASingleLine</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd>If <tt class="docutils literal"><span class="pre">true</span></tt>, <tt class="docutils literal"><span class="pre">while</span> <span class="pre">(true)</span> <span class="pre">continue;</span></tt> can be put on a single
+line.</dd>
+<dt><strong>AlwaysBreakAfterDefinitionReturnType</strong> (<tt class="docutils literal"><span class="pre">DefinitionReturnTypeBreakingStyle</span></tt>)</dt>
+<dd><p class="first">The function definition return type breaking style to use.  This
+option is <strong>deprecated</strong> and is retained for backwards compatibility.</p>
+<p>Possible values:</p>
+<ul class="last simple">
+<li><tt class="docutils literal"><span class="pre">DRTBS_None</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">None</span></tt>)
+Break after return type automatically.
+<tt class="docutils literal"><span class="pre">PenaltyReturnTypeOnItsOwnLine</span></tt> is taken into account.</li>
+<li><tt class="docutils literal"><span class="pre">DRTBS_All</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">All</span></tt>)
+Always break after the return type.</li>
+<li><tt class="docutils literal"><span class="pre">DRTBS_TopLevel</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">TopLevel</span></tt>)
+Always break after the return types of top-level functions.</li>
+</ul>
+</dd>
+<dt><strong>AlwaysBreakAfterReturnType</strong> (<tt class="docutils literal"><span class="pre">ReturnTypeBreakingStyle</span></tt>)</dt>
+<dd><p class="first">The function declaration return type breaking style to use.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><tt class="docutils literal"><span class="pre">RTBS_None</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">None</span></tt>)
+Break after return type automatically.
+<tt class="docutils literal"><span class="pre">PenaltyReturnTypeOnItsOwnLine</span></tt> is taken into account.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">RTBS_All</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">All</span></tt>)
+Always break after the return type.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">RTBS_TopLevel</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">TopLevel</span></tt>)
+Always break after the return types of top-level functions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">RTBS_AllDefinitions</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">AllDefinitions</span></tt>)
+Always break after the return type of function definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">RTBS_TopLevelDefinitions</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">TopLevelDefinitions</span></tt>)
+Always break after the return type of top-level definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, always break before multiline string literals.</p>
+<p>This flag is mean to make cases where there are multiple multiline strings
+in a file look more consistent. Thus, it will only take effect if wrapping
+the string at that point leads to it being indented
+<tt class="docutils literal"><span class="pre">ContinuationIndentWidth</span></tt> spaces from the start of the line.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, always break after the <tt class="docutils literal"><span class="pre">template<...></span></tt> of a template
+declaration.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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="k">typename</span> <span class="n">T</span><span class="o">></span>          <span class="n">vs</span><span class="p">.</span>     <span class="k">template</span> <span class="o"><</span><span class="k">typename</span> <span class="n">T</span><span class="o">></span> <span class="k">class</span> <span class="nc">C</span> <span class="p">{};</span>
+<span class="k">class</span> <span class="nc">C</span> <span class="p">{};</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>BinPackArguments</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">false</span></tt>, a function call’s arguments will either be all on the
+same line or will have one line each.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">false</span></tt>, a function declaration’s or function definition’s
+parameters will either all be on the same line or will have one line each.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">BraceWrappingFlags</span></tt>)</dt>
+<dd><p class="first">Control of individual brace wrapping cases.</p>
+<p>If <tt class="docutils literal"><span class="pre">BreakBeforeBraces</span></tt> is set to <tt class="docutils literal"><span class="pre">BS_Custom</span></tt>, use this to specify how
+each individual brace case should be handled. Otherwise, this is ignored.</p>
+<p>Nested configuration flags:</p>
+<ul class="last">
+<li><p class="first"><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">AfterClass</span></tt> Wrap class definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">AfterControlStatement</span></tt> Wrap control statements (<tt class="docutils literal"><span class="pre">if</span></tt>/<tt class="docutils literal"><span class="pre">for</span></tt>/<tt class="docutils literal"><span class="pre">while</span></tt>/<tt class="docutils literal"><span class="pre">switch</span></tt>/..).</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">AfterEnum</span></tt> Wrap enum definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">AfterFunction</span></tt> Wrap function definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">AfterNamespace</span></tt> Wrap namespace definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">AfterObjCDeclaration</span></tt> Wrap ObjC definitions (<tt class="docutils literal"><span class="pre">@autoreleasepool</span></tt>, interfaces, ..).</p>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">AfterStruct</span></tt> Wrap struct definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">AfterUnion</span></tt> Wrap union definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">BeforeCatch</span></tt> Wrap before <tt class="docutils literal"><span class="pre">catch</span></tt>.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">BeforeElse</span></tt> Wrap before <tt class="docutils literal"><span class="pre">else</span></tt>.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">IndentBraces</span></tt> Indent the wrapped braces themselves.</p>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">SplitEmptyFunctionBody</span></tt> If <tt class="docutils literal"><span class="pre">false</span></tt>, empty function body can be put on a single line.
+This option is used only if the opening brace of the function has
+already been wrapped, i.e. the <cite>AfterFunction</cite> brace wrapping mode is
+set, and the function could/should not be put on a single line (as per
+<cite>AllowShortFunctionsOnASingleLine</cite> and constructor formatting options).</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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>
+</ul>
+</dd>
+<dt><strong>BreakAfterJavaFieldAnnotations</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">Break after each annotation on a field in Java files.</p>
+<div class="last highlight-java"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">BinaryOperatorStyle</span></tt>)</dt>
+<dd><p class="first">The way to wrap binary operators.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><tt class="docutils literal"><span class="pre">BOS_None</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">None</span></tt>)
+Break after operators.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">BOS_NonAssignment</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">NonAssignment</span></tt>)
+Break before operators that aren’t assignments.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">BOS_All</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">All</span></tt>)
+Break before operators.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">BraceBreakingStyle</span></tt>)</dt>
+<dd><p class="first">The brace breaking style to use.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><tt class="docutils literal"><span class="pre">BS_Attach</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Attach</span></tt>)
+Always attach braces to surrounding context.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">BS_Linux</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Linux</span></tt>)
+Like <tt class="docutils literal"><span class="pre">Attach</span></tt>, but break before braces on function, namespace and
+class definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">BS_Mozilla</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Mozilla</span></tt>)
+Like <tt class="docutils literal"><span class="pre">Attach</span></tt>, but break before braces on enum, function, and record
+definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">BS_Stroustrup</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Stroustrup</span></tt>)
+Like <tt class="docutils literal"><span class="pre">Attach</span></tt>, but break before function definitions, <tt class="docutils literal"><span class="pre">catch</span></tt>, and
+<tt class="docutils literal"><span class="pre">else</span></tt>.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">BS_Allman</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Allman</span></tt>)
+Always break before braces.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">BS_GNU</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">GNU</span></tt>)
+Always break before braces and add an extra level of indentation to
+braces of control statements, not to those of class, function
+or other definitions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">BS_WebKit</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">WebKit</span></tt>)
+Like <tt class="docutils literal"><span class="pre">Attach</span></tt>, but break before functions.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">BS_Custom</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Custom</span></tt>)
+Configure each individual brace in <cite>BraceWrapping</cite>.</p>
+</li>
+</ul>
+</dd>
+<dt><strong>BreakBeforeInheritanceComma</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, in the class inheritance expression clang-format will
+break before <tt class="docutils literal"><span class="pre">:</span></tt> and <tt class="docutils literal"><span class="pre">,</span></tt> if there is multiple inheritance.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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">MyClass</span>                  <span class="n">vs</span><span class="p">.</span>     <span class="k">class</span> <span class="nc">MyClass</span> <span class="o">:</span> <span class="k">public</span> <span class="n">X</span><span class="p">,</span> <span class="k">public</span> <span class="n">Y</span> <span class="p">{</span>
+    <span class="o">:</span> <span class="k">public</span> <span class="n">X</span>                         <span class="p">};</span>
+    <span class="p">,</span> <span class="k">public</span> <span class="n">Y</span> <span class="p">{</span>
+<span class="p">};</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>BreakBeforeTernaryOperators</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, ternary operators will be placed after line breaks.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">BreakConstructorInitializersStyle</span></tt>)</dt>
+<dd><p class="first">The constructor initializers style to use.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><tt class="docutils literal"><span class="pre">BCIS_BeforeColon</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">BeforeColon</span></tt>)
+Break constructor initializers before the colon and after the commas.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span>
+</pre></div>
+</div>
+<dl class="docutils">
+<dt>Constructor()</dt>
+<dd><dl class="first last docutils">
+<dt>: initializer1(),</dt>
+<dd><p class="first last">initializer2()</p>
+</dd>
+</dl>
+</dd>
+</dl>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">BCIS_BeforeComma</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">BeforeComma</span></tt>)
+Break constructor initializers before the colon and commas, and align
+the commas with the colon.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span>
+</pre></div>
+</div>
+<dl class="docutils">
+<dt>Constructor()</dt>
+<dd><p class="first last">: initializer1()
+, initializer2()</p>
+</dd>
+</dl>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">BCIS_AfterColon</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">AfterColon</span></tt>)
+Break constructor initializers after the colon and commas.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span>
+</pre></div>
+</div>
+<dl class="docutils">
+<dt>Constructor() :</dt>
+<dd><p class="first last">initializer1(),
+initializer2()</p>
+</dd>
+</dl>
+</li>
+</ul>
+</dd>
+<dt><strong>BreakStringLiterals</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd>Allow breaking string literals when formatting.</dd>
+<dt><strong>ColumnLimit</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd><p class="first">The column limit.</p>
+<p class="last">A column limit of <tt class="docutils literal"><span class="pre">0</span></tt> means that there is no column limit. In this case,
+clang-format will respect the input’s line breaking decisions within
+statements unless they contradict other rules.</p>
+</dd>
+<dt><strong>CommentPragmas</strong> (<tt class="docutils literal"><span class="pre">std::string</span></tt>)</dt>
+<dd><p class="first">A regular expression that describes comments with special meaning,
+which should not be split into lines or otherwise changed.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, consecutive namespace declarations will be on the same
+line. If <tt class="docutils literal"><span class="pre">false</span></tt>, each namespace is declared on a new line.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If the constructor initializers don’t fit on a line, put each
+initializer on its own line.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></span><span class="nb">true</span><span class="o">:</span>
+<span class="n">SomeClass</span><span class="o">::</span><span class="n">Constructor</span><span class="p">()</span>
+    <span class="o">:</span> <span class="n">aaaaaaaa</span><span class="p">(</span><span class="n">aaaaaaaa</span><span class="p">),</span> <span class="n">aaaaaaaa</span><span class="p">(</span><span class="n">aaaaaaaa</span><span class="p">),</span> <span class="n">aaaaaaaa</span><span class="p">(</span><span class="n">aaaaaaaaaaaaaaaaaaaaaaaaa</span><span class="p">)</span> <span class="p">{</span>
+  <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="nb">false</span><span class="o">:</span>
+<span class="n">SomeClass</span><span class="o">::</span><span class="n">Constructor</span><span class="p">()</span>
+    <span class="o">:</span> <span class="n">aaaaaaaa</span><span class="p">(</span><span class="n">aaaaaaaa</span><span class="p">),</span> <span class="n">aaaaaaaa</span><span class="p">(</span><span class="n">aaaaaaaa</span><span class="p">),</span>
+      <span class="n">aaaaaaaa</span><span class="p">(</span><span class="n">aaaaaaaaaaaaaaaaaaaaaaaaa</span><span class="p">)</span> <span class="p">{</span>
+  <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</dd>
+<dt><strong>ConstructorInitializerIndentWidth</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd>The number of characters to use for indentation of constructor
+initializer lists.</dd>
+<dt><strong>ContinuationIndentWidth</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd><p class="first">Indent width for line continuations.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, format braced lists as best suited for C++11 braced
+lists.</p>
+<p>Important differences:
+- No spaces inside the braced list.
+- No line break before the closing brace.
+- Indentation with the continuation indent, not with the block indent.</p>
+<p>Fundamentally, C++11 braced lists are formatted exactly like function
+calls would be formatted in their place. If the braced list follows a name
+(e.g. a type or variable name), clang-format formats as if the <tt class="docutils literal"><span class="pre">{}</span></tt> were
+the parentheses of a function call with that name. If there is no name,
+a zero-length name is assumed.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd>If <tt class="docutils literal"><span class="pre">true</span></tt>, analyze the formatted file for the most common
+alignment of <tt class="docutils literal"><span class="pre">&</span></tt> and <tt class="docutils literal"><span class="pre">*</span></tt>.
+Pointer and reference alignment styles are going to be updated according
+to the preferences found in the file.
+<tt class="docutils literal"><span class="pre">PointerAlignment</span></tt> is then used only as fallback.</dd>
+<dt><strong>DisableFormat</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd>Disables formatting completely.</dd>
+<dt><strong>ExperimentalAutoDetectBinPacking</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, clang-format detects whether function calls and
+definitions are formatted with one parameter per line.</p>
+<p>Each call can be bin-packed, one-per-line or inconclusive. If it is
+inconclusive, e.g. completely on one line, but a decision needs to be
+made, clang-format analyzes whether there are other bin-packed cases in
+the input file and act accordingly.</p>
+<p class="last">NOTE: This is an experimental flag, that might go away or be renamed. Do
+not use this in config files, etc. Use at your own risk.</p>
+</dd>
+<dt><strong>FixNamespaceComments</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, clang-format adds missing namespace end comments and
+fixes invalid existing ones.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">std::vector<std::string></span></tt>)</dt>
+<dd><p class="first">A vector of macros that should be interpreted as foreach loops
+instead of as function calls.</p>
+<p>These are expected to be macros of the form:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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>IncludeCategories</strong> (<tt class="docutils literal"><span class="pre">std::vector<IncludeCategory></span></tt>)</dt>
+<dd><p class="first">Regular expressions denoting the different <tt class="docutils literal"><span class="pre">#include</span></tt> categories
+used for ordering <tt class="docutils literal"><span class="pre">#includes</span></tt>.</p>
+<p>These regular expressions are matched against the filename of an include
+(including the <> or “”) in order. The value belonging to the first
+matching regular expression is assigned and <tt class="docutils literal"><span class="pre">#includes</span></tt> are sorted first
+according to increasing category number and then alphabetically within
+each category.</p>
+<p>If none of the regular expressions match, INT_MAX is assigned as
+category. The main header for a source file automatically gets category 0.
+so that it is generally kept at the beginning of the <tt class="docutils literal"><span class="pre">#includes</span></tt>
+(<a class="reference external" href="http://llvm.org/docs/CodingStandards.html#include-style">http://llvm.org/docs/CodingStandards.html#include-style</a>). However, you
+can also assign negative priorities if you have certain headers that
+always need to be first.</p>
+<p>To configure this in the .clang-format file, use:</p>
+<div class="last highlight-yaml"><div class="highlight"><pre><span></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|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">'.*'</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> (<tt class="docutils literal"><span class="pre">std::string</span></tt>)</dt>
+<dd><p class="first">Specify a regular expression of suffixes that are allowed in the
+file-to-main-include mapping.</p>
+<p>When guessing whether a #include is the “main” include (to assign
+category 0, see above), use this regex of allowed suffixes to the header
+stem. A partial match is done, so that:
+- “” means “arbitrary suffix”
+- “$” means “no suffix”</p>
+<p class="last">For example, if configured to “(_test)?$”, then a header a.h would be seen
+as the “main” include in both a.cc and a_test.cc.</p>
+</dd>
+<dt><strong>IndentCaseLabels</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">Indent case labels one level from the switch statement.</p>
+<p>When <tt class="docutils literal"><span class="pre">false</span></tt>, use the same indentation level as for the switch statement.
+Switch statement body is always indented one level more than case labels.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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>IndentWidth</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd><p class="first">The number of columns to use for indentation.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">Indent if a function definition or declaration is wrapped after the
+type.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">JavaScriptQuoteStyle</span></tt>)</dt>
+<dd><p class="first">The JavaScriptQuoteStyle to use for JavaScript strings.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><tt class="docutils literal"><span class="pre">JSQS_Leave</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Leave</span></tt>)
+Leave string quotes as they are.</p>
+<div class="highlight-js"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">JSQS_Single</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Single</span></tt>)
+Always use single quotes.</p>
+<div class="highlight-js"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">JSQS_Double</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Double</span></tt>)
+Always use double quotes.</p>
+<div class="highlight-js"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">Whether to wrap JavaScript import/export statements.</p>
+<div class="last highlight-js"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If true, the empty line at the start of blocks is kept.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">LanguageKind</span></tt>)</dt>
+<dd><p class="first">Language, this format style is targeted at.</p>
+<p>Possible values:</p>
+<ul class="last simple">
+<li><tt class="docutils literal"><span class="pre">LK_None</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">None</span></tt>)
+Do not use.</li>
+<li><tt class="docutils literal"><span class="pre">LK_Cpp</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Cpp</span></tt>)
+Should be used for C, C++.</li>
+<li><tt class="docutils literal"><span class="pre">LK_Java</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Java</span></tt>)
+Should be used for Java.</li>
+<li><tt class="docutils literal"><span class="pre">LK_JavaScript</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">JavaScript</span></tt>)
+Should be used for JavaScript.</li>
+<li><tt class="docutils literal"><span class="pre">LK_ObjC</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">ObjC</span></tt>)
+Should be used for Objective-C, Objective-C++.</li>
+<li><tt class="docutils literal"><span class="pre">LK_Proto</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Proto</span></tt>)
+Should be used for Protocol Buffers
+(<a class="reference external" href="https://developers.google.com/protocol-buffers/">https://developers.google.com/protocol-buffers/</a>).</li>
+<li><tt class="docutils literal"><span class="pre">LK_TableGen</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">TableGen</span></tt>)
+Should be used for TableGen code.</li>
+</ul>
+</dd>
+<dt><strong>MacroBlockBegin</strong> (<tt class="docutils literal"><span class="pre">std::string</span></tt>)</dt>
+<dd><p class="first">A regular expression matching macros that start a block.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">std::string</span></tt>)</dt>
+<dd>A regular expression matching macros that end a block.</dd>
+<dt><strong>MaxEmptyLinesToKeep</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd><p class="first">The maximum number of consecutive empty lines to keep.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">NamespaceIndentationKind</span></tt>)</dt>
+<dd><p class="first">The indentation used for namespaces.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><tt class="docutils literal"><span class="pre">NI_None</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">None</span></tt>)
+Don’t indent in namespaces.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">NI_Inner</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Inner</span></tt>)
+Indent only in inner namespaces (nested in other namespaces).</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">NI_All</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">All</span></tt>)
+Indent in all namespaces.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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>ObjCBlockIndentWidth</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd><p class="first">The number of characters to use for indentation of ObjC blocks.</p>
+<div class="last highlight-objc"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd>Add a space after <tt class="docutils literal"><span class="pre">@property</span></tt> in Objective-C, i.e. use
+<tt class="docutils literal"><span class="pre">@property</span> <span class="pre">(readonly)</span></tt> instead of <tt class="docutils literal"><span class="pre">@property(readonly)</span></tt>.</dd>
+<dt><strong>ObjCSpaceBeforeProtocolList</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd>Add a space in front of an Objective-C protocol list, i.e. use
+<tt class="docutils literal"><span class="pre">Foo</span> <span class="pre"><Protocol></span></tt> instead of <tt class="docutils literal"><span class="pre">Foo<Protocol></span></tt>.</dd>
+<dt><strong>PenaltyBreakAssignment</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd>The penalty for breaking around an assignment operator.</dd>
+<dt><strong>PenaltyBreakBeforeFirstCallParameter</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd>The penalty for breaking a function call after <tt class="docutils literal"><span class="pre">call(</span></tt>.</dd>
+<dt><strong>PenaltyBreakComment</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd>The penalty for each line break introduced inside a comment.</dd>
+<dt><strong>PenaltyBreakFirstLessLess</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd>The penalty for breaking before the first <tt class="docutils literal"><span class="pre"><<</span></tt>.</dd>
+<dt><strong>PenaltyBreakString</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd>The penalty for each line break introduced inside a string literal.</dd>
+<dt><strong>PenaltyExcessCharacter</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd>The penalty for each character outside of the column limit.</dd>
+<dt><strong>PenaltyReturnTypeOnItsOwnLine</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd>Penalty for putting the return type of a function onto its own
+line.</dd>
+<dt><strong>PointerAlignment</strong> (<tt class="docutils literal"><span class="pre">PointerAlignmentStyle</span></tt>)</dt>
+<dd><p class="first">Pointer and reference alignment style.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><tt class="docutils literal"><span class="pre">PAS_Left</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Left</span></tt>)
+Align pointer to the left.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">PAS_Right</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Right</span></tt>)
+Align pointer to the right.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">PAS_Middle</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Middle</span></tt>)
+Align pointer in the middle.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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>ReflowComments</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, clang-format will attempt to re-flow comments.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, clang-format will sort <tt class="docutils literal"><span class="pre">#includes</span></tt>.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, clang-format will sort using declarations.</p>
+<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> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, a space is inserted after C style casts.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, a space will be inserted after the ‘template’ keyword.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">false</span></tt>, spaces will be removed before assignment operators.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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>SpaceBeforeParens</strong> (<tt class="docutils literal"><span class="pre">SpaceBeforeParensOptions</span></tt>)</dt>
+<dd><p class="first">Defines in which cases to put a space before opening parentheses.</p>
+<p>Possible values:</p>
+<ul class="last">
+<li><p class="first"><tt class="docutils literal"><span class="pre">SBPO_Never</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Never</span></tt>)
+Never put a space before opening parentheses.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">SBPO_ControlStatements</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">ControlStatements</span></tt>)
+Put a space before opening parentheses only after control statement
+keywords (<tt class="docutils literal"><span class="pre">for/if/while...</span></tt>).</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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"><tt class="docutils literal"><span class="pre">SBPO_Always</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Always</span></tt>)
+Always put a space before opening parentheses, except when it’s
+prohibited by the syntax rules (in function-like macro definitions) or
+when determined by other style rules (after unary operators, opening
+parentheses, etc.)</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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>SpaceInEmptyParentheses</strong> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, spaces may be inserted into <tt class="docutils literal"><span class="pre">()</span></tt>.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd><p class="first">The number of spaces before trailing line comments
+(<tt class="docutils literal"><span class="pre">//</span></tt> - comments).</p>
+<p>This does not affect trailing block comments (<tt class="docutils literal"><span class="pre">/*</span></tt> - comments) as
+those commonly have different usage patterns and a number of special
+cases.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, spaces will be inserted after <tt class="docutils literal"><span class="pre"><</span></tt> and before <tt class="docutils literal"><span class="pre">></span></tt>
+in template argument lists.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, spaces may be inserted into C style casts.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, spaces are inserted inside container literals (e.g.
+ObjC and Javascript array and dict literals).</p>
+<div class="last highlight-js"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, spaces will be inserted after <tt class="docutils literal"><span class="pre">(</span></tt> and before <tt class="docutils literal"><span class="pre">)</span></tt>.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">bool</span></tt>)</dt>
+<dd><p class="first">If <tt class="docutils literal"><span class="pre">true</span></tt>, spaces will be inserted after <tt class="docutils literal"><span class="pre">[</span></tt> and before <tt class="docutils literal"><span class="pre">]</span></tt>.
+Lambdas or unspecified size array declarations will not be affected.</p>
+<div class="last highlight-c++"><div class="highlight"><pre><span></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> (<tt class="docutils literal"><span class="pre">LanguageStandard</span></tt>)</dt>
+<dd><p class="first">Format compatible with this standard, e.g. use <tt class="docutils literal"><span class="pre">A<A<int></span> <span class="pre">></span></tt>
+instead of <tt class="docutils literal"><span class="pre">A<A<int>></span></tt> for <tt class="docutils literal"><span class="pre">LS_Cpp03</span></tt>.</p>
+<p>Possible values:</p>
+<ul class="last simple">
+<li><tt class="docutils literal"><span class="pre">LS_Cpp03</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Cpp03</span></tt>)
+Use C++03-compatible syntax.</li>
+<li><tt class="docutils literal"><span class="pre">LS_Cpp11</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Cpp11</span></tt>)
+Use features of C++11, C++14 and C++1z (e.g. <tt class="docutils literal"><span class="pre">A<A<int>></span></tt> instead of
+<tt class="docutils literal"><span class="pre">A<A<int></span> <span class="pre">></span></tt>).</li>
+<li><tt class="docutils literal"><span class="pre">LS_Auto</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Auto</span></tt>)
+Automatic detection based on the input.</li>
+</ul>
+</dd>
+<dt><strong>TabWidth</strong> (<tt class="docutils literal"><span class="pre">unsigned</span></tt>)</dt>
+<dd>The number of columns used for tab stops.</dd>
+<dt><strong>UseTab</strong> (<tt class="docutils literal"><span class="pre">UseTabStyle</span></tt>)</dt>
+<dd><p class="first">The way to use tab characters in the resulting file.</p>
+<p>Possible values:</p>
+<ul class="last simple">
+<li><tt class="docutils literal"><span class="pre">UT_Never</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Never</span></tt>)
+Never use tab.</li>
+<li><tt class="docutils literal"><span class="pre">UT_ForIndentation</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">ForIndentation</span></tt>)
+Use tabs only for indentation.</li>
+<li><tt class="docutils literal"><span class="pre">UT_ForContinuationAndIndentation</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">ForContinuationAndIndentation</span></tt>)
+Use tabs only for line continuation and indentation.</li>
+<li><tt class="docutils literal"><span class="pre">UT_Always</span></tt> (in configuration: <tt class="docutils literal"><span class="pre">Always</span></tt>)
+Use tabs whenever we need to fill whitespace that spans at least from
+one tab stop to the next one.</li>
+</ul>
+</dd>
+</dl>
+</div>
+<div class="section" id="adding-additional-style-options">
+<h2>Adding additional style options<a class="headerlink" href="#adding-additional-style-options" title="Permalink to this headline">Â¶</a></h2>
+<p>Each additional style option adds costs to the clang-format project. Some of
+these costs affect the clang-format development itself, as we need to make
+sure that any given combination of options work and that new features don’t
+break any of the existing options in any way. There are also costs for end users
+as options become less discoverable and people have to think about and make a
+decision on options they don’t really care about.</p>
+<p>The goal of the clang-format project is more on the side of supporting a
+limited set of styles really well as opposed to supporting every single style
+used by a codebase somewhere in the wild. Of course, we do want to support all
+major projects and thus have established the following bar for adding style
+options. Each new style option must ..</p>
+<blockquote>
+<div><ul class="simple">
+<li>be used in a project of significant size (have dozens of contributors)</li>
+<li>have a publicly accessible style guide</li>
+<li>have a person willing to contribute and maintain patches</li>
+</ul>
+</div></blockquote>
+</div>
+<div class="section" id="examples">
+<h2>Examples<a class="headerlink" href="#examples" title="Permalink to this headline">Â¶</a></h2>
+<p>A style similar to the <a class="reference external" href="https://www.kernel.org/doc/Documentation/CodingStyle">Linux Kernel style</a>:</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span></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">
+      
+        <p>
+        Â«  <a href="ClangFormat.html">ClangFormat</a>
+          ::  
+        <a class="uplink" href="index.html">Contents</a>
+          ::  
+        <a href="InternalsManual.html">“Clang” CFE Internals Manual</a>  Â»
+        </p>
+
+      </div>
+
+    <div class="footer">
+        © Copyright 2007-2017, The Clang Team.
+      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.2.2.
+    </div>
+  </body>
+</html>
\ No newline at end of file

Added: www-releases/trunk/5.0.0/tools/clang/docs/ClangPlugins.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/5.0.0/tools/clang/docs/ClangPlugins.html?rev=312731&view=auto
==============================================================================
--- www-releases/trunk/5.0.0/tools/clang/docs/ClangPlugins.html (added)
+++ www-releases/trunk/5.0.0/tools/clang/docs/ClangPlugins.html Thu Sep  7 10:47:16 2017
@@ -0,0 +1,182 @@
+<!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 5 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:     '5',
+        COLLAPSE_INDEX: false,
+        FILE_SUFFIX: '.html',
+        HAS_SOURCE:  true
+      };
+    </script>
+    <script type="text/javascript" src="_static/jquery.js"></script>
+    <script type="text/javascript" src="_static/underscore.js"></script>
+    <script type="text/javascript" src="_static/doctools.js"></script>
+    <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+    <link rel="top" title="Clang 5 documentation" href="index.html" />
+    <link rel="next" title="How to write RecursiveASTVisitor based ASTFrontendActions." href="RAVFrontendAction.html" />
+    <link rel="prev" title="LibFormat" href="LibFormat.html" /> 
+  </head>
+  <body>
+      <div class="header"><h1 class="heading"><a href="index.html">
+          <span>Clang 5 documentation</span></a></h1>
+        <h2 class="heading"><span>Clang Plugins</span></h2>
+      </div>
+      <div class="topnav">
+      
+        <p>
+        Â«  <a href="LibFormat.html">LibFormat</a>
+          ::  
+        <a class="uplink" href="index.html">Contents</a>
+          ::  
+        <a href="RAVFrontendAction.html">How to write RecursiveASTVisitor based ASTFrontendActions.</a>  Â»
+        </p>
+
+      </div>
+      <div class="content">
+        
+        
+  <div class="section" id="clang-plugins">
+<h1>Clang Plugins<a class="headerlink" href="#clang-plugins" title="Permalink to this headline">Â¶</a></h1>
+<p>Clang Plugins make it possible to run extra user defined actions during a
+compilation. This document will provide a basic walkthrough of how to write and
+run a Clang Plugin.</p>
+<div class="section" id="introduction">
+<h2>Introduction<a class="headerlink" href="#introduction" title="Permalink to this headline">Â¶</a></h2>
+<p>Clang Plugins run FrontendActions over code. See the <a class="reference internal" href="RAVFrontendAction.html"><em>FrontendAction
+tutorial</em></a> on how to write a <tt class="docutils literal"><span class="pre">FrontendAction</span></tt> using the
+<tt class="docutils literal"><span class="pre">RecursiveASTVisitor</span></tt>. In this tutorial, we’ll demonstrate how to write a
+simple clang plugin.</p>
+</div>
+<div class="section" id="writing-a-pluginastaction">
+<h2>Writing a <tt class="docutils literal"><span class="pre">PluginASTAction</span></tt><a class="headerlink" href="#writing-a-pluginastaction" title="Permalink to this headline">Â¶</a></h2>
+<p>The main difference from writing normal <tt class="docutils literal"><span class="pre">FrontendActions</span></tt> is that you can
+handle plugin command line options. The <tt class="docutils literal"><span class="pre">PluginASTAction</span></tt> base class declares
+a <tt class="docutils literal"><span class="pre">ParseArgs</span></tt> method which you have to implement in your plugin.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">FrontendPluginRegistry::Add<></span></tt>:</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 <tt class="docutils literal"><span class="pre">PragmaHandler</span></tt> and
+registering it using <tt class="docutils literal"><span class="pre">PragmaHandlerRegistry::Add<></span></tt>:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">print-function-names</span></tt> plugin over a source file in
+clang, first build the plugin, and then call clang with the plugin from the
+source tree:</p>
+<div class="highlight-console"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">getActionType</span></tt> method then the plugin is run
+automatically. For example, to run the plugin automatically after the main AST
+action (i.e. the same as using <cite>-add-plugin</cite>):</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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">
+      
+        <p>
+        Â«  <a href="LibFormat.html">LibFormat</a>
+          ::  
+        <a class="uplink" href="index.html">Contents</a>
+          ::  
+        <a href="RAVFrontendAction.html">How to write RecursiveASTVisitor based ASTFrontendActions.</a>  Â»
+        </p>
+
+      </div>
+
+    <div class="footer">
+        © Copyright 2007-2017, The Clang Team.
+      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.2.2.
+    </div>
+  </body>
+</html>
\ No newline at end of file

Added: www-releases/trunk/5.0.0/tools/clang/docs/ClangTools.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/5.0.0/tools/clang/docs/ClangTools.html?rev=312731&view=auto
==============================================================================
--- www-releases/trunk/5.0.0/tools/clang/docs/ClangTools.html (added)
+++ www-releases/trunk/5.0.0/tools/clang/docs/ClangTools.html Thu Sep  7 10:47:16 2017
@@ -0,0 +1,220 @@
+<!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 5 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:     '5',
+        COLLAPSE_INDEX: false,
+        FILE_SUFFIX: '.html',
+        HAS_SOURCE:  true
+      };
+    </script>
+    <script type="text/javascript" src="_static/jquery.js"></script>
+    <script type="text/javascript" src="_static/underscore.js"></script>
+    <script type="text/javascript" src="_static/doctools.js"></script>
+    <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+    <link rel="top" title="Clang 5 documentation" href="index.html" />
+    <link rel="next" title="ClangCheck" href="ClangCheck.html" />
+    <link rel="prev" title="JSON Compilation Database Format Specification" href="JSONCompilationDatabase.html" /> 
+  </head>
+  <body>
+      <div class="header"><h1 class="heading"><a href="index.html">
+          <span>Clang 5 documentation</span></a></h1>
+        <h2 class="heading"><span>Overview</span></h2>
+      </div>
+      <div class="topnav">
+      
+        <p>
+        Â«  <a href="JSONCompilationDatabase.html">JSON Compilation Database Format Specification</a>
+          ::  
+        <a class="uplink" href="index.html">Contents</a>
+          ::  
+        <a href="ClangCheck.html">ClangCheck</a>  Â»
+        </p>
+
+      </div>
+      <div class="content">
+        
+        
+  <div class="section" id="overview">
+<h1>Overview<a class="headerlink" href="#overview" title="Permalink to this headline">Â¶</a></h1>
+<p>Clang Tools are standalone command line (and potentially GUI) tools
+designed for use by C++ developers who are already using and enjoying
+Clang as their compiler. These tools provide developer-oriented
+functionality such as fast syntax checking, automatic formatting,
+refactoring, etc.</p>
+<p>Only a couple of the most basic and fundamental tools are kept in the
+primary Clang Subversion project. The rest of the tools are kept in a
+side-project so that developers who don’t want or need to build them
+don’t. If you want to get access to the extra Clang Tools repository,
+simply check it out into the tools tree of your Clang checkout and
+follow the usual process for building and working with a combined
+LLVM/Clang checkout:</p>
+<ul class="simple">
+<li>With Subversion:<ul>
+<li><tt class="docutils literal"><span class="pre">cd</span> <span class="pre">llvm/tools/clang/tools</span></tt></li>
+<li><tt class="docutils literal"><span class="pre">svn</span> <span class="pre">co</span> <span class="pre">http://llvm.org/svn/llvm-project/clang-tools-extra/trunk</span> <span class="pre">extra</span></tt></li>
+</ul>
+</li>
+<li>Or with Git:<ul>
+<li><tt class="docutils literal"><span class="pre">cd</span> <span class="pre">llvm/tools/clang/tools</span></tt></li>
+<li><tt class="docutils literal"><span class="pre">git</span> <span class="pre">clone</span> <span class="pre">http://llvm.org/git/clang-tools-extra.git</span> <span class="pre">extra</span></tt></li>
+</ul>
+</li>
+</ul>
+<p>This document describes a high-level overview of the organization of
+Clang Tools within the project as well as giving an introduction to some
+of the more important tools. However, it should be noted that this
+document is currently focused on Clang and Clang Tool developers, not on
+end users of these tools.</p>
+<div class="section" id="clang-tools-organization">
+<h2>Clang Tools Organization<a class="headerlink" href="#clang-tools-organization" title="Permalink to this headline">Â¶</a></h2>
+<p>Clang Tools are CLI or GUI programs that are intended to be directly
+used by C++ developers. That is they are <em>not</em> primarily for use by
+Clang developers, although they are hopefully useful to C++ developers
+who happen to work on Clang, and we try to actively dogfood their
+functionality. They are developed in three components: the underlying
+infrastructure for building a standalone tool based on Clang, core
+shared logic used by many different tools in the form of refactoring and
+rewriting libraries, and the tools themselves.</p>
+<p>The underlying infrastructure for Clang Tools is the
+<a class="reference internal" href="LibTooling.html"><em>LibTooling</em></a> platform. See its documentation for much
+more detailed information about how this infrastructure works. The
+common refactoring and rewriting toolkit-style library is also part of
+LibTooling organizationally.</p>
+<p>A few Clang Tools are developed along side the core Clang libraries as
+examples and test cases of fundamental functionality. However, most of
+the tools are developed in a side repository to provide easy separation
+from the core libraries. We intentionally do not support public
+libraries in the side repository, as we want to carefully review and
+find good APIs for libraries as they are lifted out of a few tools and
+into the core Clang library set.</p>
+<p>Regardless of which repository Clang Tools’ code resides in, the
+development process and practices for all Clang Tools are exactly those
+of Clang itself. They are entirely within the Clang <em>project</em>,
+regardless of the version control scheme.</p>
+</div>
+<div class="section" id="core-clang-tools">
+<h2>Core Clang Tools<a class="headerlink" href="#core-clang-tools" title="Permalink to this headline">Â¶</a></h2>
+<p>The core set of Clang tools that are within the main repository are
+tools that very specifically complement, and allow use and testing of
+<em>Clang</em> specific functionality.</p>
+<div class="section" id="clang-check">
+<h3><tt class="docutils literal"><span class="pre">clang-check</span></tt><a class="headerlink" href="#clang-check" title="Permalink to this headline">Â¶</a></h3>
+<p><a class="reference internal" href="ClangCheck.html"><em>ClangCheck</em></a> combines the LibTooling framework for running a
+Clang tool with the basic Clang diagnostics by syntax checking specific files
+in a fast, command line interface. It can also accept flags to re-display the
+diagnostics in different formats with different flags, suitable for use driving
+an IDE or editor. Furthermore, it can be used in fixit-mode to directly apply
+fixit-hints offered by clang. See <a class="reference internal" href="HowToSetupToolingForLLVM.html"><em>How To Setup Clang Tooling For LLVM</em></a> for
+instructions on how to setup and used <cite>clang-check</cite>.</p>
+</div>
+<div class="section" id="clang-format">
+<h3><tt class="docutils literal"><span class="pre">clang-format</span></tt><a class="headerlink" href="#clang-format" title="Permalink to this headline">Â¶</a></h3>
+<p>Clang-format is both a <a class="reference internal" href="LibFormat.html"><em>library</em></a> and a <a class="reference internal" href="ClangFormat.html"><em>stand-alone tool</em></a> with the goal of automatically reformatting C++ sources files
+according to configurable style guides.  To do so, clang-format uses Clang’s
+<tt class="docutils literal"><span class="pre">Lexer</span></tt> to transform an input file into a token stream and then changes all
+the whitespace around those tokens.  The goal is for clang-format to serve both
+as a user tool (ideally with powerful IDE integrations) and as part of other
+refactoring tools, e.g. to do a reformatting of all the lines changed during a
+renaming.</p>
+</div>
+</div>
+<div class="section" id="extra-clang-tools">
+<h2>Extra Clang Tools<a class="headerlink" href="#extra-clang-tools" title="Permalink to this headline">Â¶</a></h2>
+<p>As various categories of Clang Tools are added to the extra repository,
+they’ll be tracked here. The focus of this documentation is on the scope
+and features of the tools for other tool developers; each tool should
+provide its own user-focused documentation.</p>
+<div class="section" id="clang-tidy">
+<h3><tt class="docutils literal"><span class="pre">clang-tidy</span></tt><a class="headerlink" href="#clang-tidy" title="Permalink to this headline">Â¶</a></h3>
+<p><a class="reference external" href="http://clang.llvm.org/extra/clang-tidy/">clang-tidy</a> is a clang-based C++
+linter tool. It provides an extensible framework for building compiler-based
+static analyses detecting and fixing bug-prone patterns, performance,
+portability and maintainability issues.</p>
+</div>
+</div>
+<div class="section" id="ideas-for-new-tools">
+<h2>Ideas for new Tools<a class="headerlink" href="#ideas-for-new-tools" title="Permalink to this headline">Â¶</a></h2>
+<ul>
+<li><p class="first">C++ cast conversion tool.  Will convert C-style casts (<tt class="docutils literal"><span class="pre">(type)</span> <span class="pre">value</span></tt>) to
+appropriate C++ cast (<tt class="docutils literal"><span class="pre">static_cast</span></tt>, <tt class="docutils literal"><span class="pre">const_cast</span></tt> or
+<tt class="docutils literal"><span class="pre">reinterpret_cast</span></tt>).</p>
+</li>
+<li><p class="first">Non-member <tt class="docutils literal"><span class="pre">begin()</span></tt> and <tt class="docutils literal"><span class="pre">end()</span></tt> conversion tool.  Will convert
+<tt class="docutils literal"><span class="pre">foo.begin()</span></tt> into <tt class="docutils literal"><span class="pre">begin(foo)</span></tt> and similarly for <tt class="docutils literal"><span class="pre">end()</span></tt>, where
+<tt class="docutils literal"><span class="pre">foo</span></tt> is a standard container.  We could also detect similar patterns for
+arrays.</p>
+</li>
+<li><p class="first"><tt class="docutils literal"><span class="pre">tr1</span></tt> removal tool.  Will migrate source code from using TR1 library
+features to C++11 library.  For example:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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 <tt class="docutils literal"><span class="pre">auto</span></tt>.  Will convert <tt class="docutils literal"><span class="pre">auto</span></tt> to an explicit type or add
+comments with deduced types.  The motivation is that there are developers
+that don’t want to use <tt class="docutils literal"><span class="pre">auto</span></tt> because they are afraid that they might lose
+control over their code.</p>
+</li>
+<li><p class="first">C++14: less verbose operator function objects (<a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3421.htm">N3421</a>).
+For example:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></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">
+      
+        <p>
+        Â«  <a href="JSONCompilationDatabase.html">JSON Compilation Database Format Specification</a>
+          ::  
+        <a class="uplink" href="index.html">Contents</a>
+          ::  
+        <a href="ClangCheck.html">ClangCheck</a>  Â»
+        </p>
+
+      </div>
+
+    <div class="footer">
+        © Copyright 2007-2017, The Clang Team.
+      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.2.2.
+    </div>
+  </body>
+</html>
\ No newline at end of file

Added: www-releases/trunk/5.0.0/tools/clang/docs/CommandGuide/clang.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/5.0.0/tools/clang/docs/CommandGuide/clang.html?rev=312731&view=auto
==============================================================================
--- www-releases/trunk/5.0.0/tools/clang/docs/CommandGuide/clang.html (added)
+++ www-releases/trunk/5.0.0/tools/clang/docs/CommandGuide/clang.html Thu Sep  7 10:47:16 2017
@@ -0,0 +1,705 @@
+<!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 5 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:     '5',
+        COLLAPSE_INDEX: false,
+        FILE_SUFFIX: '.html',
+        HAS_SOURCE:  true
+      };
+    </script>
+    <script type="text/javascript" src="../_static/jquery.js"></script>
+    <script type="text/javascript" src="../_static/underscore.js"></script>
+    <script type="text/javascript" src="../_static/doctools.js"></script>
+    <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+    <link rel="top" title="Clang 5 documentation" href="../index.html" />
+    <link rel="up" title="Clang âmanâ pages" href="index.html" />
+    <link rel="next" title="Frequently Asked Questions (FAQ)" href="../FAQ.html" />
+    <link rel="prev" title="Clang âmanâ pages" href="index.html" /> 
+  </head>
+  <body>
+      <div class="header"><h1 class="heading"><a href="../index.html">
+          <span>Clang 5 documentation</span></a></h1>
+        <h2 class="heading"><span>clang - the Clang C, C++, and Objective-C compiler</span></h2>
+      </div>
+      <div class="topnav">
+      
+        <p>
+        Â«  <a href="index.html">Clang “man” pages</a>
+          ::  
+        <a class="uplink" href="../index.html">Contents</a>
+          ::  
+        <a href="../FAQ.html">Frequently Asked Questions (FAQ)</a>  Â»
+        </p>
+
+      </div>
+      <div class="content">
+        
+        
+  <div class="section" id="clang-the-clang-c-c-and-objective-c-compiler">
+<h1>clang - the Clang C, C++, and Objective-C compiler<a class="headerlink" href="#clang-the-clang-c-c-and-objective-c-compiler" title="Permalink to this headline">Â¶</a></h1>
+<div class="section" id="synopsis">
+<h2>SYNOPSIS<a class="headerlink" href="#synopsis" title="Permalink to this headline">Â¶</a></h2>
+<p><strong class="program">clang</strong> [<em>options</em>] <em>filename ...</em></p>
+</div>
+<div class="section" id="description">
+<h2>DESCRIPTION<a class="headerlink" href="#description" title="Permalink to this headline">Â¶</a></h2>
+<p><strong class="program">clang</strong> is a C, C++, and Objective-C compiler which encompasses
+preprocessing, parsing, optimization, code generation, assembly, and linking.
+Depending on which high-level mode setting is passed, Clang will stop before
+doing a full link.  While Clang is highly integrated, it is important to
+understand the stages of compilation, to understand how to invoke it.  These
+stages are:</p>
+<dl class="docutils">
+<dt>Driver</dt>
+<dd>The clang executable is actually a small driver which controls the overall
+execution of other tools such as the compiler, assembler and linker.
+Typically you do not need to interact with the driver, but you
+transparently use it to run the other tools.</dd>
+<dt>Preprocessing</dt>
+<dd>This stage handles tokenization of the input source file, macro expansion,
+#include expansion and handling of other preprocessor directives.  The
+output of this stage is typically called a ”.i” (for C), ”.ii” (for C++),
+”.mi” (for Objective-C), or ”.mii” (for Objective-C++) file.</dd>
+<dt>Parsing and Semantic Analysis</dt>
+<dd>This stage parses the input file, translating preprocessor tokens into a
+parse tree.  Once in the form of a parse tree, it applies semantic
+analysis to compute types for expressions as well and determine whether
+the code is well formed. This stage is responsible for generating most of
+the compiler warnings as well as parse errors. The output of this stage is
+an “Abstract Syntax Tree” (AST).</dd>
+<dt>Code Generation and Optimization</dt>
+<dd><p class="first">This stage translates an AST into low-level intermediate code (known as
+“LLVM IR”) and ultimately to machine code.  This phase is responsible for
+optimizing the generated code and handling target-specific code generation.
+The output of this stage is typically called a ”.s” file or “assembly” file.</p>
+<p class="last">Clang also supports the use of an integrated assembler, in which the code
+generator produces object files directly. This avoids the overhead of
+generating the ”.s” file and of calling the target assembler.</p>
+</dd>
+<dt>Assembler</dt>
+<dd>This stage runs the target assembler to translate the output of the
+compiler into a target object file. The output of this stage is typically
+called a ”.o” file or “object” file.</dd>
+<dt>Linker</dt>
+<dd>This stage runs the target linker to merge multiple object files into an
+executable or dynamic library. The output of this stage is typically called
+an “a.out”, ”.dylib” or ”.so” file.</dd>
+</dl>
+<p><strong class="program">Clang Static Analyzer</strong></p>
+<p>The Clang Static Analyzer is a tool that scans source code to try to find bugs
+through code analysis.  This tool uses many parts of Clang and is built into
+the same driver.  Please see <<a class="reference external" href="http://clang-analyzer.llvm.org">http://clang-analyzer.llvm.org</a>> for more details
+on how to use the static analyzer.</p>
+</div>
+<div class="section" id="options">
+<h2>OPTIONS<a class="headerlink" href="#options" title="Permalink to this headline">Â¶</a></h2>
+<div class="section" id="stage-selection-options">
+<h3>Stage Selection Options<a class="headerlink" href="#stage-selection-options" title="Permalink to this headline">Â¶</a></h3>
+<dl class="option">
+<dt id="cmdoption-E">
+<tt class="descname">-E</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-E" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Run the preprocessor stage.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fsyntax-only">
+<tt class="descname">-fsyntax-only</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-fsyntax-only" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Run the preprocessor, parser and type checking stages.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-S">
+<tt class="descname">-S</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-S" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Run the previous stages as well as LLVM generation and optimization stages
+and target-specific code generation, producing an assembly file.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-c">
+<tt class="descname">-c</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-c" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Run all of the above, plus the assembler, generating a target ”.o” object file.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-arg-no">
+<tt class="descname">no</tt><tt class="descclassname"> stage selection option</tt><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">
+<tt class="descname">-x</tt><tt class="descclassname"> <language></tt><a class="headerlink" href="#cmdoption-x" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Treat subsequent input files as having type language.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-std">
+<tt class="descname">-std</tt><tt class="descclassname">=<language></tt><a class="headerlink" href="#cmdoption-std" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Specify the language standard to compile for.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-stdlib">
+<tt class="descname">-stdlib</tt><tt class="descclassname">=<library></tt><a class="headerlink" href="#cmdoption-stdlib" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Specify the C++ standard library to use; supported options are libstdc++ and
+libc++. If not specified, platform default will be used.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-rtlib">
+<tt class="descname">-rtlib</tt><tt class="descclassname">=<library></tt><a class="headerlink" href="#cmdoption-rtlib" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Specify the compiler runtime library to use; supported options are libgcc and
+compiler-rt. If not specified, platform default will be used.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-ansi">
+<tt class="descname">-ansi</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-ansi" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Same as -std=c89.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-ObjC">
+<span id="cmdoption-ObjC"></span><tt class="descname">-ObjC</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-ObjC</tt><tt class="descclassname">++</tt><a class="headerlink" href="#cmdoption-ObjC" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Treat source input files as Objective-C and Object-C++ inputs respectively.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-trigraphs">
+<tt class="descname">-trigraphs</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-trigraphs" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Enable trigraphs.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-ffreestanding">
+<tt class="descname">-ffreestanding</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-ffreestanding" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Indicate that the file should be compiled for a freestanding, not a hosted,
+environment.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fno-builtin">
+<tt class="descname">-fno-builtin</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-fno-builtin" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Disable special handling and optimizations of builtin functions like
+<tt class="xref c c-func docutils literal"><span class="pre">strlen()</span></tt> and <tt class="xref c c-func docutils literal"><span class="pre">malloc()</span></tt>.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fmath-errno">
+<tt class="descname">-fmath-errno</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-fmath-errno" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Indicate that math functions should be treated as updating <tt class="xref c c-data docutils literal"><span class="pre">errno</span></tt>.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fpascal-strings">
+<tt class="descname">-fpascal-strings</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-fpascal-strings" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Enable support for Pascal-style strings with “\pfoo”.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fms-extensions">
+<tt class="descname">-fms-extensions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-fms-extensions" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Enable support for Microsoft extensions.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fmsc-version">
+<tt class="descname">-fmsc-version</tt><tt class="descclassname">=</tt><a class="headerlink" href="#cmdoption-fmsc-version" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Set _MSC_VER. Defaults to 1300 on Windows. Not set otherwise.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fborland-extensions">
+<tt class="descname">-fborland-extensions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-fborland-extensions" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Enable support for Borland extensions.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fwritable-strings">
+<tt class="descname">-fwritable-strings</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-fwritable-strings" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Make all string literals default to writable.  This disables uniquing of
+strings and other optimizations.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-flax-vector-conversions">
+<tt class="descname">-flax-vector-conversions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-flax-vector-conversions" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Allow loose type checking rules for implicit vector conversions.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fblocks">
+<tt class="descname">-fblocks</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-fblocks" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Enable the “Blocks” language feature.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fobjc-abi-version">
+<tt class="descname">-fobjc-abi-version</tt><tt class="descclassname">=version</tt><a class="headerlink" href="#cmdoption-fobjc-abi-version" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Select the Objective-C ABI version to use. Available versions are 1 (legacy
+“fragile” ABI), 2 (non-fragile ABI 1), and 3 (non-fragile ABI 2).</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fobjc-nonfragile-abi-version">
+<tt class="descname">-fobjc-nonfragile-abi-version</tt><tt class="descclassname">=<version></tt><a class="headerlink" href="#cmdoption-fobjc-nonfragile-abi-version" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Select the Objective-C non-fragile ABI version to use by default. This will
+only be used as the Objective-C ABI when the non-fragile ABI is enabled
+(either via <a class="reference internal" href="#cmdoption-fobjc-nonfragile-abi"><em class="xref std std-option">-fobjc-nonfragile-abi</em></a>, or because it is the platform
+default).</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fobjc-nonfragile-abi">
+<span id="cmdoption-fno-objc-nonfragile-abi"></span><tt class="descname">-fobjc-nonfragile-abi</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-objc-nonfragile-abi</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-fobjc-nonfragile-abi" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Enable use of the Objective-C non-fragile ABI. On platforms for which this is
+the default ABI, it can be disabled with <a class="reference internal" href="#cmdoption-fno-objc-nonfragile-abi"><em class="xref std std-option">-fno-objc-nonfragile-abi</em></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">
+<tt class="descname">-arch</tt><tt class="descclassname"> <architecture></tt><a class="headerlink" href="#cmdoption-arch" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Specify the architecture to build for.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-mmacosx-version-min">
+<tt class="descname">-mmacosx-version-min</tt><tt class="descclassname">=<version></tt><a class="headerlink" href="#cmdoption-mmacosx-version-min" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>When building for Mac OS X, specify the minimum version supported by your
+application.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-miphoneos-version-min">
+<tt class="descname">-miphoneos-version-min</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-miphoneos-version-min" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>When building for iPhone OS, specify the minimum version supported by your
+application.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-march">
+<tt class="descname">-march</tt><tt class="descclassname">=<cpu></tt><a class="headerlink" href="#cmdoption-march" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Specify that Clang should generate code for a specific processor family
+member and later.  For example, if you specify -march=i486, the compiler is
+allowed to generate instructions that are valid on i486 and later processors,
+but which may not exist on earlier ones.</p>
+</dd></dl>
+
+</div>
+<div class="section" id="code-generation-options">
+<h3>Code Generation Options<a class="headerlink" href="#code-generation-options" title="Permalink to this headline">Â¶</a></h3>
+<dl class="option">
+<dt id="cmdoption-O0">
+<span id="cmdoption-O1"></span><span id="cmdoption-O2"></span><span id="cmdoption-O3"></span><span id="cmdoption-Ofast"></span><span id="cmdoption-Os"></span><span id="cmdoption-Oz"></span><span id="cmdoption-Og"></span><span id="cmdoption-O"></span><span id="cmdoption-O4"></span><tt class="descname">-O0</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-O1</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-O2</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-O3</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-Ofast</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-Os</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-Oz</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-Og</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-O</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-O4</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-O0" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Specify which optimization level to use:</p>
+<blockquote>
+<div><p><a class="reference internal" href="#cmdoption-O0"><em class="xref std std-option">-O0</em></a> Means “no optimization”: this level compiles the fastest and
+generates the most debuggable code.</p>
+<p><a class="reference internal" href="#cmdoption-O1"><em class="xref std std-option">-O1</em></a> Somewhere between <a class="reference internal" href="#cmdoption-O0"><em class="xref std std-option">-O0</em></a> and <a class="reference internal" href="#cmdoption-O2"><em class="xref std std-option">-O2</em></a>.</p>
+<p><a class="reference internal" href="#cmdoption-O2"><em class="xref std std-option">-O2</em></a> Moderate level of optimization which enables most
+optimizations.</p>
+<p><a class="reference internal" href="#cmdoption-O3"><em class="xref std std-option">-O3</em></a> Like <a class="reference internal" href="#cmdoption-O2"><em class="xref std std-option">-O2</em></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-Ofast"><em class="xref std std-option">-Ofast</em></a> Enables all the optimizations from <a class="reference internal" href="#cmdoption-O3"><em class="xref std std-option">-O3</em></a> along
+with other aggressive optimizations that may violate strict compliance with
+language standards.</p>
+<p><a class="reference internal" href="#cmdoption-Os"><em class="xref std std-option">-Os</em></a> Like <a class="reference internal" href="#cmdoption-O2"><em class="xref std std-option">-O2</em></a> with extra optimizations to reduce code
+size.</p>
+<p><a class="reference internal" href="#cmdoption-Oz"><em class="xref std std-option">-Oz</em></a> Like <a class="reference internal" href="#cmdoption-Os"><em class="xref std std-option">-Os</em></a> (and thus <a class="reference internal" href="#cmdoption-O2"><em class="xref std std-option">-O2</em></a>), but reduces code
+size further.</p>
+<p><a class="reference internal" href="#cmdoption-Og"><em class="xref std std-option">-Og</em></a> Like <a class="reference internal" href="#cmdoption-O1"><em class="xref std std-option">-O1</em></a>. In future versions, this option might
+disable different optimizations in order to improve debuggability.</p>
+<p><a class="reference internal" href="#cmdoption-O"><em class="xref std std-option">-O</em></a> Equivalent to <a class="reference internal" href="#cmdoption-O2"><em class="xref std std-option">-O2</em></a>.</p>
+<p><a class="reference internal" href="#cmdoption-O4"><em class="xref std std-option">-O4</em></a> and higher</p>
+<blockquote>
+<div>Currently equivalent to <a class="reference internal" href="#cmdoption-O3"><em class="xref std std-option">-O3</em></a></div></blockquote>
+</div></blockquote>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-g">
+<span id="cmdoption-gline-tables-only"></span><span id="cmdoption-gmodules"></span><tt class="descname">-g</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-gline-tables-only</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-gmodules</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-g" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Control debug information output.  Note that Clang debug information works
+best at <a class="reference internal" href="#cmdoption-O0"><em class="xref std std-option">-O0</em></a>.  When more than one option starting with <cite>-g</cite> is
+specified, the last one wins:</p>
+<blockquote>
+<div><p><a class="reference internal" href="../UsersManual.html#cmdoption-g"><em class="xref std std-option">-g</em></a> Generate debug information.</p>
+<p><a class="reference internal" href="../UsersManual.html#cmdoption-gline-tables-only"><em class="xref std std-option">-gline-tables-only</em></a> Generate only line table debug information. This
+allows for symbolicated backtraces with inlining information, but does not
+include any information about variables, their locations or types.</p>
+<p><a class="reference internal" href="#cmdoption-gmodules"><em class="xref std std-option">-gmodules</em></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">
+<tt class="descname">-fstandalone-debug</tt><tt class="descclassname"> -fno-standalone-debug</tt><a class="headerlink" href="#cmdoption-fstandalone-debug" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Clang supports a number of optimizations to reduce the size of debug
+information in the binary. They work based on the assumption that the
+debug type information can be spread out over multiple compilation units.
+For instance, Clang will not emit type definitions for types that are not
+needed by a module and could be replaced with a forward declaration.
+Further, Clang will only emit type info for a dynamic C++ class in the
+module that contains the vtable for the class.</p>
+<p>The <a class="reference internal" href="../UsersManual.html#cmdoption-fstandalone-debug"><em class="xref std std-option">-fstandalone-debug</em></a> option turns off these optimizations.
+This is useful when working with 3rd-party libraries that don’t come with
+debug information.  This is the default on Darwin.  Note that Clang will
+never emit type information for types that are not referenced at all by the
+program.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fexceptions">
+<tt class="descname">-fexceptions</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-fexceptions" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Enable generation of unwind information. This allows exceptions to be thrown
+through Clang compiled stack frames.  This is on by default in x86-64.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-ftrapv">
+<tt class="descname">-ftrapv</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-ftrapv" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Generate code to catch integer overflow errors.  Signed integer overflow is
+undefined in C. With this flag, extra code is generated to detect this and
+abort when it happens.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fvisibility">
+<tt class="descname">-fvisibility</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-fvisibility" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>This flag sets the default visibility level.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-fcommon">
+<span id="cmdoption-fno-common"></span><tt class="descname">-fcommon</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fno-common</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-fcommon" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>This flag specifies that variables without initializers get common linkage.
+It can be disabled with <a class="reference internal" href="#cmdoption-fno-common"><em class="xref std std-option">-fno-common</em></a>.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-ftls-model">
+<tt class="descname">-ftls-model</tt><tt class="descclassname">=<model></tt><a class="headerlink" href="#cmdoption-ftls-model" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Set the default thread-local storage (TLS) model to use for thread-local
+variables. Valid values are: “global-dynamic”, “local-dynamic”,
+“initial-exec” and “local-exec”. The default is “global-dynamic”. The default
+model can be overridden with the tls_model attribute. The compiler will try
+to choose a more efficient model if possible.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-flto">
+<span id="cmdoption-flto"></span><span id="cmdoption-flto"></span><span id="cmdoption-emit-llvm"></span><tt class="descname">-flto</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-flto</tt><tt class="descclassname">=full</tt><tt class="descclassname">, </tt><tt class="descname">-flto</tt><tt class="descclassname">=thin</tt><tt class="descclassname">, </tt><tt class="descname">-emit-llvm</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-flto" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Generate output files in LLVM formats, suitable for link time optimization.
+When used with <a class="reference internal" href="#cmdoption-S"><em class="xref std std-option">-S</em></a> this generates LLVM intermediate language
+assembly files, otherwise this generates LLVM bitcode format object files
+(which may be passed to the linker depending on the stage selection options).</p>
+<p>The default for <a class="reference internal" href="#cmdoption-flto"><em class="xref std std-option">-flto</em></a> is “full”, in which the
+LLVM bitcode is suitable for monolithic Link Time Optimization (LTO), where
+the linker merges all such modules into a single combined module for
+optimization. With “thin”, <a class="reference internal" href="../ThinLTO.html"><em>ThinLTO</em></a>
+compilation is invoked instead.</p>
+</dd></dl>
+
+</div>
+<div class="section" id="driver-options">
+<h3>Driver Options<a class="headerlink" href="#driver-options" title="Permalink to this headline">Â¶</a></h3>
+<dl class="option">
+<dt id="cmdoption-">
+<tt class="descname">-</tt><tt class="descclassname">###</tt><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">
+<tt class="descname">--help</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption--help" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Display available options.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-Qunused-arguments">
+<tt class="descname">-Qunused-arguments</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-Qunused-arguments" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Do not emit any warnings for unused driver arguments.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-Wa">
+<tt class="descname">-Wa</tt><tt class="descclassname">,<args></tt><a class="headerlink" href="#cmdoption-Wa" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Pass the comma separated arguments in args to the assembler.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-Wl">
+<tt class="descname">-Wl</tt><tt class="descclassname">,<args></tt><a class="headerlink" href="#cmdoption-Wl" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Pass the comma separated arguments in args to the linker.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-Wp">
+<tt class="descname">-Wp</tt><tt class="descclassname">,<args></tt><a class="headerlink" href="#cmdoption-Wp" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Pass the comma separated arguments in args to the preprocessor.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-Xanalyzer">
+<tt class="descname">-Xanalyzer</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-Xanalyzer" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Pass arg to the static analyzer.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-Xassembler">
+<tt class="descname">-Xassembler</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-Xassembler" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Pass arg to the assembler.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-Xlinker">
+<tt class="descname">-Xlinker</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-Xlinker" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Pass arg to the linker.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-Xpreprocessor">
+<tt class="descname">-Xpreprocessor</tt><tt class="descclassname"> <arg></tt><a class="headerlink" href="#cmdoption-Xpreprocessor" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Pass arg to the preprocessor.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-o">
+<tt class="descname">-o</tt><tt class="descclassname"> <file></tt><a class="headerlink" href="#cmdoption-o" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Write output to file.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-print-file-name">
+<tt class="descname">-print-file-name</tt><tt class="descclassname">=<file></tt><a class="headerlink" href="#cmdoption-print-file-name" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Print the full library path of file.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-print-libgcc-file-name">
+<tt class="descname">-print-libgcc-file-name</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-print-libgcc-file-name" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Print the library path for the currently used compiler runtime library
+(“libgcc.a” or “libclang_rt.builtins.*.a”).</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-print-prog-name">
+<tt class="descname">-print-prog-name</tt><tt class="descclassname">=<name></tt><a class="headerlink" href="#cmdoption-print-prog-name" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Print the full program path of name.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-print-search-dirs">
+<tt class="descname">-print-search-dirs</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-print-search-dirs" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Print the paths used for finding libraries and programs.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-save-temps">
+<tt class="descname">-save-temps</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-save-temps" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Save intermediate compilation results.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-save-stats">
+<span id="cmdoption-save-stats"></span><span id="cmdoption-save-stats"></span><tt class="descname">-save-stats</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-save-stats</tt><tt class="descclassname">=cwd</tt><tt class="descclassname">, </tt><tt class="descname">-save-stats</tt><tt class="descclassname">=obj</tt><a class="headerlink" href="#cmdoption-save-stats" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Save internal code generation (LLVM) statistics to a file in the current
+directory (<a class="reference internal" href="#cmdoption-save-stats"><em class="xref std std-option">-save-stats</em></a>/”-save-stats=cwd”) or the directory
+of the output file (“-save-state=obj”).</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-integrated-as">
+<span id="cmdoption-no-integrated-as"></span><tt class="descname">-integrated-as</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-no-integrated-as</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-integrated-as" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Used to enable and disable, respectively, the use of the integrated
+assembler. Whether the integrated assembler is on by default is target
+dependent.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-time">
+<tt class="descname">-time</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-time" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Time individual commands.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-ftime-report">
+<tt class="descname">-ftime-report</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-ftime-report" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Print timing summary of each stage of compilation.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-v">
+<tt class="descname">-v</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-v" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Show commands to run and use verbose output.</p>
+</dd></dl>
+
+</div>
+<div class="section" id="diagnostics-options">
+<h3>Diagnostics Options<a class="headerlink" href="#diagnostics-options" title="Permalink to this headline">Â¶</a></h3>
+<dl class="option">
+<dt id="cmdoption-fshow-column">
+<span id="cmdoption-fshow-source-location"></span><span id="cmdoption-fcaret-diagnostics"></span><span id="cmdoption-fdiagnostics-fixit-info"></span><span id="cmdoption-fdiagnostics-parseable-fixits"></span><span id="cmdoption-fdiagnostics-print-source-range-info"></span><span id="cmdoption-fprint-source-range-info"></span><span id="cmdoption-fdiagnostics-show-option"></span><span id="cmdoption-fmessage-length"></span><tt class="descname">-fshow-column</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fshow-source-location</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fcaret-diagnostics</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fdiagnostics-fixit-info</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fdiagnostics-parseable-fixits</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fdiagnostics-print-source-range-info</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fprint-source-range-info</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fdiagnostics-show-option</tt><tt class="descclassname"></tt><tt class="descclassname">, </tt><tt class="descname">-fmessage-length</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-fshow-column" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>These options control how Clang prints out information about diagnostics
+(errors and warnings). Please see the Clang User’s Manual for more information.</p>
+</dd></dl>
+
+</div>
+<div class="section" id="preprocessor-options">
+<h3>Preprocessor Options<a class="headerlink" href="#preprocessor-options" title="Permalink to this headline">Â¶</a></h3>
+<dl class="option">
+<dt id="cmdoption-D">
+<tt class="descname">-D</tt><tt class="descclassname"><macroname>=<value></tt><a class="headerlink" href="#cmdoption-D" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Adds an implicit #define into the predefines buffer which is read before the
+source file is preprocessed.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-U">
+<tt class="descname">-U</tt><tt class="descclassname"><macroname></tt><a class="headerlink" href="#cmdoption-U" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Adds an implicit #undef into the predefines buffer which is read before the
+source file is preprocessed.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-include">
+<tt class="descname">-include</tt><tt class="descclassname"> <filename></tt><a class="headerlink" href="#cmdoption-include" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Adds an implicit #include into the predefines buffer which is read before the
+source file is preprocessed.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-I">
+<tt class="descname">-I</tt><tt class="descclassname"><directory></tt><a class="headerlink" href="#cmdoption-I" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Add the specified directory to the search path for include files.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-F">
+<tt class="descname">-F</tt><tt class="descclassname"><directory></tt><a class="headerlink" href="#cmdoption-F" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Add the specified directory to the search path for framework include files.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-nostdinc">
+<tt class="descname">-nostdinc</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-nostdinc" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Do not search the standard system directories or compiler builtin directories
+for include files.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-nostdlibinc">
+<tt class="descname">-nostdlibinc</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-nostdlibinc" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Do not search the standard system directories for include files, but do
+search compiler builtin include directories.</p>
+</dd></dl>
+
+<dl class="option">
+<dt id="cmdoption-nobuiltininc">
+<tt class="descname">-nobuiltininc</tt><tt class="descclassname"></tt><a class="headerlink" href="#cmdoption-nobuiltininc" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>Do not search clang’s builtin directory for include files.</p>
+</dd></dl>
+
+</div>
+</div>
+<div class="section" id="environment">
+<h2>ENVIRONMENT<a class="headerlink" href="#environment" title="Permalink to this headline">Â¶</a></h2>
+<dl class="envvar">
+<dt id="envvar-TMPDIR,TEMP,TMP">
+<tt class="descname">TMPDIR, TEMP, TMP</tt><a class="headerlink" href="#envvar-TMPDIR,TEMP,TMP" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>These environment variables are checked, in order, for the location to write
+temporary files used during the compilation process.</p>
+</dd></dl>
+
+<dl class="envvar">
+<dt id="envvar-CPATH">
+<tt class="descname">CPATH</tt><a class="headerlink" href="#envvar-CPATH" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>If this environment variable is present, it is treated as a delimited list of
+paths to be added to the default system include path list. The delimiter is
+the platform dependent delimiter, as used in the PATH environment variable.</p>
+<p>Empty components in the environment variable are ignored.</p>
+</dd></dl>
+
+<dl class="envvar">
+<dt id="envvar-C_INCLUDE_PATH,OBJC_INCLUDE_PATH,CPLUS_INCLUDE_PATH,OBJCPLUS_INCLUDE_PATH">
+<tt class="descname">C_INCLUDE_PATH, OBJC_INCLUDE_PATH, CPLUS_INCLUDE_PATH, OBJCPLUS_INCLUDE_PATH</tt><a class="headerlink" href="#envvar-C_INCLUDE_PATH,OBJC_INCLUDE_PATH,CPLUS_INCLUDE_PATH,OBJCPLUS_INCLUDE_PATH" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>These environment variables specify additional paths, as for <span class="target" id="index-0"></span><a class="reference internal" href="#envvar-CPATH"><tt class="xref std std-envvar docutils literal"><span class="pre">CPATH</span></tt></a>, which are
+only used when processing the appropriate language.</p>
+</dd></dl>
+
+<dl class="envvar">
+<dt id="envvar-MACOSX_DEPLOYMENT_TARGET">
+<tt class="descname">MACOSX_DEPLOYMENT_TARGET</tt><a class="headerlink" href="#envvar-MACOSX_DEPLOYMENT_TARGET" title="Permalink to this definition">Â¶</a></dt>
+<dd><p>If <a class="reference internal" href="#cmdoption-mmacosx-version-min"><em class="xref std std-option">-mmacosx-version-min</em></a> is unspecified, the default deployment
+target is read from this environment variable. This option only affects
+Darwin targets.</p>
+</dd></dl>
+
+</div>
+<div class="section" id="bugs">
+<h2>BUGS<a class="headerlink" href="#bugs" title="Permalink to this headline">Â¶</a></h2>
+<p>To report bugs, please visit <<a class="reference external" href="http://llvm.org/bugs/">http://llvm.org/bugs/</a>>.  Most bug reports should
+include preprocessed source files (use the <a class="reference internal" href="#cmdoption-E"><em class="xref std std-option">-E</em></a> option) and the full
+output of the compiler, along with information to reproduce.</p>
+</div>
+<div class="section" id="see-also">
+<h2>SEE ALSO<a class="headerlink" href="#see-also" title="Permalink to this headline">Â¶</a></h2>
+<p><em class="manpage">as(1)</em>, <em class="manpage">ld(1)</em></p>
+</div>
+</div>
+
+
+      </div>
+      <div class="bottomnav">
+      
+        <p>
+        Â«  <a href="index.html">Clang “man” pages</a>
+          ::  
+        <a class="uplink" href="../index.html">Contents</a>
+          ::  
+        <a href="../FAQ.html">Frequently Asked Questions (FAQ)</a>  Â»
+        </p>
+
+      </div>
+
+    <div class="footer">
+        © Copyright 2007-2017, The Clang Team.
+      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.2.2.
+    </div>
+  </body>
+</html>
\ No newline at end of file

Added: www-releases/trunk/5.0.0/tools/clang/docs/CommandGuide/index.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/5.0.0/tools/clang/docs/CommandGuide/index.html?rev=312731&view=auto
==============================================================================
--- www-releases/trunk/5.0.0/tools/clang/docs/CommandGuide/index.html (added)
+++ www-releases/trunk/5.0.0/tools/clang/docs/CommandGuide/index.html Thu Sep  7 10:47:16 2017
@@ -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 5 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:     '5',
+        COLLAPSE_INDEX: false,
+        FILE_SUFFIX: '.html',
+        HAS_SOURCE:  true
+      };
+    </script>
+    <script type="text/javascript" src="../_static/jquery.js"></script>
+    <script type="text/javascript" src="../_static/underscore.js"></script>
+    <script type="text/javascript" src="../_static/doctools.js"></script>
+    <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+    <link rel="top" title="Clang 5 documentation" href="../index.html" />
+    <link rel="next" title="clang - the Clang C, C++, and Objective-C compiler" href="clang.html" />
+    <link rel="prev" title="ThinLTO" href="../ThinLTO.html" /> 
+  </head>
+  <body>
+      <div class="header"><h1 class="heading"><a href="../index.html">
+          <span>Clang 5 documentation</span></a></h1>
+        <h2 class="heading"><span>Clang âmanâ pages</span></h2>
+      </div>
+      <div class="topnav">
+      
+        <p>
+        Â«  <a href="../ThinLTO.html">ThinLTO</a>
+          ::  
+        <a class="uplink" href="../index.html">Contents</a>
+          ::  
+        <a href="clang.html">clang - the Clang C, C++, and Objective-C compiler</a>  Â»
+        </p>
+
+      </div>
+      <div class="content">
+        
+        
+  <div class="section" id="clang-man-pages">
+<h1>Clang “man” pages<a class="headerlink" href="#clang-man-pages" title="Permalink to this headline">Â¶</a></h1>
+<p>The following documents are command descriptions for all of the Clang tools.
+These pages describe how to use the Clang commands and what their options are.
+Note that these pages do not describe all of the options available for all
+tools. To get a complete listing, pass the <tt class="docutils literal"><span class="pre">--help</span></tt> (general options) or
+<tt class="docutils literal"><span class="pre">--help-hidden</span></tt> (general and debugging options) arguments to the tool you are
+interested in.</p>
+<div class="section" id="basic-commands">
+<h2>Basic Commands<a class="headerlink" href="#basic-commands" title="Permalink to this headline">Â¶</a></h2>
+<div class="toctree-wrapper compound">
+<ul>
+<li class="toctree-l1"><a class="reference internal" href="clang.html">clang - the Clang C, C++, and Objective-C compiler</a></li>
+</ul>
+</div>
+</div>
+</div>
+
+
+      </div>
+      <div class="bottomnav">
+      
+        <p>
+        Â«  <a href="../ThinLTO.html">ThinLTO</a>
+          ::  
+        <a class="uplink" href="../index.html">Contents</a>
+          ::  
+        <a href="clang.html">clang - the Clang C, C++, and Objective-C compiler</a>  Â»
+        </p>
+
+      </div>
+
+    <div class="footer">
+        © Copyright 2007-2017, The Clang Team.
+      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.2.2.
+    </div>
+  </body>
+</html>
\ No newline at end of file

Added: www-releases/trunk/5.0.0/tools/clang/docs/ControlFlowIntegrity.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/5.0.0/tools/clang/docs/ControlFlowIntegrity.html?rev=312731&view=auto
==============================================================================
--- www-releases/trunk/5.0.0/tools/clang/docs/ControlFlowIntegrity.html (added)
+++ www-releases/trunk/5.0.0/tools/clang/docs/ControlFlowIntegrity.html Thu Sep  7 10:47:16 2017
@@ -0,0 +1,322 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    
+    <title>Control Flow Integrity — Clang 5 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:     '5',
+        COLLAPSE_INDEX: false,
+        FILE_SUFFIX: '.html',
+        HAS_SOURCE:  true
+      };
+    </script>
+    <script type="text/javascript" src="_static/jquery.js"></script>
+    <script type="text/javascript" src="_static/underscore.js"></script>
+    <script type="text/javascript" src="_static/doctools.js"></script>
+    <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+    <link rel="top" title="Clang 5 documentation" href="index.html" />
+    <link rel="next" title="Control Flow Integrity Design Documentation" href="ControlFlowIntegrityDesign.html" />
+    <link rel="prev" title="Sanitizer special case list" href="SanitizerSpecialCaseList.html" /> 
+  </head>
+  <body>
+      <div class="header"><h1 class="heading"><a href="index.html">
+          <span>Clang 5 documentation</span></a></h1>
+        <h2 class="heading"><span>Control Flow Integrity</span></h2>
+      </div>
+      <div class="topnav">
+      
+        <p>
+        Â«  <a href="SanitizerSpecialCaseList.html">Sanitizer special case list</a>
+          ::  
+        <a class="uplink" href="index.html">Contents</a>
+          ::  
+        <a href="ControlFlowIntegrityDesign.html">Control Flow Integrity Design Documentation</a>  Â»
+        </p>
+
+      </div>
+      <div class="content">
+        
+        
+  <div class="section" id="control-flow-integrity">
+<h1>Control Flow Integrity<a class="headerlink" href="#control-flow-integrity" title="Permalink to this headline">Â¶</a></h1>
+<div class="toctree-wrapper compound">
+</div>
+<div class="contents local topic" id="contents">
+<ul class="simple">
+<li><a class="reference internal" href="#introduction" id="id1">Introduction</a></li>
+<li><a class="reference internal" href="#available-schemes" id="id2">Available schemes</a></li>
+<li><a class="reference internal" href="#trapping-and-diagnostics" id="id3">Trapping and Diagnostics</a></li>
+<li><a class="reference internal" href="#forward-edge-cfi-for-virtual-calls" id="id4">Forward-Edge CFI for Virtual Calls</a><ul>
+<li><a class="reference internal" href="#performance" id="id5">Performance</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#bad-cast-checking" id="id6">Bad Cast Checking</a></li>
+<li><a class="reference internal" href="#non-virtual-member-function-call-checking" id="id7">Non-Virtual Member Function Call Checking</a><ul>
+<li><a class="reference internal" href="#strictness" id="id8">Strictness</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#indirect-function-call-checking" id="id9">Indirect Function Call Checking</a><ul>
+<li><a class="reference internal" href="#fsanitize-cfi-icall-and-fsanitize-function" id="id10"><tt class="docutils literal"><span class="pre">-fsanitize=cfi-icall</span></tt> and <tt class="docutils literal"><span class="pre">-fsanitize=function</span></tt></a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#blacklist" id="id11">Blacklist</a></li>
+<li><a class="reference internal" href="#shared-library-support" id="id12">Shared library support</a></li>
+<li><a class="reference internal" href="#design" id="id13">Design</a></li>
+<li><a class="reference internal" href="#publications" id="id14">Publications</a></li>
+</ul>
+</div>
+<div class="section" id="introduction">
+<h2><a class="toc-backref" href="#id1">Introduction</a><a class="headerlink" href="#introduction" title="Permalink to this headline">Â¶</a></h2>
+<p>Clang includes an implementation of a number of control flow integrity (CFI)
+schemes, which are designed to abort the program upon detecting certain forms
+of undefined behavior that can potentially allow attackers to subvert the
+program’s control flow. These schemes have been optimized for performance,
+allowing developers to enable them in release builds.</p>
+<p>To enable Clang’s available CFI schemes, use the flag <tt class="docutils literal"><span class="pre">-fsanitize=cfi</span></tt>.
+You can also enable a subset of available <a class="reference internal" href="#cfi-schemes"><em>schemes</em></a>.
+As currently implemented, all schemes rely on link-time optimization (LTO);
+so it is required to specify <tt class="docutils literal"><span class="pre">-flto</span></tt>, and the linker used must support LTO,
+for example via the <a class="reference external" href="http://llvm.org/docs/GoldPlugin.html">gold plugin</a>.</p>
+<p>To allow the checks to be implemented efficiently, the program must
+be structured such that certain object files are compiled with CFI
+enabled, and are statically linked into the program. This may preclude
+the use of shared libraries in some cases.</p>
+<p>The compiler will only produce CFI checks for a class if it can infer hidden
+LTO visibility for that class. LTO visibility is a property of a class that
+is inferred from flags and attributes. For more details, see the documentation
+for <a class="reference internal" href="LTOVisibility.html"><em>LTO visibility</em></a>.</p>
+<p>The <tt class="docutils literal"><span class="pre">-fsanitize=cfi-{vcall,nvcall,derived-cast,unrelated-cast}</span></tt> flags
+require that a <tt class="docutils literal"><span class="pre">-fvisibility=</span></tt> flag also be specified. This is because the
+default visibility setting is <tt class="docutils literal"><span class="pre">-fvisibility=default</span></tt>, which would disable
+CFI checks for classes without visibility attributes. Most users will want
+to specify <tt class="docutils literal"><span class="pre">-fvisibility=hidden</span></tt>, which enables CFI checks for such classes.</p>
+<p>Experimental support for <a class="reference internal" href="#cfi-cross-dso"><em>cross-DSO control flow integrity</em></a> exists that does not require classes to have hidden LTO
+visibility. This cross-DSO support has unstable ABI at this time.</p>
+</div>
+<div class="section" id="available-schemes">
+<span id="cfi-schemes"></span><h2><a class="toc-backref" href="#id2">Available schemes</a><a class="headerlink" href="#available-schemes" title="Permalink to this headline">Â¶</a></h2>
+<p>Available schemes are:</p>
+<blockquote>
+<div><ul class="simple">
+<li><tt class="docutils literal"><span class="pre">-fsanitize=cfi-cast-strict</span></tt>: Enables <a class="reference internal" href="#cfi-strictness"><em>strict cast checks</em></a>.</li>
+<li><tt class="docutils literal"><span class="pre">-fsanitize=cfi-derived-cast</span></tt>: Base-to-derived cast to the wrong
+dynamic type.</li>
+<li><tt class="docutils literal"><span class="pre">-fsanitize=cfi-unrelated-cast</span></tt>: Cast from <tt class="docutils literal"><span class="pre">void*</span></tt> or another
+unrelated type to the wrong dynamic type.</li>
+<li><tt class="docutils literal"><span class="pre">-fsanitize=cfi-nvcall</span></tt>: Non-virtual call via an object whose vptr is of
+the wrong dynamic type.</li>
+<li><tt class="docutils literal"><span class="pre">-fsanitize=cfi-vcall</span></tt>: Virtual call via an object whose vptr is of the
+wrong dynamic type.</li>
+<li><tt class="docutils literal"><span class="pre">-fsanitize=cfi-icall</span></tt>: Indirect call of a function with wrong dynamic
+type.</li>
+</ul>
+</div></blockquote>
+<p>You can use <tt class="docutils literal"><span class="pre">-fsanitize=cfi</span></tt> to enable all the schemes and use
+<tt class="docutils literal"><span class="pre">-fno-sanitize</span></tt> flag to narrow down the set of schemes as desired.
+For example, you can build your program with
+<tt class="docutils literal"><span class="pre">-fsanitize=cfi</span> <span class="pre">-fno-sanitize=cfi-nvcall,cfi-icall</span></tt>
+to use all schemes except for non-virtual member function call and indirect call
+checking.</p>
+<p>Remember that you have to provide <tt class="docutils literal"><span class="pre">-flto</span></tt> if at least one CFI scheme is
+enabled.</p>
+</div>
+<div class="section" id="trapping-and-diagnostics">
+<h2><a class="toc-backref" href="#id3">Trapping and Diagnostics</a><a class="headerlink" href="#trapping-and-diagnostics" title="Permalink to this headline">Â¶</a></h2>
+<p>By default, CFI will abort the program immediately upon detecting a control
+flow integrity violation. You can use the <a class="reference internal" href="UsersManual.html#controlling-code-generation"><em>-fno-sanitize-trap=</em></a> flag to cause CFI to print a diagnostic
+similar to the one below before the program aborts.</p>
+<div class="highlight-console"><div class="highlight"><pre><span></span><span class="go">bad-cast.cpp:109:7: runtime error: control flow integrity check for type 'B' failed during base-to-derived cast (vtable address 0x000000425a50)</span>
+<span class="go">0x000000425a50: note: vtable is of type 'A'</span>
+<span class="go"> 00 00 00 00  f0 f1 41 00 00 00 00 00  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  20 5a 42 00</span>
+<span class="go">              ^</span>
+</pre></div>
+</div>
+<p>If diagnostics are enabled, you can also configure CFI to continue program
+execution instead of aborting by using the <a class="reference internal" href="UsersManual.html#controlling-code-generation"><em>-fsanitize-recover=</em></a> flag.</p>
+</div>
+<div class="section" id="forward-edge-cfi-for-virtual-calls">
+<h2><a class="toc-backref" href="#id4">Forward-Edge CFI for Virtual Calls</a><a class="headerlink" href="#forward-edge-cfi-for-virtual-calls" title="Permalink to this headline">Â¶</a></h2>
+<p>This scheme checks that virtual calls take place using a vptr of the correct
+dynamic type; that is, the dynamic type of the called object must be a
+derived class of the static type of the object used to make the call.
+This CFI scheme can be enabled on its own using <tt class="docutils literal"><span class="pre">-fsanitize=cfi-vcall</span></tt>.</p>
+<p>For this scheme to work, all translation units containing the definition
+of a virtual member function (whether inline or not), other than members
+of <a class="reference internal" href="#cfi-blacklist"><em>blacklisted</em></a> types, must be compiled with
+<tt class="docutils literal"><span class="pre">-fsanitize=cfi-vcall</span></tt> enabled and be statically linked into the program.</p>
+<div class="section" id="performance">
+<h3><a class="toc-backref" href="#id5">Performance</a><a class="headerlink" href="#performance" title="Permalink to this headline">Â¶</a></h3>
+<p>A performance overhead of less than 1% has been measured by running the
+Dromaeo benchmark suite against an instrumented version of the Chromium
+web browser. Another good performance benchmark for this mechanism is the
+virtual-call-heavy SPEC 2006 xalancbmk.</p>
+<p>Note that this scheme has not yet been optimized for binary size; an increase
+of up to 15% has been observed for Chromium.</p>
+</div>
+</div>
+<div class="section" id="bad-cast-checking">
+<h2><a class="toc-backref" href="#id6">Bad Cast Checking</a><a class="headerlink" href="#bad-cast-checking" title="Permalink to this headline">Â¶</a></h2>
+<p>This scheme checks that pointer casts are made to an object of the correct
+dynamic type; that is, the dynamic type of the object must be a derived class
+of the pointee type of the cast. The checks are currently only introduced
+where the class being casted to is a polymorphic class.</p>
+<p>Bad casts are not in themselves control flow integrity violations, but they
+can also create security vulnerabilities, and the implementation uses many
+of the same mechanisms.</p>
+<p>There are two types of bad cast that may be forbidden: bad casts
+from a base class to a derived class (which can be checked with
+<tt class="docutils literal"><span class="pre">-fsanitize=cfi-derived-cast</span></tt>), and bad casts from a pointer of
+type <tt class="docutils literal"><span class="pre">void*</span></tt> or another unrelated type (which can be checked with
+<tt class="docutils literal"><span class="pre">-fsanitize=cfi-unrelated-cast</span></tt>).</p>
+<p>The difference between these two types of casts is that the first is defined
+by the C++ standard to produce an undefined value, while the second is not
+in itself undefined behavior (it is well defined to cast the pointer back
+to its original type) unless the object is uninitialized and the cast is a
+<tt class="docutils literal"><span class="pre">static_cast</span></tt> (see C++14 [basic.life]p5).</p>
+<p>If a program as a matter of policy forbids the second type of cast, that
+restriction can normally be enforced. However it may in some cases be necessary
+for a function to perform a forbidden cast to conform with an external API
+(e.g. the <tt class="docutils literal"><span class="pre">allocate</span></tt> member function of a standard library allocator). Such
+functions may be <a class="reference internal" href="#cfi-blacklist"><em>blacklisted</em></a>.</p>
+<p>For this scheme to work, all translation units containing the definition
+of a virtual member function (whether inline or not), other than members
+of <a class="reference internal" href="#cfi-blacklist"><em>blacklisted</em></a> types, must be compiled with
+<tt class="docutils literal"><span class="pre">-fsanitize=cfi-derived-cast</span></tt> or <tt class="docutils literal"><span class="pre">-fsanitize=cfi-unrelated-cast</span></tt> enabled
+and be statically linked into the program.</p>
+</div>
+<div class="section" id="non-virtual-member-function-call-checking">
+<h2><a class="toc-backref" href="#id7">Non-Virtual Member Function Call Checking</a><a class="headerlink" href="#non-virtual-member-function-call-checking" title="Permalink to this headline">Â¶</a></h2>
+<p>This scheme checks that non-virtual calls take place using an object of
+the correct dynamic type; that is, the dynamic type of the called object
+must be a derived class of the static type of the object used to make the
+call. The checks are currently only introduced where the object is of a
+polymorphic class type.  This CFI scheme can be enabled on its own using
+<tt class="docutils literal"><span class="pre">-fsanitize=cfi-nvcall</span></tt>.</p>
+<p>For this scheme to work, all translation units containing the definition
+of a virtual member function (whether inline or not), other than members
+of <a class="reference internal" href="#cfi-blacklist"><em>blacklisted</em></a> types, must be compiled with
+<tt class="docutils literal"><span class="pre">-fsanitize=cfi-nvcall</span></tt> enabled and be statically linked into the program.</p>
+<div class="section" id="strictness">
+<span id="cfi-strictness"></span><h3><a class="toc-backref" href="#id8">Strictness</a><a class="headerlink" href="#strictness" title="Permalink to this headline">Â¶</a></h3>
+<p>If a class has a single non-virtual base and does not introduce or override
+virtual member functions or fields other than an implicitly defined virtual
+destructor, it will have the same layout and virtual function semantics as
+its base. By default, casts to such classes are checked as if they were made
+to the least derived such class.</p>
+<p>Casting an instance of a base class to such a derived class is technically
+undefined behavior, but it is a relatively common hack for introducing
+member functions on class instances with specific properties that works under
+most compilers and should not have security implications, so we allow it by
+default. It can be disabled with <tt class="docutils literal"><span class="pre">-fsanitize=cfi-cast-strict</span></tt>.</p>
+</div>
+</div>
+<div class="section" id="indirect-function-call-checking">
+<h2><a class="toc-backref" href="#id9">Indirect Function Call Checking</a><a class="headerlink" href="#indirect-function-call-checking" title="Permalink to this headline">Â¶</a></h2>
+<p>This scheme checks that function calls take place using a function of the
+correct dynamic type; that is, the dynamic type of the function must match
+the static type used at the call. This CFI scheme can be enabled on its own
+using <tt class="docutils literal"><span class="pre">-fsanitize=cfi-icall</span></tt>.</p>
+<p>For this scheme to work, each indirect function call in the program, other
+than calls in <a class="reference internal" href="#cfi-blacklist"><em>blacklisted</em></a> functions, must call a
+function which was either compiled with <tt class="docutils literal"><span class="pre">-fsanitize=cfi-icall</span></tt> enabled,
+or whose address was taken by a function in a translation unit compiled with
+<tt class="docutils literal"><span class="pre">-fsanitize=cfi-icall</span></tt>.</p>
+<p>If a function in a translation unit compiled with <tt class="docutils literal"><span class="pre">-fsanitize=cfi-icall</span></tt>
+takes the address of a function not compiled with <tt class="docutils literal"><span class="pre">-fsanitize=cfi-icall</span></tt>,
+that address may differ from the address taken by a function in a translation
+unit not compiled with <tt class="docutils literal"><span class="pre">-fsanitize=cfi-icall</span></tt>. This is technically a
+violation of the C and C++ standards, but it should not affect most programs.</p>
+<p>Each translation unit compiled with <tt class="docutils literal"><span class="pre">-fsanitize=cfi-icall</span></tt> must be
+statically linked into the program or shared library, and calls across
+shared library boundaries are handled as if the callee was not compiled with
+<tt class="docutils literal"><span class="pre">-fsanitize=cfi-icall</span></tt>.</p>
+<p>This scheme is currently only supported on the x86 and x86_64 architectures.</p>
+<div class="section" id="fsanitize-cfi-icall-and-fsanitize-function">
+<h3><a class="toc-backref" href="#id10"><tt class="docutils literal"><span class="pre">-fsanitize=cfi-icall</span></tt> and <tt class="docutils literal"><span class="pre">-fsanitize=function</span></tt></a><a class="headerlink" href="#fsanitize-cfi-icall-and-fsanitize-function" title="Permalink to this headline">Â¶</a></h3>
+<p>This tool is similar to <tt class="docutils literal"><span class="pre">-fsanitize=function</span></tt> in that both tools check
+the types of function calls. However, the two tools occupy different points
+on the design space; <tt class="docutils literal"><span class="pre">-fsanitize=function</span></tt> is a developer tool designed
+to find bugs in local development builds, whereas <tt class="docutils literal"><span class="pre">-fsanitize=cfi-icall</span></tt>
+is a security hardening mechanism designed to be deployed in release builds.</p>
+<p><tt class="docutils literal"><span class="pre">-fsanitize=function</span></tt> has a higher space and time overhead due to a more
+complex type check at indirect call sites, as well as a need for run-time
+type information (RTTI), which may make it unsuitable for deployment. Because
+of the need for RTTI, <tt class="docutils literal"><span class="pre">-fsanitize=function</span></tt> can only be used with C++
+programs, whereas <tt class="docutils literal"><span class="pre">-fsanitize=cfi-icall</span></tt> can protect both C and C++ programs.</p>
+<p>On the other hand, <tt class="docutils literal"><span class="pre">-fsanitize=function</span></tt> conforms more closely with the C++
+standard and user expectations around interaction with shared libraries;
+the identity of function pointers is maintained, and calls across shared
+library boundaries are no different from calls within a single program or
+shared library.</p>
+</div>
+</div>
+<div class="section" id="blacklist">
+<span id="cfi-blacklist"></span><h2><a class="toc-backref" href="#id11">Blacklist</a><a class="headerlink" href="#blacklist" title="Permalink to this headline">Â¶</a></h2>
+<p>A <a class="reference internal" href="SanitizerSpecialCaseList.html"><em>Sanitizer special case list</em></a> can be used to relax CFI checks for certain
+source files, functions and types using the <tt class="docutils literal"><span class="pre">src</span></tt>, <tt class="docutils literal"><span class="pre">fun</span></tt> and <tt class="docutils literal"><span class="pre">type</span></tt>
+entity types.</p>
+<div class="highlight-bash"><div class="highlight"><pre><span></span><span class="c1"># Suppress checking for code in a file.</span>
+src:bad_file.cpp
+src:bad_header.h
+<span class="c1"># Ignore all functions with names containing MyFooBar.</span>
+fun:*MyFooBar*
+<span class="c1"># Ignore all types in the standard library.</span>
+type:std::*
+</pre></div>
+</div>
+</div>
+<div class="section" id="shared-library-support">
+<span id="cfi-cross-dso"></span><h2><a class="toc-backref" href="#id12">Shared library support</a><a class="headerlink" href="#shared-library-support" title="Permalink to this headline">Â¶</a></h2>
+<p>Use <strong>-f[no-]sanitize-cfi-cross-dso</strong> to enable the cross-DSO control
+flow integrity mode, which allows all CFI schemes listed above to
+apply across DSO boundaries. As in the regular CFI, each DSO must be
+built with <tt class="docutils literal"><span class="pre">-flto</span></tt>.</p>
+<p>Normally, CFI checks will only be performed for classes that have hidden LTO
+visibility. With this flag enabled, the compiler will emit cross-DSO CFI
+checks for all classes, except for those which appear in the CFI blacklist
+or which use a <tt class="docutils literal"><span class="pre">no_sanitize</span></tt> attribute.</p>
+</div>
+<div class="section" id="design">
+<h2><a class="toc-backref" href="#id13">Design</a><a class="headerlink" href="#design" title="Permalink to this headline">Â¶</a></h2>
+<p>Please refer to the <a class="reference internal" href="ControlFlowIntegrityDesign.html"><em>design document</em></a>.</p>
+</div>
+<div class="section" id="publications">
+<h2><a class="toc-backref" href="#id14">Publications</a><a class="headerlink" href="#publications" title="Permalink to this headline">Â¶</a></h2>
+<p><a class="reference external" href="http://research.microsoft.com/pubs/64250/ccs05.pdf">Control-Flow Integrity: Principles, Implementations, and Applications</a>.
+Martin Abadi, Mihai Budiu, Ãlfar Erlingsson, Jay Ligatti.</p>
+<p><a class="reference external" href="http://www.pcc.me.uk/~peter/acad/usenix14.pdf">Enforcing Forward-Edge Control-Flow Integrity in GCC & LLVM</a>.
+Caroline Tice, Tom Roeder, Peter Collingbourne, Stephen Checkoway,
+Ãlfar Erlingsson, Luis Lozano, Geoff Pike.</p>
+</div>
+</div>
+
+
+      </div>
+      <div class="bottomnav">
+      
+        <p>
+        Â«  <a href="SanitizerSpecialCaseList.html">Sanitizer special case list</a>
+          ::  
+        <a class="uplink" href="index.html">Contents</a>
+          ::  
+        <a href="ControlFlowIntegrityDesign.html">Control Flow Integrity Design Documentation</a>  Â»
+        </p>
+
+      </div>
+
+    <div class="footer">
+        © Copyright 2007-2017, The Clang Team.
+      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.2.2.
+    </div>
+  </body>
+</html>
\ No newline at end of file

Added: www-releases/trunk/5.0.0/tools/clang/docs/ControlFlowIntegrityDesign.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/5.0.0/tools/clang/docs/ControlFlowIntegrityDesign.html?rev=312731&view=auto
==============================================================================
--- www-releases/trunk/5.0.0/tools/clang/docs/ControlFlowIntegrityDesign.html (added)
+++ www-releases/trunk/5.0.0/tools/clang/docs/ControlFlowIntegrityDesign.html Thu Sep  7 10:47:16 2017
@@ -0,0 +1,959 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    
+    <title>Control Flow Integrity Design Documentation — Clang 5 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:     '5',
+        COLLAPSE_INDEX: false,
+        FILE_SUFFIX: '.html',
+        HAS_SOURCE:  true
+      };
+    </script>
+    <script type="text/javascript" src="_static/jquery.js"></script>
+    <script type="text/javascript" src="_static/underscore.js"></script>
+    <script type="text/javascript" src="_static/doctools.js"></script>
+    <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+    <link rel="top" title="Clang 5 documentation" href="index.html" />
+    <link rel="up" title="Control Flow Integrity" href="ControlFlowIntegrity.html" />
+    <link rel="next" title="LTO Visibility" href="LTOVisibility.html" />
+    <link rel="prev" title="Control Flow Integrity" href="ControlFlowIntegrity.html" /> 
+  </head>
+  <body>
+      <div class="header"><h1 class="heading"><a href="index.html">
+          <span>Clang 5 documentation</span></a></h1>
+        <h2 class="heading"><span>Control Flow Integrity Design Documentation</span></h2>
+      </div>
+      <div class="topnav">
+      
+        <p>
+        Â«  <a href="ControlFlowIntegrity.html">Control Flow Integrity</a>
+          ::  
+        <a class="uplink" href="index.html">Contents</a>
+          ::  
+        <a href="LTOVisibility.html">LTO Visibility</a>  Â»
+        </p>
+
+      </div>
+      <div class="content">
+        
+        
+  <div class="section" id="control-flow-integrity-design-documentation">
+<h1>Control Flow Integrity Design Documentation<a class="headerlink" href="#control-flow-integrity-design-documentation" title="Permalink to this headline">Â¶</a></h1>
+<p>This page documents the design of the <a class="reference internal" href="ControlFlowIntegrity.html"><em>Control Flow Integrity</em></a> schemes
+supported by Clang.</p>
+<div class="section" id="forward-edge-cfi-for-virtual-calls">
+<h2>Forward-Edge CFI for Virtual Calls<a class="headerlink" href="#forward-edge-cfi-for-virtual-calls" title="Permalink to this headline">Â¶</a></h2>
+<p>This scheme works by allocating, for each static type used to make a virtual
+call, a region of read-only storage in the object file holding a bit vector
+that maps onto to the region of storage used for those virtual tables. Each
+set bit in the bit vector corresponds to the <a class="reference external" href="https://mentorembedded.github.io/cxx-abi/abi.html#vtable-general">address point</a> for a virtual
+table compatible with the static type for which the bit vector is being built.</p>
+<p>For example, consider the following three C++ classes:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">struct</span> <span class="n">A</span> <span class="p">{</span>
+  <span class="k">virtual</span> <span class="kt">void</span> <span class="n">f1</span><span class="p">();</span>
+  <span class="k">virtual</span> <span class="kt">void</span> <span class="nf">f2</span><span class="p">();</span>
+  <span class="k">virtual</span> <span class="kt">void</span> <span class="nf">f3</span><span class="p">();</span>
+<span class="p">};</span>
+
+<span class="k">struct</span> <span class="nl">B</span> <span class="p">:</span> <span class="n">A</span> <span class="p">{</span>
+  <span class="k">virtual</span> <span class="kt">void</span> <span class="n">f1</span><span class="p">();</span>
+  <span class="k">virtual</span> <span class="kt">void</span> <span class="nf">f2</span><span class="p">();</span>
+  <span class="k">virtual</span> <span class="kt">void</span> <span class="nf">f3</span><span class="p">();</span>
+<span class="p">};</span>
+
+<span class="k">struct</span> <span class="nl">C</span> <span class="p">:</span> <span class="n">A</span> <span class="p">{</span>
+  <span class="k">virtual</span> <span class="kt">void</span> <span class="n">f1</span><span class="p">();</span>
+  <span class="k">virtual</span> <span class="kt">void</span> <span class="nf">f2</span><span class="p">();</span>
+  <span class="k">virtual</span> <span class="kt">void</span> <span class="nf">f3</span><span class="p">();</span>
+<span class="p">};</span>
+</pre></div>
+</div>
+<p>The scheme will cause the virtual tables for A, B and C to be laid out
+consecutively:</p>
+<table border="1" class="docutils">
+<caption>Virtual Table Layout for A, B, C</caption>
+<colgroup>
+<col width="7%" />
+<col width="7%" />
+<col width="7%" />
+<col width="7%" />
+<col width="7%" />
+<col width="7%" />
+<col width="7%" />
+<col width="7%" />
+<col width="7%" />
+<col width="7%" />
+<col width="7%" />
+<col width="7%" />
+<col width="7%" />
+<col width="7%" />
+<col width="7%" />
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">0</th>
+<th class="head">1</th>
+<th class="head">2</th>
+<th class="head">3</th>
+<th class="head">4</th>
+<th class="head">5</th>
+<th class="head">6</th>
+<th class="head">7</th>
+<th class="head">8</th>
+<th class="head">9</th>
+<th class="head">10</th>
+<th class="head">11</th>
+<th class="head">12</th>
+<th class="head">13</th>
+<th class="head">14</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>A::offset-to-top</td>
+<td>&A::rtti</td>
+<td>&A::f1</td>
+<td>&A::f2</td>
+<td>&A::f3</td>
+<td>B::offset-to-top</td>
+<td>&B::rtti</td>
+<td>&B::f1</td>
+<td>&B::f2</td>
+<td>&B::f3</td>
+<td>C::offset-to-top</td>
+<td>&C::rtti</td>
+<td>&C::f1</td>
+<td>&C::f2</td>
+<td>&C::f3</td>
+</tr>
+</tbody>
+</table>
+<p>The bit vector for static types A, B and C will look like this:</p>
+<table border="1" class="docutils">
+<caption>Bit Vectors for A, B, C</caption>
+<colgroup>
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">Class</th>
+<th class="head">0</th>
+<th class="head">1</th>
+<th class="head">2</th>
+<th class="head">3</th>
+<th class="head">4</th>
+<th class="head">5</th>
+<th class="head">6</th>
+<th class="head">7</th>
+<th class="head">8</th>
+<th class="head">9</th>
+<th class="head">10</th>
+<th class="head">11</th>
+<th class="head">12</th>
+<th class="head">13</th>
+<th class="head">14</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>A</td>
+<td>0</td>
+<td>0</td>
+<td>1</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>1</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>1</td>
+<td>0</td>
+<td>0</td>
+</tr>
+<tr class="row-odd"><td>B</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>1</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+</tr>
+<tr class="row-even"><td>C</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>1</td>
+<td>0</td>
+<td>0</td>
+</tr>
+</tbody>
+</table>
+<p>Bit vectors are represented in the object file as byte arrays. By loading
+from indexed offsets into the byte array and applying a mask, a program can
+test bits from the bit set with a relatively short instruction sequence. Bit
+vectors may overlap so long as they use different bits. For the full details,
+see the <a class="reference external" href="http://llvm.org/docs/doxygen/html/structllvm_1_1ByteArrayBuilder.html">ByteArrayBuilder</a> class.</p>
+<p>In this case, assuming A is laid out at offset 0 in bit 0, B at offset 0 in
+bit 1 and C at offset 0 in bit 2, the byte array would look like this:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="kt">char</span> <span class="n">bits</span><span class="p">[]</span> <span class="o">=</span> <span class="p">{</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span> <span class="p">};</span>
+</pre></div>
+</div>
+<p>To emit a virtual call, the compiler will assemble code that checks that
+the object’s virtual table pointer is in-bounds and aligned and that the
+relevant bit is set in the bit vector.</p>
+<p>For example on x86 a typical virtual call may look like this:</p>
+<div class="highlight-none"><div class="highlight"><pre><span></span>ca7fbb:       48 8b 0f                mov    (%rdi),%rcx
+ca7fbe:       48 8d 15 c3 42 fb 07    lea    0x7fb42c3(%rip),%rdx
+ca7fc5:       48 89 c8                mov    %rcx,%rax
+ca7fc8:       48 29 d0                sub    %rdx,%rax
+ca7fcb:       48 c1 c0 3d             rol    $0x3d,%rax
+ca7fcf:       48 3d 7f 01 00 00       cmp    $0x17f,%rax
+ca7fd5:       0f 87 36 05 00 00       ja     ca8511
+ca7fdb:       48 8d 15 c0 0b f7 06    lea    0x6f70bc0(%rip),%rdx
+ca7fe2:       f6 04 10 10             testb  $0x10,(%rax,%rdx,1)
+ca7fe6:       0f 84 25 05 00 00       je     ca8511
+ca7fec:       ff 91 98 00 00 00       callq  *0x98(%rcx)
+  [...]
+ca8511:       0f 0b                   ud2
+</pre></div>
+</div>
+<p>The compiler relies on co-operation from the linker in order to assemble
+the bit vectors for the whole program. It currently does this using LLVM’s
+<a class="reference external" href="http://llvm.org/docs/TypeMetadata.html">type metadata</a> mechanism together with link-time optimization.</p>
+<div class="section" id="optimizations">
+<h3>Optimizations<a class="headerlink" href="#optimizations" title="Permalink to this headline">Â¶</a></h3>
+<p>The scheme as described above is the fully general variant of the scheme.
+Most of the time we are able to apply one or more of the following
+optimizations to improve binary size or performance.</p>
+<p>In fact, if you try the above example with the current version of the
+compiler, you will probably find that it will not use the described virtual
+table layout or machine instructions. Some of the optimizations we are about
+to introduce cause the compiler to use a different layout or a different
+sequence of machine instructions.</p>
+<div class="section" id="stripping-leading-trailing-zeros-in-bit-vectors">
+<h4>Stripping Leading/Trailing Zeros in Bit Vectors<a class="headerlink" href="#stripping-leading-trailing-zeros-in-bit-vectors" title="Permalink to this headline">Â¶</a></h4>
+<p>If a bit vector contains leading or trailing zeros, we can strip them from
+the vector. The compiler will emit code to check if the pointer is in range
+of the region covered by ones, and perform the bit vector check using a
+truncated version of the bit vector. For example, the bit vectors for our
+example class hierarchy will be emitted like this:</p>
+<table border="1" class="docutils">
+<caption>Bit Vectors for A, B, C</caption>
+<colgroup>
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">Class</th>
+<th class="head">0</th>
+<th class="head">1</th>
+<th class="head">2</th>
+<th class="head">3</th>
+<th class="head">4</th>
+<th class="head">5</th>
+<th class="head">6</th>
+<th class="head">7</th>
+<th class="head">8</th>
+<th class="head">9</th>
+<th class="head">10</th>
+<th class="head">11</th>
+<th class="head">12</th>
+<th class="head">13</th>
+<th class="head">14</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>A</td>
+<td> </td>
+<td> </td>
+<td>1</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>1</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>0</td>
+<td>1</td>
+<td> </td>
+<td> </td>
+</tr>
+<tr class="row-odd"><td>B</td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td>1</td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+</tr>
+<tr class="row-even"><td>C</td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td> </td>
+<td>1</td>
+<td> </td>
+<td> </td>
+</tr>
+</tbody>
+</table>
+</div>
+<div class="section" id="short-inline-bit-vectors">
+<h4>Short Inline Bit Vectors<a class="headerlink" href="#short-inline-bit-vectors" title="Permalink to this headline">Â¶</a></h4>
+<p>If the vector is sufficiently short, we can represent it as an inline constant
+on x86. This saves us a few instructions when reading the correct element
+of the bit vector.</p>
+<p>If the bit vector fits in 32 bits, the code looks like this:</p>
+<div class="highlight-none"><div class="highlight"><pre><span></span> dc2:       48 8b 03                mov    (%rbx),%rax
+ dc5:       48 8d 15 14 1e 00 00    lea    0x1e14(%rip),%rdx
+ dcc:       48 89 c1                mov    %rax,%rcx
+ dcf:       48 29 d1                sub    %rdx,%rcx
+ dd2:       48 c1 c1 3d             rol    $0x3d,%rcx
+ dd6:       48 83 f9 03             cmp    $0x3,%rcx
+ dda:       77 2f                   ja     e0b <main+0x9b>
+ ddc:       ba 09 00 00 00          mov    $0x9,%edx
+ de1:       0f a3 ca                bt     %ecx,%edx
+ de4:       73 25                   jae    e0b <main+0x9b>
+ de6:       48 89 df                mov    %rbx,%rdi
+ de9:       ff 10                   callq  *(%rax)
+[...]
+ e0b:       0f 0b                   ud2
+</pre></div>
+</div>
+<p>Or if the bit vector fits in 64 bits:</p>
+<div class="highlight-none"><div class="highlight"><pre><span></span>11a6:       48 8b 03                mov    (%rbx),%rax
+11a9:       48 8d 15 d0 28 00 00    lea    0x28d0(%rip),%rdx
+11b0:       48 89 c1                mov    %rax,%rcx
+11b3:       48 29 d1                sub    %rdx,%rcx
+11b6:       48 c1 c1 3d             rol    $0x3d,%rcx
+11ba:       48 83 f9 2a             cmp    $0x2a,%rcx
+11be:       77 35                   ja     11f5 <main+0xb5>
+11c0:       48 ba 09 00 00 00 00    movabs $0x40000000009,%rdx
+11c7:       04 00 00
+11ca:       48 0f a3 ca             bt     %rcx,%rdx
+11ce:       73 25                   jae    11f5 <main+0xb5>
+11d0:       48 89 df                mov    %rbx,%rdi
+11d3:       ff 10                   callq  *(%rax)
+[...]
+11f5:       0f 0b                   ud2
+</pre></div>
+</div>
+<p>If the bit vector consists of a single bit, there is only one possible
+virtual table, and the check can consist of a single equality comparison:</p>
+<div class="highlight-none"><div class="highlight"><pre><span></span>9a2:   48 8b 03                mov    (%rbx),%rax
+9a5:   48 8d 0d a4 13 00 00    lea    0x13a4(%rip),%rcx
+9ac:   48 39 c8                cmp    %rcx,%rax
+9af:   75 25                   jne    9d6 <main+0x86>
+9b1:   48 89 df                mov    %rbx,%rdi
+9b4:   ff 10                   callq  *(%rax)
+[...]
+9d6:   0f 0b                   ud2
+</pre></div>
+</div>
+</div>
+<div class="section" id="virtual-table-layout">
+<h4>Virtual Table Layout<a class="headerlink" href="#virtual-table-layout" title="Permalink to this headline">Â¶</a></h4>
+<p>The compiler lays out classes of disjoint hierarchies in separate regions
+of the object file. At worst, bit vectors in disjoint hierarchies only
+need to cover their disjoint hierarchy. But the closer that classes in
+sub-hierarchies are laid out to each other, the smaller the bit vectors for
+those sub-hierarchies need to be (see “Stripping Leading/Trailing Zeros in Bit
+Vectors” above). The <a class="reference external" href="http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Transforms/IPO/LowerTypeTests.h?view=markup">GlobalLayoutBuilder</a> class is responsible for laying
+out the globals efficiently to minimize the sizes of the underlying bitsets.</p>
+</div>
+<div class="section" id="alignment">
+<h4>Alignment<a class="headerlink" href="#alignment" title="Permalink to this headline">Â¶</a></h4>
+<p>If all gaps between address points in a particular bit vector are multiples
+of powers of 2, the compiler can compress the bit vector by strengthening
+the alignment requirements of the virtual table pointer. For example, given
+this class hierarchy:</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">struct</span> <span class="n">A</span> <span class="p">{</span>
+  <span class="k">virtual</span> <span class="kt">void</span> <span class="n">f1</span><span class="p">();</span>
+  <span class="k">virtual</span> <span class="kt">void</span> <span class="nf">f2</span><span class="p">();</span>
+<span class="p">};</span>
+
+<span class="k">struct</span> <span class="nl">B</span> <span class="p">:</span> <span class="n">A</span> <span class="p">{</span>
+  <span class="k">virtual</span> <span class="kt">void</span> <span class="n">f1</span><span class="p">();</span>
+  <span class="k">virtual</span> <span class="kt">void</span> <span class="nf">f2</span><span class="p">();</span>
+  <span class="k">virtual</span> <span class="kt">void</span> <span class="nf">f3</span><span class="p">();</span>
+  <span class="k">virtual</span> <span class="kt">void</span> <span class="nf">f4</span><span class="p">();</span>
+  <span class="k">virtual</span> <span class="kt">void</span> <span class="nf">f5</span><span class="p">();</span>
+  <span class="k">virtual</span> <span class="kt">void</span> <span class="nf">f6</span><span class="p">();</span>
+<span class="p">};</span>
+
+<span class="k">struct</span> <span class="nl">C</span> <span class="p">:</span> <span class="n">A</span> <span class="p">{</span>
+  <span class="k">virtual</span> <span class="kt">void</span> <span class="n">f1</span><span class="p">();</span>
+  <span class="k">virtual</span> <span class="kt">void</span> <span class="nf">f2</span><span class="p">();</span>
+<span class="p">};</span>
+</pre></div>
+</div>
+<p>The virtual tables will be laid out like this:</p>
+<table border="1" class="docutils">
+<caption>Virtual Table Layout for A, B, C</caption>
+<colgroup>
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+<col width="6%" />
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">0</th>
+<th class="head">1</th>
+<th class="head">2</th>
+<th class="head">3</th>
+<th class="head">4</th>
+<th class="head">5</th>
+<th class="head">6</th>
+<th class="head">7</th>
+<th class="head">8</th>
+<th class="head">9</th>
+<th class="head">10</th>
+<th class="head">11</th>
+<th class="head">12</th>
+<th class="head">13</th>
+<th class="head">14</th>
+<th class="head">15</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>A::offset-to-top</td>
+<td>&A::rtti</td>
+<td>&A::f1</td>
+<td>&A::f2</td>
+<td>B::offset-to-top</td>
+<td>&B::rtti</td>
+<td>&B::f1</td>
+<td>&B::f2</td>
+<td>&B::f3</td>
+<td>&B::f4</td>
+<td>&B::f5</td>
+<td>&B::f6</td>
+<td>C::offset-to-top</td>
+<td>&C::rtti</td>
+<td>&C::f1</td>
+<td>&C::f2</td>
+</tr>
+</tbody>
+</table>
+<p>Notice that each address point for A is separated by 4 words. This lets us
+emit a compressed bit vector for A that looks like this:</p>
+<table border="1" class="docutils">
+<colgroup>
+<col width="25%" />
+<col width="25%" />
+<col width="25%" />
+<col width="25%" />
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">2</th>
+<th class="head">6</th>
+<th class="head">10</th>
+<th class="head">14</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>1</td>
+<td>1</td>
+<td>0</td>
+<td>1</td>
+</tr>
+</tbody>
+</table>
+<p>At call sites, the compiler will strengthen the alignment requirements by
+using a different rotate count. For example, on a 64-bit machine where the
+address points are 4-word aligned (as in A from our example), the <tt class="docutils literal"><span class="pre">rol</span></tt>
+instruction may look like this:</p>
+<div class="highlight-none"><div class="highlight"><pre><span></span>dd2:       48 c1 c1 3b             rol    $0x3b,%rcx
+</pre></div>
+</div>
+</div>
+<div class="section" id="padding-to-powers-of-2">
+<h4>Padding to Powers of 2<a class="headerlink" href="#padding-to-powers-of-2" title="Permalink to this headline">Â¶</a></h4>
+<p>Of course, this alignment scheme works best if the address points are
+in fact aligned correctly. To make this more likely to happen, we insert
+padding between virtual tables that in many cases aligns address points to
+a power of 2. Specifically, our padding aligns virtual tables to the next
+highest power of 2 bytes; because address points for specific base classes
+normally appear at fixed offsets within the virtual table, this normally
+has the effect of aligning the address points as well.</p>
+<p>This scheme introduces tradeoffs between decreased space overhead for
+instructions and bit vectors and increased overhead in the form of padding. We
+therefore limit the amount of padding so that we align to no more than 128
+bytes. This number was found experimentally to provide a good tradeoff.</p>
+</div>
+<div class="section" id="eliminating-bit-vector-checks-for-all-ones-bit-vectors">
+<h4>Eliminating Bit Vector Checks for All-Ones Bit Vectors<a class="headerlink" href="#eliminating-bit-vector-checks-for-all-ones-bit-vectors" title="Permalink to this headline">Â¶</a></h4>
+<p>If the bit vector is all ones, the bit vector check is redundant; we simply
+need to check that the address is in range and well aligned. This is more
+likely to occur if the virtual tables are padded.</p>
+</div>
+</div>
+</div>
+<div class="section" id="forward-edge-cfi-for-indirect-function-calls">
+<h2>Forward-Edge CFI for Indirect Function Calls<a class="headerlink" href="#forward-edge-cfi-for-indirect-function-calls" title="Permalink to this headline">Â¶</a></h2>
+<p>Under forward-edge CFI for indirect function calls, each unique function
+type has its own bit vector, and at each call site we need to check that the
+function pointer is a member of the function type’s bit vector. This scheme
+works in a similar way to forward-edge CFI for virtual calls, the distinction
+being that we need to build bit vectors of function entry points rather than
+of virtual tables.</p>
+<p>Unlike when re-arranging global variables, we cannot re-arrange functions
+in a particular order and base our calculations on the layout of the
+functions’ entry points, as we have no idea how large a particular function
+will end up being (the function sizes could even depend on how we arrange
+the functions). Instead, we build a jump table, which is a block of code
+consisting of one branch instruction for each of the functions in the bit
+set that branches to the target function, and redirect any taken function
+addresses to the corresponding jump table entry. In this way, the distance
+between function entry points is predictable and controllable. In the object
+file’s symbol table, the symbols for the target functions also refer to the
+jump table entries, so that addresses taken outside the module will pass
+any verification done inside the module.</p>
+<p>In more concrete terms, suppose we have three functions <tt class="docutils literal"><span class="pre">f</span></tt>, <tt class="docutils literal"><span class="pre">g</span></tt>,
+<tt class="docutils literal"><span class="pre">h</span></tt> which are all of the same type, and a function foo that returns their
+addresses:</p>
+<div class="highlight-none"><div class="highlight"><pre><span></span>f:
+mov 0, %eax
+ret
+
+g:
+mov 1, %eax
+ret
+
+h:
+mov 2, %eax
+ret
+
+foo:
+mov f, %eax
+mov g, %edx
+mov h, %ecx
+ret
+</pre></div>
+</div>
+<p>Our jump table will (conceptually) look like this:</p>
+<div class="highlight-none"><div class="highlight"><pre><span></span>f:
+jmp .Ltmp0 ; 5 bytes
+int3       ; 1 byte
+int3       ; 1 byte
+int3       ; 1 byte
+
+g:
+jmp .Ltmp1 ; 5 bytes
+int3       ; 1 byte
+int3       ; 1 byte
+int3       ; 1 byte
+
+h:
+jmp .Ltmp2 ; 5 bytes
+int3       ; 1 byte
+int3       ; 1 byte
+int3       ; 1 byte
+
+.Ltmp0:
+mov 0, %eax
+ret
+
+.Ltmp1:
+mov 1, %eax
+ret
+
+.Ltmp2:
+mov 2, %eax
+ret
+
+foo:
+mov f, %eax
+mov g, %edx
+mov h, %ecx
+ret
+</pre></div>
+</div>
+<p>Because the addresses of <tt class="docutils literal"><span class="pre">f</span></tt>, <tt class="docutils literal"><span class="pre">g</span></tt>, <tt class="docutils literal"><span class="pre">h</span></tt> are evenly spaced at a power of
+2, and function types do not overlap (unlike class types with base classes),
+we can normally apply the <a class="reference internal" href="#alignment">Alignment</a> and <a class="reference internal" href="#eliminating-bit-vector-checks-for-all-ones-bit-vectors">Eliminating Bit Vector Checks
+for All-Ones Bit Vectors</a> optimizations thus simplifying the check at each
+call site to a range and alignment check.</p>
+</div>
+<div class="section" id="shared-library-support">
+<h2>Shared library support<a class="headerlink" href="#shared-library-support" title="Permalink to this headline">Â¶</a></h2>
+<p><strong>EXPERIMENTAL</strong></p>
+<p>The basic CFI mode described above assumes that the application is a
+monolithic binary; at least that all possible virtual/indirect call
+targets and the entire class hierarchy are known at link time. The
+cross-DSO mode, enabled with <strong>-f[no-]sanitize-cfi-cross-dso</strong> relaxes
+this requirement by allowing virtual and indirect calls to cross the
+DSO boundary.</p>
+<p>Assuming the following setup: the binary consists of several
+instrumented and several uninstrumented DSOs. Some of them may be
+dlopen-ed/dlclose-d periodically, even frequently.</p>
+<blockquote>
+<div><ul>
+<li><p class="first">Calls made from uninstrumented DSOs are not checked and just work.</p>
+</li>
+<li><p class="first">Calls inside any instrumented DSO are fully protected.</p>
+</li>
+<li><dl class="first docutils">
+<dt>Calls between different instrumented DSOs are also protected, with</dt>
+<dd><p class="first last">a performance penalty (in addition to the monolithic CFI
+overhead).</p>
+</dd>
+</dl>
+</li>
+<li><dl class="first docutils">
+<dt>Calls from an instrumented DSO to an uninstrumented one are</dt>
+<dd><p class="first last">unchecked and just work, with performance penalty.</p>
+</dd>
+</dl>
+</li>
+<li><dl class="first docutils">
+<dt>Calls from an instrumented DSO outside of any known DSO are</dt>
+<dd><p class="first last">detected as CFI violations.</p>
+</dd>
+</dl>
+</li>
+</ul>
+</div></blockquote>
+<p>In the monolithic scheme a call site is instrumented as</p>
+<div class="highlight-none"><div class="highlight"><pre><span></span>if (!InlinedFastCheck(f))
+  abort();
+call *f
+</pre></div>
+</div>
+<p>In the cross-DSO scheme it becomes</p>
+<div class="highlight-none"><div class="highlight"><pre><span></span>if (!InlinedFastCheck(f))
+  __cfi_slowpath(CallSiteTypeId, f);
+call *f
+</pre></div>
+</div>
+<div class="section" id="callsitetypeid">
+<h3>CallSiteTypeId<a class="headerlink" href="#callsitetypeid" title="Permalink to this headline">Â¶</a></h3>
+<p><tt class="docutils literal"><span class="pre">CallSiteTypeId</span></tt> is a stable process-wide identifier of the
+call-site type. For a virtual call site, the type in question is the class
+type; for an indirect function call it is the function signature. The
+mapping from a type to an identifier is an ABI detail. In the current,
+experimental, implementation the identifier of type T is calculated as
+follows:</p>
+<blockquote>
+<div><ul class="simple">
+<li>Obtain the mangled name for “typeinfo name for T”.</li>
+<li>Calculate MD5 hash of the name as a string.</li>
+<li>Reinterpret the first 8 bytes of the hash as a little-endian
+64-bit integer.</li>
+</ul>
+</div></blockquote>
+<p>It is possible, but unlikely, that collisions in the
+<tt class="docutils literal"><span class="pre">CallSiteTypeId</span></tt> hashing will result in weaker CFI checks that would
+still be conservatively correct.</p>
+</div>
+<div class="section" id="cfi-check">
+<h3>CFI_Check<a class="headerlink" href="#cfi-check" title="Permalink to this headline">Â¶</a></h3>
+<p>In the general case, only the target DSO knows whether the call to
+function <tt class="docutils literal"><span class="pre">f</span></tt> with type <tt class="docutils literal"><span class="pre">CallSiteTypeId</span></tt> is valid or not.  To
+export this information, every DSO implements</p>
+<div class="highlight-none"><div class="highlight"><pre><span></span>void __cfi_check(uint64 CallSiteTypeId, void *TargetAddr, void *DiagData)
+</pre></div>
+</div>
+<p>This function provides external modules with access to CFI checks for
+the targets inside this DSO.  For each known <tt class="docutils literal"><span class="pre">CallSiteTypeId</span></tt>, this
+function performs an <tt class="docutils literal"><span class="pre">llvm.type.test</span></tt> with the corresponding type
+identifier. It reports an error if the type is unknown, or if the
+check fails. Depending on the values of compiler flags
+<tt class="docutils literal"><span class="pre">-fsanitize-trap</span></tt> and <tt class="docutils literal"><span class="pre">-fsanitize-recover</span></tt>, this function may
+print an error, abort and/or return to the caller. <tt class="docutils literal"><span class="pre">DiagData</span></tt> is an
+opaque pointer to the diagnostic information about the error, or
+<tt class="docutils literal"><span class="pre">null</span></tt> if the caller does not provide this information.</p>
+<p>The basic implementation is a large switch statement over all values
+of CallSiteTypeId supported by this DSO, and each case is similar to
+the InlinedFastCheck() in the basic CFI mode.</p>
+</div>
+<div class="section" id="cfi-shadow">
+<h3>CFI Shadow<a class="headerlink" href="#cfi-shadow" title="Permalink to this headline">Â¶</a></h3>
+<p>To route CFI checks to the target DSO’s __cfi_check function, a
+mapping from possible virtual / indirect call targets to the
+corresponding __cfi_check functions is maintained. This mapping is
+implemented as a sparse array of 2 bytes for every possible page (4096
+bytes) of memory. The table is kept readonly most of the time.</p>
+<p>There are 3 types of shadow values:</p>
+<blockquote>
+<div><ul class="simple">
+<li>Address in a CFI-instrumented DSO.</li>
+<li>Unchecked address (a âtrustedâ non-instrumented DSO). Encoded as
+value 0xFFFF.</li>
+<li>Invalid address (everything else). Encoded as value 0.</li>
+</ul>
+</div></blockquote>
+<p>For a CFI-instrumented DSO, a shadow value encodes the address of the
+__cfi_check function for all call targets in the corresponding memory
+page. If Addr is the target address, and V is the shadow value, then
+the address of __cfi_check is calculated as</p>
+<div class="highlight-none"><div class="highlight"><pre><span></span>__cfi_check = AlignUpTo(Addr, 4096) - (V + 1) * 4096
+</pre></div>
+</div>
+<p>This works as long as __cfi_check is aligned by 4096 bytes and located
+below any call targets in its DSO, but not more than 256MB apart from
+them.</p>
+</div>
+<div class="section" id="cfi-slowpath">
+<h3>CFI_SlowPath<a class="headerlink" href="#cfi-slowpath" title="Permalink to this headline">Â¶</a></h3>
+<p>The slow path check is implemented in a runtime support library as</p>
+<div class="highlight-none"><div class="highlight"><pre><span></span>void __cfi_slowpath(uint64 CallSiteTypeId, void *TargetAddr)
+void __cfi_slowpath_diag(uint64 CallSiteTypeId, void *TargetAddr, void *DiagData)
+</pre></div>
+</div>
+<p>These functions loads a shadow value for <tt class="docutils literal"><span class="pre">TargetAddr</span></tt>, finds the
+address of <tt class="docutils literal"><span class="pre">__cfi_check</span></tt> as described above and calls
+that. <tt class="docutils literal"><span class="pre">DiagData</span></tt> is an opaque pointer to diagnostic data which is
+passed verbatim to <tt class="docutils literal"><span class="pre">__cfi_check</span></tt>, and <tt class="docutils literal"><span class="pre">__cfi_slowpath</span></tt> passes
+<tt class="docutils literal"><span class="pre">nullptr</span></tt> instead.</p>
+<p>Compiler-RT library contains reference implementations of slowpath
+functions, but they have unresolvable issues with correctness and
+performance in the handling of dlopen(). It is recommended that
+platforms provide their own implementations, usually as part of libc
+or libdl.</p>
+</div>
+<div class="section" id="position-independent-executable-requirement">
+<h3>Position-independent executable requirement<a class="headerlink" href="#position-independent-executable-requirement" title="Permalink to this headline">Â¶</a></h3>
+<p>Cross-DSO CFI mode requires that the main executable is built as PIE.
+In non-PIE executables the address of an external function (taken from
+the main executable) is the address of that functionâs PLT record in
+the main executable. This would break the CFI checks.</p>
+</div>
+</div>
+<div class="section" id="backward-edge-cfi-for-return-statements-rcfi">
+<h2>Backward-edge CFI for return statements (RCFI)<a class="headerlink" href="#backward-edge-cfi-for-return-statements-rcfi" title="Permalink to this headline">Â¶</a></h2>
+<p>This section is a proposal. As of March 2017 it is not implemented.</p>
+<p>Backward-edge control flow (<cite>RET</cite> instructions) can be hijacked
+via overwriting the return address (<cite>RA</cite>) on stack.
+Various mitigation techniques (e.g. <a class="reference external" href="https://clang.llvm.org/docs/SafeStack.html">SafeStack</a>, <a class="reference external" href="http://xlab.tencent.com/en/2016/11/02/return-flow-guard">RFG</a>, <a class="reference external" href="https://software.intel.com/en-us/blogs/2016/06/09/intel-release-new-technology-specifications-protect-rop-attacks">Intel CET</a>)
+try to detect or prevent <cite>RA</cite> corruption on stack.</p>
+<p>RCFI enforces the expected control flow in several different ways described below.
+RCFI heavily relies on LTO.</p>
+<div class="section" id="leaf-functions">
+<h3>Leaf Functions<a class="headerlink" href="#leaf-functions" title="Permalink to this headline">Â¶</a></h3>
+<p>If <cite>f()</cite> is a leaf function (i.e. it has no calls
+except maybe no-return calls) it can be called using a special calling convention
+that stores <cite>RA</cite> in a dedicated register <cite>R</cite> before the <cite>CALL</cite> instruction.
+<cite>f()</cite> does not spill <cite>R</cite> and does not use the <cite>RET</cite> instruction,
+instead it uses the value in <cite>R</cite> to <cite>JMP</cite> to <cite>RA</cite>.</p>
+<p>This flavour of CFI is <em>precise</em>, i.e. the function is guaranteed to return
+to the point exactly following the call.</p>
+<p>An alternative approach is to
+copy <cite>RA</cite> from stack to <cite>R</cite> in the first instruction of <cite>f()</cite>,
+then <cite>JMP</cite> to <cite>R</cite>.
+This approach is simpler to implement (does not require changing the caller)
+but weaker (there is a small window when <cite>RA</cite> is actually stored on stack).</p>
+</div>
+<div class="section" id="functions-called-once">
+<h3>Functions called once<a class="headerlink" href="#functions-called-once" title="Permalink to this headline">Â¶</a></h3>
+<p>Suppose <cite>f()</cite> is called in just one place in the program
+(assuming we can verify this in LTO mode).
+In this case we can replace the <cite>RET</cite> instruction with a <cite>JMP</cite> instruction
+with the immediate constant for <cite>RA</cite>.
+This will <em>precisely</em> enforce the return control flow no matter what is stored on stack.</p>
+<p>Another variant is to compare <cite>RA</cite> on stack with the known constant and abort
+if they don’t match; then <cite>JMP</cite> to the known constant address.</p>
+</div>
+<div class="section" id="functions-called-in-a-small-number-of-call-sites">
+<h3>Functions called in a small number of call sites<a class="headerlink" href="#functions-called-in-a-small-number-of-call-sites" title="Permalink to this headline">Â¶</a></h3>
+<p>We may extend the above approach to cases where <cite>f()</cite>
+is called more than once (but still a small number of times).
+With LTO we know all possible values of <cite>RA</cite> and we check them
+one-by-one (or using binary search) against the value on stack.
+If the match is found, we <cite>JMP</cite> to the known constant address, otherwise abort.</p>
+<p>This protection is <em>near-precise</em>, i.e. it guarantees that the control flow will
+be transferred to one of the valid return addresses for this function,
+but not necessary to the point of the most recent <cite>CALL</cite>.</p>
+</div>
+<div class="section" id="general-case">
+<h3>General case<a class="headerlink" href="#general-case" title="Permalink to this headline">Â¶</a></h3>
+<p>For functions called multiple times a <em>return jump table</em> is constructed
+in the same manner as jump tables for indirect function calls (see above).
+The correct jump table entry (or it’s index) is passed by <cite>CALL</cite> to <cite>f()</cite>
+(as an extra argument) and then spilled to stack.
+The <cite>RET</cite> instruction is replaced with a load of the jump table entry,
+jump table range check, and <cite>JMP</cite> to the jump table entry.</p>
+<p>This protection is also <em>near-precise</em>.</p>
+</div>
+<div class="section" id="returns-from-functions-called-indirectly">
+<h3>Returns from functions called indirectly<a class="headerlink" href="#returns-from-functions-called-indirectly" title="Permalink to this headline">Â¶</a></h3>
+<p>If a function is called indirectly, the return jump table is constructed for the
+equivalence class of functions instead of a single function.</p>
+</div>
+<div class="section" id="cross-dso-calls">
+<h3>Cross-DSO calls<a class="headerlink" href="#cross-dso-calls" title="Permalink to this headline">Â¶</a></h3>
+<p>Consider two instrumented DSOs, <cite>A</cite> and <cite>B</cite>. <cite>A</cite> defines <cite>f()</cite> and <cite>B</cite> calls it.</p>
+<p>This case will be handled similarly to the cross-DSO scheme using the slow path callback.</p>
+</div>
+<div class="section" id="non-goals">
+<h3>Non-goals<a class="headerlink" href="#non-goals" title="Permalink to this headline">Â¶</a></h3>
+<dl class="docutils">
+<dt>RCFI does not protect <cite>RET</cite> instructions:</dt>
+<dd><ul class="first last simple">
+<li>in non-instrumented DSOs,</li>
+<li>in instrumented DSOs for functions that are called from non-instrumented DSOs,</li>
+<li>embedded into other instructions (e.g. <cite>0f4fc3 cmovg %ebx,%eax</cite>).</li>
+</ul>
+</dd>
+</dl>
+</div>
+</div>
+<div class="section" id="hardware-support">
+<h2>Hardware support<a class="headerlink" href="#hardware-support" title="Permalink to this headline">Â¶</a></h2>
+<p>We believe that the above design can be efficiently implemented in hardware.
+A single new instruction added to an ISA would allow to perform the forward-edge CFI check
+with fewer bytes per check (smaller code size overhead) and potentially more
+efficiently. The current software-only instrumentation requires at least
+32-bytes per check (on x86_64).
+A hardware instruction may probably be less than ~ 12 bytes.
+Such instruction would check that the argument pointer is in-bounds,
+and is properly aligned, and if the checks fail it will either trap (in monolithic scheme)
+or call the slow path function (cross-DSO scheme).
+The bit vector lookup is probably too complex for a hardware implementation.</p>
+<div class="highlight-none"><div class="highlight"><pre><span></span>//  This instruction checks that 'Ptr'
+//   * is aligned by (1 << kAlignment) and
+//   * is inside [kRangeBeg, kRangeBeg+(kRangeSize<<kAlignment))
+//  and if the check fails it jumps to the given target (slow path).
+//
+// 'Ptr' is a register, pointing to the virtual function table
+//    or to the function which we need to check. We may require an explicit
+//    fixed register to be used.
+// 'kAlignment' is a 4-bit constant.
+// 'kRangeSize' is a ~20-bit constant.
+// 'kRangeBeg' is a PC-relative constant (~28 bits)
+//    pointing to the beginning of the allowed range for 'Ptr'.
+// 'kFailedCheckTarget': is a PC-relative constant (~28 bits)
+//    representing the target to branch to when the check fails.
+//    If kFailedCheckTarget==0, the process will trap
+//    (monolithic binary scheme).
+//    Otherwise it will jump to a handler that implements `CFI_SlowPath`
+//    (cross-DSO scheme).
+CFI_Check(Ptr, kAlignment, kRangeSize, kRangeBeg, kFailedCheckTarget) {
+   if (Ptr < kRangeBeg ||
+       Ptr >= kRangeBeg + (kRangeSize << kAlignment) ||
+       Ptr & ((1 << kAlignment) - 1))
+         Jump(kFailedCheckTarget);
+}
+</pre></div>
+</div>
+<p>An alternative and more compact encoding would not use <cite>kFailedCheckTarget</cite>,
+and will trap on check failure instead.
+This will allow us to fit the instruction into <strong>8-9 bytes</strong>.
+The cross-DSO checks will be performed by a trap handler and
+performance-critical ones will have to be black-listed and checked using the
+software-only scheme.</p>
+<p>Note that such hardware extension would be complementary to checks
+at the callee side, such as e.g. <strong>Intel ENDBRANCH</strong>.
+Moreover, CFI would have two benefits over ENDBRANCH: a) precision and b)
+ability to protect against invalid casts between polymorphic types.</p>
+</div>
+</div>
+
+
+      </div>
+      <div class="bottomnav">
+      
+        <p>
+        Â«  <a href="ControlFlowIntegrity.html">Control Flow Integrity</a>
+          ::  
+        <a class="uplink" href="index.html">Contents</a>
+          ::  
+        <a href="LTOVisibility.html">LTO Visibility</a>  Â»
+        </p>
+
+      </div>
+
+    <div class="footer">
+        © Copyright 2007-2017, The Clang Team.
+      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.2.2.
+    </div>
+  </body>
+</html>
\ No newline at end of file

Added: www-releases/trunk/5.0.0/tools/clang/docs/CrossCompilation.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/5.0.0/tools/clang/docs/CrossCompilation.html?rev=312731&view=auto
==============================================================================
--- www-releases/trunk/5.0.0/tools/clang/docs/CrossCompilation.html (added)
+++ www-releases/trunk/5.0.0/tools/clang/docs/CrossCompilation.html Thu Sep  7 10:47:16 2017
@@ -0,0 +1,259 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    
+    <title>Cross-compilation using Clang — Clang 5 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:     '5',
+        COLLAPSE_INDEX: false,
+        FILE_SUFFIX: '.html',
+        HAS_SOURCE:  true
+      };
+    </script>
+    <script type="text/javascript" src="_static/jquery.js"></script>
+    <script type="text/javascript" src="_static/underscore.js"></script>
+    <script type="text/javascript" src="_static/doctools.js"></script>
+    <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+    <link rel="top" title="Clang 5 documentation" href="index.html" />
+    <link rel="next" title="Thread Safety Analysis" href="ThreadSafetyAnalysis.html" />
+    <link rel="prev" title="Diagnostic flags in Clang" href="DiagnosticsReference.html" /> 
+  </head>
+  <body>
+      <div class="header"><h1 class="heading"><a href="index.html">
+          <span>Clang 5 documentation</span></a></h1>
+        <h2 class="heading"><span>Cross-compilation using Clang</span></h2>
+      </div>
+      <div class="topnav">
+      
+        <p>
+        Â«  <a href="DiagnosticsReference.html">Diagnostic flags in Clang</a>
+          ::  
+        <a class="uplink" href="index.html">Contents</a>
+          ::  
+        <a href="ThreadSafetyAnalysis.html">Thread Safety Analysis</a>  Â»
+        </p>
+
+      </div>
+      <div class="content">
+        
+        
+  <div class="section" id="cross-compilation-using-clang">
+<h1>Cross-compilation using Clang<a class="headerlink" href="#cross-compilation-using-clang" title="Permalink to this headline">Â¶</a></h1>
+<div class="section" id="introduction">
+<h2>Introduction<a class="headerlink" href="#introduction" title="Permalink to this headline">Â¶</a></h2>
+<p>This document will guide you in choosing the right Clang options
+for cross-compiling your code to a different architecture. It assumes you
+already know how to compile the code in question for the host architecture,
+and that you know how to choose additional include and library paths.</p>
+<p>However, this document is <em>not</em> a “how to” and won’t help you setting your
+build system or Makefiles, nor choosing the right CMake options, etc.
+Also, it does not cover all the possible options, nor does it contain
+specific examples for specific architectures. For a concrete example, the
+<a class="reference external" href="http://llvm.org/docs/HowToCrossCompileLLVM.html">instructions for cross-compiling LLVM itself</a> may be of interest.</p>
+<p>After reading this document, you should be familiar with the main issues
+related to cross-compilation, and what main compiler options Clang provides
+for performing cross-compilation.</p>
+</div>
+<div class="section" id="cross-compilation-issues">
+<h2>Cross compilation issues<a class="headerlink" href="#cross-compilation-issues" title="Permalink to this headline">Â¶</a></h2>
+<p>In GCC world, every host/target combination has its own set of binaries,
+headers, libraries, etc. So, it’s usually simple to download a package
+with all files in, unzip to a directory and point the build system to
+that compiler, that will know about its location and find all it needs to
+when compiling your code.</p>
+<p>On the other hand, Clang/LLVM is natively a cross-compiler, meaning that
+one set of programs can compile to all targets by setting the <tt class="docutils literal"><span class="pre">-target</span></tt>
+option. That makes it a lot easier for programmers wishing to compile to
+different platforms and architectures, and for compiler developers that
+only have to maintain one build system, and for OS distributions, that
+need only one set of main packages.</p>
+<p>But, as is true to any cross-compiler, and given the complexity of
+different architectures, OS’s and options, it’s not always easy finding
+the headers, libraries or binutils to generate target specific code.
+So you’ll need special options to help Clang understand what target
+you’re compiling to, where your tools are, etc.</p>
+<p>Another problem is that compilers come with standard libraries only (like
+<tt class="docutils literal"><span class="pre">compiler-rt</span></tt>, <tt class="docutils literal"><span class="pre">libcxx</span></tt>, <tt class="docutils literal"><span class="pre">libgcc</span></tt>, <tt class="docutils literal"><span class="pre">libm</span></tt>, etc), so you’ll have to
+find and make available to the build system, every other library required
+to build your software, that is specific to your target. It’s not enough to
+have your host’s libraries installed.</p>
+<p>Finally, not all toolchains are the same, and consequently, not every Clang
+option will work magically. Some options, like <tt class="docutils literal"><span class="pre">--sysroot</span></tt> (which
+effectively changes the logical root for headers and libraries), assume
+all your binaries and libraries are in the same directory, which may not
+true when your cross-compiler was installed by the distribution’s package
+management. So, for each specific case, you may use more than one
+option, and in most cases, you’ll end up setting include paths (<tt class="docutils literal"><span class="pre">-I</span></tt>) and
+library paths (<tt class="docutils literal"><span class="pre">-L</span></tt>) manually.</p>
+<dl class="docutils">
+<dt>To sum up, different toolchains can:</dt>
+<dd><ul class="first last simple">
+<li>be host/target specific or more flexible</li>
+<li>be in a single directory, or spread out across your system</li>
+<li>have different sets of libraries and headers by default</li>
+<li>need special options, which your build system won’t be able to figure
+out by itself</li>
+</ul>
+</dd>
+</dl>
+</div>
+<div class="section" id="general-cross-compilation-options-in-clang">
+<h2>General Cross-Compilation Options in Clang<a class="headerlink" href="#general-cross-compilation-options-in-clang" title="Permalink to this headline">Â¶</a></h2>
+<div class="section" id="target-triple">
+<h3>Target Triple<a class="headerlink" href="#target-triple" title="Permalink to this headline">Â¶</a></h3>
+<p>The basic option is to define the target architecture. For that, use
+<tt class="docutils literal"><span class="pre">-target</span> <span class="pre"><triple></span></tt>. If you don’t specify the target, CPU names won’t
+match (since Clang assumes the host triple), and the compilation will
+go ahead, creating code for the host platform, which will break later
+on when assembling or linking.</p>
+<dl class="docutils">
+<dt>The triple has the general format <tt class="docutils literal"><span class="pre"><arch><sub>-<vendor>-<sys>-<abi></span></tt>, where:</dt>
+<dd><ul class="first last simple">
+<li><tt class="docutils literal"><span class="pre">arch</span></tt> = <tt class="docutils literal"><span class="pre">x86_64</span></tt>, <tt class="docutils literal"><span class="pre">i386</span></tt>, <tt class="docutils literal"><span class="pre">arm</span></tt>, <tt class="docutils literal"><span class="pre">thumb</span></tt>, <tt class="docutils literal"><span class="pre">mips</span></tt>, etc.</li>
+<li><tt class="docutils literal"><span class="pre">sub</span></tt> = for ex. on ARM: <tt class="docutils literal"><span class="pre">v5</span></tt>, <tt class="docutils literal"><span class="pre">v6m</span></tt>, <tt class="docutils literal"><span class="pre">v7a</span></tt>, <tt class="docutils literal"><span class="pre">v7m</span></tt>, etc.</li>
+<li><tt class="docutils literal"><span class="pre">vendor</span></tt> = <tt class="docutils literal"><span class="pre">pc</span></tt>, <tt class="docutils literal"><span class="pre">apple</span></tt>, <tt class="docutils literal"><span class="pre">nvidia</span></tt>, <tt class="docutils literal"><span class="pre">ibm</span></tt>, etc.</li>
+<li><tt class="docutils literal"><span class="pre">sys</span></tt> = <tt class="docutils literal"><span class="pre">none</span></tt>, <tt class="docutils literal"><span class="pre">linux</span></tt>, <tt class="docutils literal"><span class="pre">win32</span></tt>, <tt class="docutils literal"><span class="pre">darwin</span></tt>, <tt class="docutils literal"><span class="pre">cuda</span></tt>, etc.</li>
+<li><tt class="docutils literal"><span class="pre">abi</span></tt> = <tt class="docutils literal"><span class="pre">eabi</span></tt>, <tt class="docutils literal"><span class="pre">gnu</span></tt>, <tt class="docutils literal"><span class="pre">android</span></tt>, <tt class="docutils literal"><span class="pre">macho</span></tt>, <tt class="docutils literal"><span class="pre">elf</span></tt>, etc.</li>
+</ul>
+</dd>
+</dl>
+<p>The sub-architecture options are available for their own architectures,
+of course, so “x86v7a” doesn’t make sense. The vendor needs to be
+specified only if there’s a relevant change, for instance between PC
+and Apple. Most of the time it can be omitted (and Unknown)
+will be assumed, which sets the defaults for the specified architecture.
+The system name is generally the OS (linux, darwin), but could be special
+like the bare-metal “none”.</p>
+<p>When a parameter is not important, it can be omitted, or you can
+choose <tt class="docutils literal"><span class="pre">unknown</span></tt> and the defaults will be used. If you choose a parameter
+that Clang doesn’t know, like <tt class="docutils literal"><span class="pre">blerg</span></tt>, it’ll ignore and assume
+<tt class="docutils literal"><span class="pre">unknown</span></tt>, which is not always desired, so be careful.</p>
+<p>Finally, the ABI option is something that will pick default CPU/FPU,
+define the specific behaviour of your code (PCS, extensions),
+and also choose the correct library calls, etc.</p>
+</div>
+<div class="section" id="cpu-fpu-abi">
+<h3>CPU, FPU, ABI<a class="headerlink" href="#cpu-fpu-abi" title="Permalink to this headline">Â¶</a></h3>
+<p>Once your target is specified, it’s time to pick the hardware you’ll
+be compiling to. For every architecture, a default set of CPU/FPU/ABI
+will be chosen, so you’ll almost always have to change it via flags.</p>
+<dl class="docutils">
+<dt>Typical flags include:</dt>
+<dd><ul class="first last simple">
+<li><tt class="docutils literal"><span class="pre">-mcpu=<cpu-name></span></tt>, like x86-64, swift, cortex-a15</li>
+<li><tt class="docutils literal"><span class="pre">-mfpu=<fpu-name></span></tt>, like SSE3, NEON, controlling the FP unit available</li>
+<li><tt class="docutils literal"><span class="pre">-mfloat-abi=<fabi></span></tt>, like soft, hard, controlling which registers
+to use for floating-point</li>
+</ul>
+</dd>
+</dl>
+<p>The default is normally the common denominator, so that Clang doesn’t
+generate code that breaks. But that also means you won’t get the best
+code for your specific hardware, which may mean orders of magnitude
+slower than you expect.</p>
+<p>For example, if your target is <tt class="docutils literal"><span class="pre">arm-none-eabi</span></tt>, the default CPU will
+be <tt class="docutils literal"><span class="pre">arm7tdmi</span></tt> using soft float, which is extremely slow on modern cores,
+whereas if your triple is <tt class="docutils literal"><span class="pre">armv7a-none-eabi</span></tt>, it’ll be Cortex-A8 with
+NEON, but still using soft-float, which is much better, but still not
+great.</p>
+</div>
+<div class="section" id="toolchain-options">
+<h3>Toolchain Options<a class="headerlink" href="#toolchain-options" title="Permalink to this headline">Â¶</a></h3>
+<p>There are three main options to control access to your cross-compiler:
+<tt class="docutils literal"><span class="pre">--sysroot</span></tt>, <tt class="docutils literal"><span class="pre">-I</span></tt>, and <tt class="docutils literal"><span class="pre">-L</span></tt>. The two last ones are well known,
+but they’re particularly important for additional libraries
+and headers that are specific to your target.</p>
+<p>There are two main ways to have a cross-compiler:</p>
+<ol class="arabic">
+<li><p class="first">When you have extracted your cross-compiler from a zip file into
+a directory, you have to use <tt class="docutils literal"><span class="pre">--sysroot=<path></span></tt>. The path is the
+root directory where you have unpacked your file, and Clang will
+look for the directories <tt class="docutils literal"><span class="pre">bin</span></tt>, <tt class="docutils literal"><span class="pre">lib</span></tt>, <tt class="docutils literal"><span class="pre">include</span></tt> in there.</p>
+<p>In this case, your setup should be pretty much done (if no
+additional headers or libraries are needed), as Clang will find
+all binaries it needs (assembler, linker, etc) in there.</p>
+</li>
+<li><p class="first">When you have installed via a package manager (modern Linux
+distributions have cross-compiler packages available), make
+sure the target triple you set is <em>also</em> the prefix of your
+cross-compiler toolchain.</p>
+<p>In this case, Clang will find the other binaries (assembler,
+linker), but not always where the target headers and libraries
+are. People add system-specific clues to Clang often, but as
+things change, it’s more likely that it won’t find than the
+other way around.</p>
+<p>So, here, you’ll be a lot safer if you specify the include/library
+directories manually (via <tt class="docutils literal"><span class="pre">-I</span></tt> and <tt class="docutils literal"><span class="pre">-L</span></tt>).</p>
+</li>
+</ol>
+</div>
+</div>
+<div class="section" id="target-specific-libraries">
+<h2>Target-Specific Libraries<a class="headerlink" href="#target-specific-libraries" title="Permalink to this headline">Â¶</a></h2>
+<p>All libraries that you compile as part of your build will be
+cross-compiled to your target, and your build system will probably
+find them in the right place. But all dependencies that are
+normally checked against (like <tt class="docutils literal"><span class="pre">libxml</span></tt> or <tt class="docutils literal"><span class="pre">libz</span></tt> etc) will match
+against the host platform, not the target.</p>
+<p>So, if the build system is not aware that you want to cross-compile
+your code, it will get every dependency wrong, and your compilation
+will fail during build time, not configure time.</p>
+<p>Also, finding the libraries for your target are not as easy
+as for your host machine. There aren’t many cross-libraries available
+as packages to most OS’s, so you’ll have to either cross-compile them
+from source, or download the package for your target platform,
+extract the libraries and headers, put them in specific directories
+and add <tt class="docutils literal"><span class="pre">-I</span></tt> and <tt class="docutils literal"><span class="pre">-L</span></tt> pointing to them.</p>
+<p>Also, some libraries have different dependencies on different targets,
+so configuration tools to find dependencies in the host can get the
+list wrong for the target platform. This means that the configuration
+of your build can get things wrong when setting their own library
+paths, and you’ll have to augment it via additional flags (configure,
+Make, CMake, etc).</p>
+<div class="section" id="multilibs">
+<h3>Multilibs<a class="headerlink" href="#multilibs" title="Permalink to this headline">Â¶</a></h3>
+<p>When you want to cross-compile to more than one configuration, for
+example hard-float-ARM and soft-float-ARM, you’ll have to have multiple
+copies of your libraries and (possibly) headers.</p>
+<p>Some Linux distributions have support for Multilib, which handle that
+for you in an easier way, but if you’re not careful and, for instance,
+forget to specify <tt class="docutils literal"><span class="pre">-ccc-gcc-name</span> <span class="pre">armv7l-linux-gnueabihf-gcc</span></tt> (which
+uses hard-float), Clang will pick the <tt class="docutils literal"><span class="pre">armv7l-linux-gnueabi-ld</span></tt>
+(which uses soft-float) and linker errors will happen.</p>
+<p>The same is true if you’re compiling for different ABIs, like <tt class="docutils literal"><span class="pre">gnueabi</span></tt>
+and <tt class="docutils literal"><span class="pre">androideabi</span></tt>, and might even link and run, but produce run-time
+errors, which are much harder to track down and fix.</p>
+</div>
+</div>
+</div>
+
+
+      </div>
+      <div class="bottomnav">
+      
+        <p>
+        Â«  <a href="DiagnosticsReference.html">Diagnostic flags in Clang</a>
+          ::  
+        <a class="uplink" href="index.html">Contents</a>
+          ::  
+        <a href="ThreadSafetyAnalysis.html">Thread Safety Analysis</a>  Â»
+        </p>
+
+      </div>
+
+    <div class="footer">
+        © Copyright 2007-2017, The Clang Team.
+      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.2.2.
+    </div>
+  </body>
+</html>
\ No newline at end of file

Added: www-releases/trunk/5.0.0/tools/clang/docs/DataFlowSanitizer.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/5.0.0/tools/clang/docs/DataFlowSanitizer.html?rev=312731&view=auto
==============================================================================
--- www-releases/trunk/5.0.0/tools/clang/docs/DataFlowSanitizer.html (added)
+++ www-releases/trunk/5.0.0/tools/clang/docs/DataFlowSanitizer.html Thu Sep  7 10:47:16 2017
@@ -0,0 +1,221 @@
+<!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>DataFlowSanitizer — Clang 5 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:     '5',
+        COLLAPSE_INDEX: false,
+        FILE_SUFFIX: '.html',
+        HAS_SOURCE:  true
+      };
+    </script>
+    <script type="text/javascript" src="_static/jquery.js"></script>
+    <script type="text/javascript" src="_static/underscore.js"></script>
+    <script type="text/javascript" src="_static/doctools.js"></script>
+    <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+    <link rel="top" title="Clang 5 documentation" href="index.html" />
+    <link rel="next" title="DataFlowSanitizer Design Document" href="DataFlowSanitizerDesign.html" />
+    <link rel="prev" title="UndefinedBehaviorSanitizer" href="UndefinedBehaviorSanitizer.html" /> 
+  </head>
+  <body>
+      <div class="header"><h1 class="heading"><a href="index.html">
+          <span>Clang 5 documentation</span></a></h1>
+        <h2 class="heading"><span>DataFlowSanitizer</span></h2>
+      </div>
+      <div class="topnav">
+      
+        <p>
+        Â«  <a href="UndefinedBehaviorSanitizer.html">UndefinedBehaviorSanitizer</a>
+          ::  
+        <a class="uplink" href="index.html">Contents</a>
+          ::  
+        <a href="DataFlowSanitizerDesign.html">DataFlowSanitizer Design Document</a>  Â»
+        </p>
+
+      </div>
+      <div class="content">
+        
+        
+  <div class="section" id="dataflowsanitizer">
+<h1>DataFlowSanitizer<a class="headerlink" href="#dataflowsanitizer" title="Permalink to this headline">Â¶</a></h1>
+<div class="toctree-wrapper compound">
+</div>
+<div class="contents local topic" id="contents">
+<ul class="simple">
+<li><a class="reference internal" href="#introduction" id="id1">Introduction</a></li>
+<li><a class="reference internal" href="#usage" id="id2">Usage</a><ul>
+<li><a class="reference internal" href="#abi-list" id="id3">ABI List</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#example" id="id4">Example</a></li>
+<li><a class="reference internal" href="#current-status" id="id5">Current status</a></li>
+<li><a class="reference internal" href="#design" id="id6">Design</a></li>
+</ul>
+</div>
+<div class="section" id="introduction">
+<h2><a class="toc-backref" href="#id1">Introduction</a><a class="headerlink" href="#introduction" title="Permalink to this headline">Â¶</a></h2>
+<p>DataFlowSanitizer is a generalised dynamic data flow analysis.</p>
+<p>Unlike other Sanitizer tools, this tool is not designed to detect a
+specific class of bugs on its own.  Instead, it provides a generic
+dynamic data flow analysis framework to be used by clients to help
+detect application-specific issues within their own code.</p>
+</div>
+<div class="section" id="usage">
+<h2><a class="toc-backref" href="#id2">Usage</a><a class="headerlink" href="#usage" title="Permalink to this headline">Â¶</a></h2>
+<p>With no program changes, applying DataFlowSanitizer to a program
+will not alter its behavior.  To use DataFlowSanitizer, the program
+uses API functions to apply tags to data to cause it to be tracked, and to
+check the tag of a specific data item.  DataFlowSanitizer manages
+the propagation of tags through the program according to its data flow.</p>
+<p>The APIs are defined in the header file <tt class="docutils literal"><span class="pre">sanitizer/dfsan_interface.h</span></tt>.
+For further information about each function, please refer to the header
+file.</p>
+<div class="section" id="abi-list">
+<h3><a class="toc-backref" href="#id3">ABI List</a><a class="headerlink" href="#abi-list" title="Permalink to this headline">Â¶</a></h3>
+<p>DataFlowSanitizer uses a list of functions known as an ABI list to decide
+whether a call to a specific function should use the operating system’s native
+ABI or whether it should use a variant of this ABI that also propagates labels
+through function parameters and return values.  The ABI list file also controls
+how labels are propagated in the former case.  DataFlowSanitizer comes with a
+default ABI list which is intended to eventually cover the glibc library on
+Linux but it may become necessary for users to extend the ABI list in cases
+where a particular library or function cannot be instrumented (e.g. because
+it is implemented in assembly or another language which DataFlowSanitizer does
+not support) or a function is called from a library or function which cannot
+be instrumented.</p>
+<p>DataFlowSanitizer’s ABI list file is a <a class="reference internal" href="SanitizerSpecialCaseList.html"><em>Sanitizer special case list</em></a>.
+The pass treats every function in the <tt class="docutils literal"><span class="pre">uninstrumented</span></tt> category in the
+ABI list file as conforming to the native ABI.  Unless the ABI list contains
+additional categories for those functions, a call to one of those functions
+will produce a warning message, as the labelling behavior of the function
+is unknown.  The other supported categories are <tt class="docutils literal"><span class="pre">discard</span></tt>, <tt class="docutils literal"><span class="pre">functional</span></tt>
+and <tt class="docutils literal"><span class="pre">custom</span></tt>.</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">discard</span></tt> – To the extent that this function writes to (user-accessible)
+memory, it also updates labels in shadow memory (this condition is trivially
+satisfied for functions which do not write to user-accessible memory).  Its
+return value is unlabelled.</li>
+<li><tt class="docutils literal"><span class="pre">functional</span></tt> – Like <tt class="docutils literal"><span class="pre">discard</span></tt>, except that the label of its return value
+is the union of the label of its arguments.</li>
+<li><tt class="docutils literal"><span class="pre">custom</span></tt> – Instead of calling the function, a custom wrapper <tt class="docutils literal"><span class="pre">__dfsw_F</span></tt>
+is called, where <tt class="docutils literal"><span class="pre">F</span></tt> is the name of the function.  This function may wrap
+the original function or provide its own implementation.  This category is
+generally used for uninstrumentable functions which write to user-accessible
+memory or which have more complex label propagation behavior.  The signature
+of <tt class="docutils literal"><span class="pre">__dfsw_F</span></tt> is based on that of <tt class="docutils literal"><span class="pre">F</span></tt> with each argument having a
+label of type <tt class="docutils literal"><span class="pre">dfsan_label</span></tt> appended to the argument list.  If <tt class="docutils literal"><span class="pre">F</span></tt>
+is of non-void return type a final argument of type <tt class="docutils literal"><span class="pre">dfsan_label</span> <span class="pre">*</span></tt>
+is appended to which the custom function can store the label for the
+return value.  For example:</li>
+</ul>
+<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="kt">int</span> <span class="n">x</span><span class="p">);</span>
+<span class="kt">void</span> <span class="nf">__dfsw_f</span><span class="p">(</span><span class="kt">int</span> <span class="n">x</span><span class="p">,</span> <span class="n">dfsan_label</span> <span class="n">x_label</span><span class="p">);</span>
+
+<span class="kt">void</span> <span class="o">*</span><span class="nf">memcpy</span><span class="p">(</span><span class="kt">void</span> <span class="o">*</span><span class="n">dest</span><span class="p">,</span> <span class="k">const</span> <span class="kt">void</span> <span class="o">*</span><span class="n">src</span><span class="p">,</span> <span class="kt">size_t</span> <span class="n">n</span><span class="p">);</span>
+<span class="kt">void</span> <span class="o">*</span><span class="nf">__dfsw_memcpy</span><span class="p">(</span><span class="kt">void</span> <span class="o">*</span><span class="n">dest</span><span class="p">,</span> <span class="k">const</span> <span class="kt">void</span> <span class="o">*</span><span class="n">src</span><span class="p">,</span> <span class="kt">size_t</span> <span class="n">n</span><span class="p">,</span>
+                    <span class="n">dfsan_label</span> <span class="n">dest_label</span><span class="p">,</span> <span class="n">dfsan_label</span> <span class="n">src_label</span><span class="p">,</span>
+                    <span class="n">dfsan_label</span> <span class="n">n_label</span><span class="p">,</span> <span class="n">dfsan_label</span> <span class="o">*</span><span class="n">ret_label</span><span class="p">);</span>
+</pre></div>
+</div>
+<p>If a function defined in the translation unit being compiled belongs to the
+<tt class="docutils literal"><span class="pre">uninstrumented</span></tt> category, it will be compiled so as to conform to the
+native ABI.  Its arguments will be assumed to be unlabelled, but it will
+propagate labels in shadow memory.</p>
+<p>For example:</p>
+<div class="highlight-none"><div class="highlight"><pre><span></span># main is called by the C runtime using the native ABI.
+fun:main=uninstrumented
+fun:main=discard
+
+# malloc only writes to its internal data structures, not user-accessible memory.
+fun:malloc=uninstrumented
+fun:malloc=discard
+
+# tolower is a pure function.
+fun:tolower=uninstrumented
+fun:tolower=functional
+
+# memcpy needs to copy the shadow from the source to the destination region.
+# This is done in a custom function.
+fun:memcpy=uninstrumented
+fun:memcpy=custom
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="example">
+<h2><a class="toc-backref" href="#id4">Example</a><a class="headerlink" href="#example" title="Permalink to this headline">Â¶</a></h2>
+<p>The following program demonstrates label propagation by checking that
+the correct labels are propagated.</p>
+<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="cp">#include</span> <span class="cpf"><sanitizer/dfsan_interface.h></span><span class="cp"></span>
+<span class="cp">#include</span> <span class="cpf"><assert.h></span><span class="cp"></span>
+
+<span class="kt">int</span> <span class="nf">main</span><span class="p">(</span><span class="kt">void</span><span class="p">)</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">dfsan_label</span> <span class="n">i_label</span> <span class="o">=</span> <span class="n">dfsan_create_label</span><span class="p">(</span><span class="s">"i"</span><span class="p">,</span> <span class="mi">0</span><span class="p">);</span>
+  <span class="n">dfsan_set_label</span><span class="p">(</span><span class="n">i_label</span><span class="p">,</span> <span class="o">&</span><span class="n">i</span><span class="p">,</span> <span class="k">sizeof</span><span class="p">(</span><span class="n">i</span><span class="p">));</span>
+
+  <span class="kt">int</span> <span class="n">j</span> <span class="o">=</span> <span class="mi">2</span><span class="p">;</span>
+  <span class="n">dfsan_label</span> <span class="n">j_label</span> <span class="o">=</span> <span class="n">dfsan_create_label</span><span class="p">(</span><span class="s">"j"</span><span class="p">,</span> <span class="mi">0</span><span class="p">);</span>
+  <span class="n">dfsan_set_label</span><span class="p">(</span><span class="n">j_label</span><span class="p">,</span> <span class="o">&</span><span class="n">j</span><span class="p">,</span> <span class="k">sizeof</span><span class="p">(</span><span class="n">j</span><span class="p">));</span>
+
+  <span class="kt">int</span> <span class="n">k</span> <span class="o">=</span> <span class="mi">3</span><span class="p">;</span>
+  <span class="n">dfsan_label</span> <span class="n">k_label</span> <span class="o">=</span> <span class="n">dfsan_create_label</span><span class="p">(</span><span class="s">"k"</span><span class="p">,</span> <span class="mi">0</span><span class="p">);</span>
+  <span class="n">dfsan_set_label</span><span class="p">(</span><span class="n">k_label</span><span class="p">,</span> <span class="o">&</span><span class="n">k</span><span class="p">,</span> <span class="k">sizeof</span><span class="p">(</span><span class="n">k</span><span class="p">));</span>
+
+  <span class="n">dfsan_label</span> <span class="n">ij_label</span> <span class="o">=</span> <span class="n">dfsan_get_label</span><span class="p">(</span><span class="n">i</span> <span class="o">+</span> <span class="n">j</span><span class="p">);</span>
+  <span class="n">assert</span><span class="p">(</span><span class="n">dfsan_has_label</span><span class="p">(</span><span class="n">ij_label</span><span class="p">,</span> <span class="n">i_label</span><span class="p">));</span>
+  <span class="n">assert</span><span class="p">(</span><span class="n">dfsan_has_label</span><span class="p">(</span><span class="n">ij_label</span><span class="p">,</span> <span class="n">j_label</span><span class="p">));</span>
+  <span class="n">assert</span><span class="p">(</span><span class="o">!</span><span class="n">dfsan_has_label</span><span class="p">(</span><span class="n">ij_label</span><span class="p">,</span> <span class="n">k_label</span><span class="p">));</span>
+
+  <span class="n">dfsan_label</span> <span class="n">ijk_label</span> <span class="o">=</span> <span class="n">dfsan_get_label</span><span class="p">(</span><span class="n">i</span> <span class="o">+</span> <span class="n">j</span> <span class="o">+</span> <span class="n">k</span><span class="p">);</span>
+  <span class="n">assert</span><span class="p">(</span><span class="n">dfsan_has_label</span><span class="p">(</span><span class="n">ijk_label</span><span class="p">,</span> <span class="n">i_label</span><span class="p">));</span>
+  <span class="n">assert</span><span class="p">(</span><span class="n">dfsan_has_label</span><span class="p">(</span><span class="n">ijk_label</span><span class="p">,</span> <span class="n">j_label</span><span class="p">));</span>
+  <span class="n">assert</span><span class="p">(</span><span class="n">dfsan_has_label</span><span class="p">(</span><span class="n">ijk_label</span><span class="p">,</span> <span class="n">k_label</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>
+</div>
+<div class="section" id="current-status">
+<h2><a class="toc-backref" href="#id5">Current status</a><a class="headerlink" href="#current-status" title="Permalink to this headline">Â¶</a></h2>
+<p>DataFlowSanitizer is a work in progress, currently under development for
+x86_64 Linux.</p>
+</div>
+<div class="section" id="design">
+<h2><a class="toc-backref" href="#id6">Design</a><a class="headerlink" href="#design" title="Permalink to this headline">Â¶</a></h2>
+<p>Please refer to the <a class="reference internal" href="DataFlowSanitizerDesign.html"><em>design document</em></a>.</p>
+</div>
+</div>
+
+
+      </div>
+      <div class="bottomnav">
+      
+        <p>
+        Â«  <a href="UndefinedBehaviorSanitizer.html">UndefinedBehaviorSanitizer</a>
+          ::  
+        <a class="uplink" href="index.html">Contents</a>
+          ::  
+        <a href="DataFlowSanitizerDesign.html">DataFlowSanitizer Design Document</a>  Â»
+        </p>
+
+      </div>
+
+    <div class="footer">
+        © Copyright 2007-2017, The Clang Team.
+      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.2.2.
+    </div>
+  </body>
+</html>
\ No newline at end of file

Added: www-releases/trunk/5.0.0/tools/clang/docs/DataFlowSanitizerDesign.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/5.0.0/tools/clang/docs/DataFlowSanitizerDesign.html?rev=312731&view=auto
==============================================================================
--- www-releases/trunk/5.0.0/tools/clang/docs/DataFlowSanitizerDesign.html (added)
+++ www-releases/trunk/5.0.0/tools/clang/docs/DataFlowSanitizerDesign.html Thu Sep  7 10:47:16 2017
@@ -0,0 +1,291 @@
+<!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>DataFlowSanitizer Design Document — Clang 5 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:     '5',
+        COLLAPSE_INDEX: false,
+        FILE_SUFFIX: '.html',
+        HAS_SOURCE:  true
+      };
+    </script>
+    <script type="text/javascript" src="_static/jquery.js"></script>
+    <script type="text/javascript" src="_static/underscore.js"></script>
+    <script type="text/javascript" src="_static/doctools.js"></script>
+    <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+    <link rel="top" title="Clang 5 documentation" href="index.html" />
+    <link rel="up" title="DataFlowSanitizer" href="DataFlowSanitizer.html" />
+    <link rel="next" title="LeakSanitizer" href="LeakSanitizer.html" />
+    <link rel="prev" title="DataFlowSanitizer" href="DataFlowSanitizer.html" /> 
+  </head>
+  <body>
+      <div class="header"><h1 class="heading"><a href="index.html">
+          <span>Clang 5 documentation</span></a></h1>
+        <h2 class="heading"><span>DataFlowSanitizer Design Document</span></h2>
+      </div>
+      <div class="topnav">
+      
+        <p>
+        Â«  <a href="DataFlowSanitizer.html">DataFlowSanitizer</a>
+          ::  
+        <a class="uplink" href="index.html">Contents</a>
+          ::  
+        <a href="LeakSanitizer.html">LeakSanitizer</a>  Â»
+        </p>
+
+      </div>
+      <div class="content">
+        
+        
+  <div class="section" id="dataflowsanitizer-design-document">
+<h1>DataFlowSanitizer Design Document<a class="headerlink" href="#dataflowsanitizer-design-document" title="Permalink to this headline">Â¶</a></h1>
+<p>This document sets out the design for DataFlowSanitizer, a general
+dynamic data flow analysis.  Unlike other Sanitizer tools, this tool is
+not designed to detect a specific class of bugs on its own. Instead,
+it provides a generic dynamic data flow analysis framework to be used
+by clients to help detect application-specific issues within their
+own code.</p>
+<p>DataFlowSanitizer is a program instrumentation which can associate
+a number of taint labels with any data stored in any memory region
+accessible by the program. The analysis is dynamic, which means that
+it operates on a running program, and tracks how the labels propagate
+through that program. The tool shall support a large (>100) number
+of labels, such that programs which operate on large numbers of data
+items may be analysed with each data item being tracked separately.</p>
+<div class="section" id="use-cases">
+<h2>Use Cases<a class="headerlink" href="#use-cases" title="Permalink to this headline">Â¶</a></h2>
+<p>This instrumentation can be used as a tool to help monitor how data
+flows from a program’s inputs (sources) to its outputs (sinks).
+This has applications from a privacy/security perspective in that
+one can audit how a sensitive data item is used within a program and
+ensure it isn’t exiting the program anywhere it shouldn’t be.</p>
+</div>
+<div class="section" id="interface">
+<h2>Interface<a class="headerlink" href="#interface" title="Permalink to this headline">Â¶</a></h2>
+<p>A number of functions are provided which will create taint labels,
+attach labels to memory regions and extract the set of labels
+associated with a specific memory region. These functions are declared
+in the header file <tt class="docutils literal"><span class="pre">sanitizer/dfsan_interface.h</span></tt>.</p>
+<div class="highlight-c"><div class="highlight"><pre><span></span><span class="c1">/// Creates and returns a base label with the given description and user data.</span>
+<span class="n">dfsan_label</span> <span class="nf">dfsan_create_label</span><span class="p">(</span><span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">desc</span><span class="p">,</span> <span class="kt">void</span> <span class="o">*</span><span class="n">userdata</span><span class="p">);</span>
+
+<span class="c1">/// Sets the label for each address in [addr,addr+size) to \c label.</span>
+<span class="kt">void</span> <span class="nf">dfsan_set_label</span><span class="p">(</span><span class="n">dfsan_label</span> <span class="n">label</span><span class="p">,</span> <span class="kt">void</span> <span class="o">*</span><span class="n">addr</span><span class="p">,</span> <span class="kt">size_t</span> <span class="n">size</span><span class="p">);</span>
+
+<span class="c1">/// Sets the label for each address in [addr,addr+size) to the union of the</span>
+<span class="c1">/// current label for that address and \c label.</span>
+<span class="kt">void</span> <span class="nf">dfsan_add_label</span><span class="p">(</span><span class="n">dfsan_label</span> <span class="n">label</span><span class="p">,</span> <span class="kt">void</span> <span class="o">*</span><span class="n">addr</span><span class="p">,</span> <span class="kt">size_t</span> <span class="n">size</span><span class="p">);</span>
+
+<span class="c1">/// Retrieves the label associated with the given data.</span>
+<span class="c1">///</span>
+<span class="c1">/// The type of 'data' is arbitrary.  The function accepts a value of any type,</span>
+<span class="c1">/// which can be truncated or extended (implicitly or explicitly) as necessary.</span>
+<span class="c1">/// The truncation/extension operations will preserve the label of the original</span>
+<span class="c1">/// value.</span>
+<span class="n">dfsan_label</span> <span class="nf">dfsan_get_label</span><span class="p">(</span><span class="kt">long</span> <span class="n">data</span><span class="p">);</span>
+
+<span class="c1">/// Retrieves a pointer to the dfsan_label_info struct for the given label.</span>
+<span class="k">const</span> <span class="k">struct</span> <span class="n">dfsan_label_info</span> <span class="o">*</span><span class="nf">dfsan_get_label_info</span><span class="p">(</span><span class="n">dfsan_label</span> <span class="n">label</span><span class="p">);</span>
+
+<span class="c1">/// Returns whether the given label label contains the label elem.</span>
+<span class="kt">int</span> <span class="nf">dfsan_has_label</span><span class="p">(</span><span class="n">dfsan_label</span> <span class="n">label</span><span class="p">,</span> <span class="n">dfsan_label</span> <span class="n">elem</span><span class="p">);</span>
+
+<span class="c1">/// If the given label label contains a label with the description desc, returns</span>
+<span class="c1">/// that label, else returns 0.</span>
+<span class="n">dfsan_label</span> <span class="nf">dfsan_has_label_with_desc</span><span class="p">(</span><span class="n">dfsan_label</span> <span class="n">label</span><span class="p">,</span> <span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">desc</span><span class="p">);</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="taint-label-representation">
+<h2>Taint label representation<a class="headerlink" href="#taint-label-representation" title="Permalink to this headline">Â¶</a></h2>
+<p>As stated above, the tool must track a large number of taint
+labels. This poses an implementation challenge, as most multiple-label
+tainting systems assign one label per bit to shadow storage, and
+union taint labels using a bitwise or operation. This will not scale
+to clients which use hundreds or thousands of taint labels, as the
+label union operation becomes O(n) in the number of supported labels,
+and data associated with it will quickly dominate the live variable
+set, causing register spills and hampering performance.</p>
+<p>Instead, a low overhead approach is proposed which is best-case O(log<sub>2</sub> n) during execution. The underlying assumption is that
+the required space of label unions is sparse, which is a reasonable
+assumption to make given that we are optimizing for the case where
+applications mostly copy data from one place to another, without often
+invoking the need for an actual union operation. The representation
+of a taint label is a 16-bit integer, and new labels are allocated
+sequentially from a pool. The label identifier 0 is special, and means
+that the data item is unlabelled.</p>
+<p>When a label union operation is requested at a join point (any
+arithmetic or logical operation with two or more operands, such as
+addition), the code checks whether a union is required, whether the
+same union has been requested before, and whether one union label
+subsumes the other. If so, it returns the previously allocated union
+label. If not, it allocates a new union label from the same pool used
+for new labels.</p>
+<p>Specifically, the instrumentation pass will insert code like this
+to decide the union label <tt class="docutils literal"><span class="pre">lu</span></tt> for a pair of labels <tt class="docutils literal"><span class="pre">l1</span></tt>
+and <tt class="docutils literal"><span class="pre">l2</span></tt>:</p>
+<div class="highlight-c"><div class="highlight"><pre><span></span><span class="k">if</span> <span class="p">(</span><span class="n">l1</span> <span class="o">==</span> <span class="n">l2</span><span class="p">)</span>
+  <span class="n">lu</span> <span class="o">=</span> <span class="n">l1</span><span class="p">;</span>
+<span class="k">else</span>
+  <span class="n">lu</span> <span class="o">=</span> <span class="n">__dfsan_union</span><span class="p">(</span><span class="n">l1</span><span class="p">,</span> <span class="n">l2</span><span class="p">);</span>
+</pre></div>
+</div>
+<p>The equality comparison is outlined, to provide an early exit in
+the common cases where the program is processing unlabelled data, or
+where the two data items have the same label.  <tt class="docutils literal"><span class="pre">__dfsan_union</span></tt> is
+a runtime library function which performs all other union computation.</p>
+<p>Further optimizations are possible, for example if <tt class="docutils literal"><span class="pre">l1</span></tt> is known
+at compile time to be zero (e.g. it is derived from a constant),
+<tt class="docutils literal"><span class="pre">l2</span></tt> can be used for <tt class="docutils literal"><span class="pre">lu</span></tt>, and vice versa.</p>
+</div>
+<div class="section" id="memory-layout-and-label-management">
+<h2>Memory layout and label management<a class="headerlink" href="#memory-layout-and-label-management" title="Permalink to this headline">Â¶</a></h2>
+<p>The following is the current memory layout for Linux/x86_64:</p>
+<table border="1" class="docutils">
+<colgroup>
+<col width="30%" />
+<col width="30%" />
+<col width="40%" />
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">Start</th>
+<th class="head">End</th>
+<th class="head">Use</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>0x700000008000</td>
+<td>0x800000000000</td>
+<td>application memory</td>
+</tr>
+<tr class="row-odd"><td>0x200200000000</td>
+<td>0x700000008000</td>
+<td>unused</td>
+</tr>
+<tr class="row-even"><td>0x200000000000</td>
+<td>0x200200000000</td>
+<td>union table</td>
+</tr>
+<tr class="row-odd"><td>0x000000010000</td>
+<td>0x200000000000</td>
+<td>shadow memory</td>
+</tr>
+<tr class="row-even"><td>0x000000000000</td>
+<td>0x000000010000</td>
+<td>reserved by kernel</td>
+</tr>
+</tbody>
+</table>
+<p>Each byte of application memory corresponds to two bytes of shadow
+memory, which are used to store its taint label. As for LLVM SSA
+registers, we have not found it necessary to associate a label with
+each byte or bit of data, as some other tools do. Instead, labels are
+associated directly with registers.  Loads will result in a union of
+all shadow labels corresponding to bytes loaded (which most of the
+time will be short circuited by the initial comparison) and stores will
+result in a copy of the label to the shadow of all bytes stored to.</p>
+</div>
+<div class="section" id="propagating-labels-through-arguments">
+<h2>Propagating labels through arguments<a class="headerlink" href="#propagating-labels-through-arguments" title="Permalink to this headline">Â¶</a></h2>
+<p>In order to propagate labels through function arguments and return values,
+DataFlowSanitizer changes the ABI of each function in the translation unit.
+There are currently two supported ABIs:</p>
+<ul class="simple">
+<li>Args – Argument and return value labels are passed through additional
+arguments and by modifying the return type.</li>
+<li>TLS – Argument and return value labels are passed through TLS variables
+<tt class="docutils literal"><span class="pre">__dfsan_arg_tls</span></tt> and <tt class="docutils literal"><span class="pre">__dfsan_retval_tls</span></tt>.</li>
+</ul>
+<p>The main advantage of the TLS ABI is that it is more tolerant of ABI mismatches
+(TLS storage is not shared with any other form of storage, whereas extra
+arguments may be stored in registers which under the native ABI are not used
+for parameter passing and thus could contain arbitrary values).  On the other
+hand the args ABI is more efficient and allows ABI mismatches to be more easily
+identified by checking for nonzero labels in nominally unlabelled programs.</p>
+</div>
+<div class="section" id="implementing-the-abi-list">
+<h2>Implementing the ABI list<a class="headerlink" href="#implementing-the-abi-list" title="Permalink to this headline">Â¶</a></h2>
+<p>The <a class="reference external" href="DataFlowSanitizer.html#abi-list">ABI list</a> provides a list of functions
+which conform to the native ABI, each of which is callable from an instrumented
+program.  This is implemented by replacing each reference to a native ABI
+function with a reference to a function which uses the instrumented ABI.
+Such functions are automatically-generated wrappers for the native functions.
+For example, given the ABI list example provided in the user manual, the
+following wrappers will be generated under the args ABI:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span></span><span class="k">define</span> <span class="k">linkonce_odr</span> <span class="p">{</span> <span class="k">i8</span><span class="p">*,</span> <span class="k">i16</span> <span class="p">}</span> <span class="vg">@"dfsw$malloc"</span><span class="p">(</span><span class="k">i64</span> <span class="nv nv-Anonymous">%0</span><span class="p">,</span> <span class="k">i16</span> <span class="nv nv-Anonymous">%1</span><span class="p">)</span> <span class="p">{</span>
+<span class="nl">entry:</span>
+  <span class="nv nv-Anonymous">%2</span> <span class="p">=</span> <span class="k">call</span> <span class="k">i8</span><span class="p">*</span> <span class="vg">@malloc</span><span class="p">(</span><span class="k">i64</span> <span class="nv nv-Anonymous">%0</span><span class="p">)</span>
+  <span class="nv nv-Anonymous">%3</span> <span class="p">=</span> <span class="k">insertvalue</span> <span class="p">{</span> <span class="k">i8</span><span class="p">*,</span> <span class="k">i16</span> <span class="p">}</span> <span class="k">undef</span><span class="p">,</span> <span class="k">i8</span><span class="p">*</span> <span class="nv nv-Anonymous">%2</span><span class="p">,</span> <span class="m">0</span>
+  <span class="nv nv-Anonymous">%4</span> <span class="p">=</span> <span class="k">insertvalue</span> <span class="p">{</span> <span class="k">i8</span><span class="p">*,</span> <span class="k">i16</span> <span class="p">}</span> <span class="nv nv-Anonymous">%3</span><span class="p">,</span> <span class="k">i16</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span>
+  <span class="k">ret</span> <span class="p">{</span> <span class="k">i8</span><span class="p">*,</span> <span class="k">i16</span> <span class="p">}</span> <span class="nv nv-Anonymous">%4</span>
+<span class="p">}</span>
+
+<span class="k">define</span> <span class="k">linkonce_odr</span> <span class="p">{</span> <span class="k">i32</span><span class="p">,</span> <span class="k">i16</span> <span class="p">}</span> <span class="vg">@"dfsw$tolower"</span><span class="p">(</span><span class="k">i32</span> <span class="nv nv-Anonymous">%0</span><span class="p">,</span> <span class="k">i16</span> <span class="nv nv-Anonymous">%1</span><span class="p">)</span> <span class="p">{</span>
+<span class="nl">entry:</span>
+  <span class="nv nv-Anonymous">%2</span> <span class="p">=</span> <span class="k">call</span> <span class="k">i32</span> <span class="vg">@tolower</span><span class="p">(</span><span class="k">i32</span> <span class="nv nv-Anonymous">%0</span><span class="p">)</span>
+  <span class="nv nv-Anonymous">%3</span> <span class="p">=</span> <span class="k">insertvalue</span> <span class="p">{</span> <span class="k">i32</span><span class="p">,</span> <span class="k">i16</span> <span class="p">}</span> <span class="k">undef</span><span class="p">,</span> <span class="k">i32</span> <span class="nv nv-Anonymous">%2</span><span class="p">,</span> <span class="m">0</span>
+  <span class="nv nv-Anonymous">%4</span> <span class="p">=</span> <span class="k">insertvalue</span> <span class="p">{</span> <span class="k">i32</span><span class="p">,</span> <span class="k">i16</span> <span class="p">}</span> <span class="nv nv-Anonymous">%3</span><span class="p">,</span> <span class="k">i16</span> <span class="nv nv-Anonymous">%1</span><span class="p">,</span> <span class="m">1</span>
+  <span class="k">ret</span> <span class="p">{</span> <span class="k">i32</span><span class="p">,</span> <span class="k">i16</span> <span class="p">}</span> <span class="nv nv-Anonymous">%4</span>
+<span class="p">}</span>
+
+<span class="k">define</span> <span class="k">linkonce_odr</span> <span class="p">{</span> <span class="k">i8</span><span class="p">*,</span> <span class="k">i16</span> <span class="p">}</span> <span class="vg">@"dfsw$memcpy"</span><span class="p">(</span><span class="k">i8</span><span class="p">*</span> <span class="nv nv-Anonymous">%0</span><span class="p">,</span> <span class="k">i8</span><span class="p">*</span> <span class="nv nv-Anonymous">%1</span><span class="p">,</span> <span class="k">i64</span> <span class="nv nv-Anonymous">%2</span><span class="p">,</span> <span class="k">i16</span> <span class="nv nv-Anonymous">%3</span><span class="p">,</span> <span class="k">i16</span> <span class="nv nv-Anonymous">%4</span><span class="p">,</span> <span class="k">i16</span> <span class="nv nv-Anonymous">%5</span><span class="p">)</span> <span class="p">{</span>
+<span class="nl">entry:</span>
+  <span class="nv">%labelreturn</span> <span class="p">=</span> <span class="k">alloca</span> <span class="k">i16</span>
+  <span class="nv nv-Anonymous">%6</span> <span class="p">=</span> <span class="k">call</span> <span class="k">i8</span><span class="p">*</span> <span class="vg">@__dfsw_memcpy</span><span class="p">(</span><span class="k">i8</span><span class="p">*</span> <span class="nv nv-Anonymous">%0</span><span class="p">,</span> <span class="k">i8</span><span class="p">*</span> <span class="nv nv-Anonymous">%1</span><span class="p">,</span> <span class="k">i64</span> <span class="nv nv-Anonymous">%2</span><span class="p">,</span> <span class="k">i16</span> <span class="nv nv-Anonymous">%3</span><span class="p">,</span> <span class="k">i16</span> <span class="nv nv-Anonymous">%4</span><span class="p">,</span> <span class="k">i16</span> <span class="nv nv-Anonymous">%5</span><span class="p">,</span> <span class="k">i16</span><span class="p">*</span> <span class="nv">%labelreturn</span><span class="p">)</span>
+  <span class="nv nv-Anonymous">%7</span> <span class="p">=</span> <span class="k">load</span> <span class="k">i16</span><span class="p">*</span> <span class="nv">%labelreturn</span>
+  <span class="nv nv-Anonymous">%8</span> <span class="p">=</span> <span class="k">insertvalue</span> <span class="p">{</span> <span class="k">i8</span><span class="p">*,</span> <span class="k">i16</span> <span class="p">}</span> <span class="k">undef</span><span class="p">,</span> <span class="k">i8</span><span class="p">*</span> <span class="nv nv-Anonymous">%6</span><span class="p">,</span> <span class="m">0</span>
+  <span class="nv nv-Anonymous">%9</span> <span class="p">=</span> <span class="k">insertvalue</span> <span class="p">{</span> <span class="k">i8</span><span class="p">*,</span> <span class="k">i16</span> <span class="p">}</span> <span class="nv nv-Anonymous">%8</span><span class="p">,</span> <span class="k">i16</span> <span class="nv nv-Anonymous">%7</span><span class="p">,</span> <span class="m">1</span>
+  <span class="k">ret</span> <span class="p">{</span> <span class="k">i8</span><span class="p">*,</span> <span class="k">i16</span> <span class="p">}</span> <span class="nv nv-Anonymous">%9</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>As an optimization, direct calls to native ABI functions will call the
+native ABI function directly and the pass will compute the appropriate label
+internally.  This has the advantage of reducing the number of union operations
+required when the return value label is known to be zero (i.e. <tt class="docutils literal"><span class="pre">discard</span></tt>
+functions, or <tt class="docutils literal"><span class="pre">functional</span></tt> functions with known unlabelled arguments).</p>
+</div>
+<div class="section" id="checking-abi-consistency">
+<h2>Checking ABI Consistency<a class="headerlink" href="#checking-abi-consistency" title="Permalink to this headline">Â¶</a></h2>
+<p>DFSan changes the ABI of each function in the module.  This makes it possible
+for a function with the native ABI to be called with the instrumented ABI,
+or vice versa, thus possibly invoking undefined behavior.  A simple way
+of statically detecting instances of this problem is to prepend the prefix
+“dfs$” to the name of each instrumented-ABI function.</p>
+<p>This will not catch every such problem; in particular function pointers passed
+across the instrumented-native barrier cannot be used on the other side.
+These problems could potentially be caught dynamically.</p>
+</div>
+</div>
+
+
+      </div>
+      <div class="bottomnav">
+      
+        <p>
+        Â«  <a href="DataFlowSanitizer.html">DataFlowSanitizer</a>
+          ::  
+        <a class="uplink" href="index.html">Contents</a>
+          ::  
+        <a href="LeakSanitizer.html">LeakSanitizer</a>  Â»
+        </p>
+
+      </div>
+
+    <div class="footer">
+        © Copyright 2007-2017, The Clang Team.
+      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.2.2.
+    </div>
+  </body>
+</html>
\ No newline at end of file


