[www-releases] r336152 - Add 6.0.1 docs

Tom Stellard via llvm-commits llvm-commits at lists.llvm.org
Mon Jul 2 16:21:47 PDT 2018


Added: www-releases/trunk/6.0.1/docs/LangRef.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/6.0.1/docs/LangRef.html?rev=336152&view=auto
==============================================================================
--- www-releases/trunk/6.0.1/docs/LangRef.html (added)
+++ www-releases/trunk/6.0.1/docs/LangRef.html Mon Jul  2 16:21:43 2018
@@ -0,0 +1,14324 @@
+
+
+<!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>LLVM Language Reference Manual — LLVM 6 documentation</title>
+    
+    <link rel="stylesheet" href="_static/llvm-theme.css" type="text/css" />
+    <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+    
+    <script type="text/javascript">
+      var DOCUMENTATION_OPTIONS = {
+        URL_ROOT:    '',
+        VERSION:     '6',
+        COLLAPSE_INDEX: false,
+        FILE_SUFFIX: '.html',
+        HAS_SOURCE:  true
+      };
+    </script>
+    <script type="text/javascript" src="_static/jquery.js"></script>
+    <script type="text/javascript" src="_static/underscore.js"></script>
+    <script type="text/javascript" src="_static/doctools.js"></script>
+    <link rel="top" title="LLVM 6 documentation" href="index.html" />
+    <link rel="next" title="Building LLVM with CMake" href="CMake.html" />
+    <link rel="prev" title="Overview" href="index.html" />
+<style type="text/css">
+  table.right { float: right; margin-left: 20px; }
+  table.right td { border: 1px solid #ccc; }
+</style>
+
+  </head>
+  <body>
+<div class="logo">
+  <a href="index.html">
+    <img src="_static/logo.png"
+         alt="LLVM Logo" width="250" height="88"/></a>
+</div>
+
+    <div class="related">
+      <h3>Navigation</h3>
+      <ul>
+        <li class="right" style="margin-right: 10px">
+          <a href="genindex.html" title="General Index"
+             accesskey="I">index</a></li>
+        <li class="right" >
+          <a href="CMake.html" title="Building LLVM with CMake"
+             accesskey="N">next</a> |</li>
+        <li class="right" >
+          <a href="index.html" title="Overview"
+             accesskey="P">previous</a> |</li>
+  <li><a href="http://llvm.org/">LLVM Home</a> | </li>
+  <li><a href="index.html">Documentation</a>»</li>
+ 
+      </ul>
+    </div>
+
+
+    <div class="document">
+      <div class="documentwrapper">
+          <div class="body">
+            
+  <div class="section" id="llvm-language-reference-manual">
+<h1>LLVM Language Reference Manual<a class="headerlink" href="#llvm-language-reference-manual" title="Permalink to this headline">¶</a></h1>
+<div class="contents local topic" id="contents">
+<ul class="simple">
+<li><a class="reference internal" href="#abstract" id="id813">Abstract</a></li>
+<li><a class="reference internal" href="#introduction" id="id814">Introduction</a><ul>
+<li><a class="reference internal" href="#well-formedness" id="id815">Well-Formedness</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#identifiers" id="id816">Identifiers</a></li>
+<li><a class="reference internal" href="#high-level-structure" id="id817">High Level Structure</a><ul>
+<li><a class="reference internal" href="#module-structure" id="id818">Module Structure</a></li>
+<li><a class="reference internal" href="#linkage-types" id="id819">Linkage Types</a></li>
+<li><a class="reference internal" href="#calling-conventions" id="id820">Calling Conventions</a></li>
+<li><a class="reference internal" href="#visibility-styles" id="id821">Visibility Styles</a></li>
+<li><a class="reference internal" href="#dll-storage-classes" id="id822">DLL Storage Classes</a></li>
+<li><a class="reference internal" href="#thread-local-storage-models" id="id823">Thread Local Storage Models</a></li>
+<li><a class="reference internal" href="#runtime-preemption-specifiers" id="id824">Runtime Preemption Specifiers</a></li>
+<li><a class="reference internal" href="#structure-types" id="id825">Structure Types</a></li>
+<li><a class="reference internal" href="#non-integral-pointer-type" id="id826">Non-Integral Pointer Type</a></li>
+<li><a class="reference internal" href="#global-variables" id="id827">Global Variables</a></li>
+<li><a class="reference internal" href="#functions" id="id828">Functions</a></li>
+<li><a class="reference internal" href="#aliases" id="id829">Aliases</a></li>
+<li><a class="reference internal" href="#ifuncs" id="id830">IFuncs</a></li>
+<li><a class="reference internal" href="#comdats" id="id831">Comdats</a></li>
+<li><a class="reference internal" href="#named-metadata" id="id832">Named Metadata</a></li>
+<li><a class="reference internal" href="#parameter-attributes" id="id833">Parameter Attributes</a></li>
+<li><a class="reference internal" href="#garbage-collector-strategy-names" id="id834">Garbage Collector Strategy Names</a></li>
+<li><a class="reference internal" href="#prefix-data" id="id835">Prefix Data</a></li>
+<li><a class="reference internal" href="#prologue-data" id="id836">Prologue Data</a></li>
+<li><a class="reference internal" href="#personality-function" id="id837">Personality Function</a></li>
+<li><a class="reference internal" href="#attribute-groups" id="id838">Attribute Groups</a></li>
+<li><a class="reference internal" href="#function-attributes" id="id839">Function Attributes</a></li>
+<li><a class="reference internal" href="#global-attributes" id="id840">Global Attributes</a></li>
+<li><a class="reference internal" href="#operand-bundles" id="id841">Operand Bundles</a><ul>
+<li><a class="reference internal" href="#deoptimization-operand-bundles" id="id842">Deoptimization Operand Bundles</a></li>
+<li><a class="reference internal" href="#funclet-operand-bundles" id="id843">Funclet Operand Bundles</a></li>
+<li><a class="reference internal" href="#gc-transition-operand-bundles" id="id844">GC Transition Operand Bundles</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#module-level-inline-assembly" id="id845">Module-Level Inline Assembly</a></li>
+<li><a class="reference internal" href="#data-layout" id="id846">Data Layout</a></li>
+<li><a class="reference internal" href="#target-triple" id="id847">Target Triple</a></li>
+<li><a class="reference internal" href="#pointer-aliasing-rules" id="id848">Pointer Aliasing Rules</a></li>
+<li><a class="reference internal" href="#volatile-memory-accesses" id="id849">Volatile Memory Accesses</a></li>
+<li><a class="reference internal" href="#memory-model-for-concurrent-operations" id="id850">Memory Model for Concurrent Operations</a></li>
+<li><a class="reference internal" href="#atomic-memory-ordering-constraints" id="id851">Atomic Memory Ordering Constraints</a></li>
+<li><a class="reference internal" href="#fast-math-flags" id="id852">Fast-Math Flags</a></li>
+<li><a class="reference internal" href="#use-list-order-directives" id="id853">Use-list Order Directives</a></li>
+<li><a class="reference internal" href="#source-filename" id="id854">Source Filename</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#type-system" id="id855">Type System</a><ul>
+<li><a class="reference internal" href="#void-type" id="id856">Void Type</a></li>
+<li><a class="reference internal" href="#function-type" id="id857">Function Type</a></li>
+<li><a class="reference internal" href="#first-class-types" id="id858">First Class Types</a><ul>
+<li><a class="reference internal" href="#single-value-types" id="id859">Single Value Types</a><ul>
+<li><a class="reference internal" href="#integer-type" id="id860">Integer Type</a></li>
+<li><a class="reference internal" href="#floating-point-types" id="id861">Floating Point Types</a></li>
+<li><a class="reference internal" href="#x86-mmx-type" id="id862">X86_mmx Type</a></li>
+<li><a class="reference internal" href="#pointer-type" id="id863">Pointer Type</a></li>
+<li><a class="reference internal" href="#vector-type" id="id864">Vector Type</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#label-type" id="id865">Label Type</a></li>
+<li><a class="reference internal" href="#token-type" id="id866">Token Type</a></li>
+<li><a class="reference internal" href="#metadata-type" id="id867">Metadata Type</a></li>
+<li><a class="reference internal" href="#aggregate-types" id="id868">Aggregate Types</a><ul>
+<li><a class="reference internal" href="#array-type" id="id869">Array Type</a></li>
+<li><a class="reference internal" href="#structure-type" id="id870">Structure Type</a></li>
+<li><a class="reference internal" href="#opaque-structure-types" id="id871">Opaque Structure Types</a></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#constants" id="id872">Constants</a><ul>
+<li><a class="reference internal" href="#simple-constants" id="id873">Simple Constants</a></li>
+<li><a class="reference internal" href="#complex-constants" id="id874">Complex Constants</a></li>
+<li><a class="reference internal" href="#global-variable-and-function-addresses" id="id875">Global Variable and Function Addresses</a></li>
+<li><a class="reference internal" href="#undefined-values" id="id876">Undefined Values</a></li>
+<li><a class="reference internal" href="#poison-values" id="id877">Poison Values</a></li>
+<li><a class="reference internal" href="#addresses-of-basic-blocks" id="id878">Addresses of Basic Blocks</a></li>
+<li><a class="reference internal" href="#constant-expressions" id="id879">Constant Expressions</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#other-values" id="id880">Other Values</a><ul>
+<li><a class="reference internal" href="#inline-assembler-expressions" id="id881">Inline Assembler Expressions</a><ul>
+<li><a class="reference internal" href="#inline-asm-constraint-string" id="id882">Inline Asm Constraint String</a><ul>
+<li><a class="reference internal" href="#output-constraints" id="id883">Output constraints</a></li>
+<li><a class="reference internal" href="#input-constraints" id="id884">Input constraints</a></li>
+<li><a class="reference internal" href="#indirect-inputs-and-outputs" id="id885">Indirect inputs and outputs</a></li>
+<li><a class="reference internal" href="#clobber-constraints" id="id886">Clobber constraints</a></li>
+<li><a class="reference internal" href="#constraint-codes" id="id887">Constraint Codes</a></li>
+<li><a class="reference internal" href="#supported-constraint-code-list" id="id888">Supported Constraint Code List</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#asm-template-argument-modifiers" id="id889">Asm template argument modifiers</a></li>
+<li><a class="reference internal" href="#inline-asm-metadata" id="id890">Inline Asm Metadata</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#metadata" id="id891">Metadata</a><ul>
+<li><a class="reference internal" href="#metadata-nodes-and-metadata-strings" id="id892">Metadata Nodes and Metadata Strings</a><ul>
+<li><a class="reference internal" href="#specialized-metadata-nodes" id="id893">Specialized Metadata Nodes</a><ul>
+<li><a class="reference internal" href="#dicompileunit" id="id894">DICompileUnit</a></li>
+<li><a class="reference internal" href="#difile" id="id895">DIFile</a></li>
+<li><a class="reference internal" href="#dibasictype" id="id896">DIBasicType</a></li>
+<li><a class="reference internal" href="#disubroutinetype" id="id897">DISubroutineType</a></li>
+<li><a class="reference internal" href="#diderivedtype" id="id898">DIDerivedType</a></li>
+<li><a class="reference internal" href="#dicompositetype" id="id899">DICompositeType</a></li>
+<li><a class="reference internal" href="#disubrange" id="id900">DISubrange</a></li>
+<li><a class="reference internal" href="#dienumerator" id="id901">DIEnumerator</a></li>
+<li><a class="reference internal" href="#ditemplatetypeparameter" id="id902">DITemplateTypeParameter</a></li>
+<li><a class="reference internal" href="#ditemplatevalueparameter" id="id903">DITemplateValueParameter</a></li>
+<li><a class="reference internal" href="#dinamespace" id="id904">DINamespace</a></li>
+<li><a class="reference internal" href="#diglobalvariable" id="id905">DIGlobalVariable</a></li>
+<li><a class="reference internal" href="#disubprogram" id="id906">DISubprogram</a></li>
+<li><a class="reference internal" href="#dilexicalblock" id="id907">DILexicalBlock</a></li>
+<li><a class="reference internal" href="#dilexicalblockfile" id="id908">DILexicalBlockFile</a></li>
+<li><a class="reference internal" href="#dilocation" id="id909">DILocation</a></li>
+<li><a class="reference internal" href="#dilocalvariable" id="id910">DILocalVariable</a></li>
+<li><a class="reference internal" href="#diexpression" id="id911">DIExpression</a></li>
+<li><a class="reference internal" href="#diobjcproperty" id="id912">DIObjCProperty</a></li>
+<li><a class="reference internal" href="#diimportedentity" id="id913">DIImportedEntity</a></li>
+<li><a class="reference internal" href="#dimacro" id="id914">DIMacro</a></li>
+<li><a class="reference internal" href="#dimacrofile" id="id915">DIMacroFile</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#tbaa-metadata" id="id916">‘<tt class="docutils literal"><span class="pre">tbaa</span></tt>‘ Metadata</a><ul>
+<li><a class="reference internal" href="#semantics" id="id917">Semantics</a></li>
+<li><a class="reference internal" href="#representation" id="id918">Representation</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#tbaa-struct-metadata" id="id919">‘<tt class="docutils literal"><span class="pre">tbaa.struct</span></tt>‘ Metadata</a></li>
+<li><a class="reference internal" href="#noalias-and-alias-scope-metadata" id="id920">‘<tt class="docutils literal"><span class="pre">noalias</span></tt>‘ and ‘<tt class="docutils literal"><span class="pre">alias.scope</span></tt>‘ Metadata</a></li>
+<li><a class="reference internal" href="#fpmath-metadata" id="id921">‘<tt class="docutils literal"><span class="pre">fpmath</span></tt>‘ Metadata</a></li>
+<li><a class="reference internal" href="#range-metadata" id="id922">‘<tt class="docutils literal"><span class="pre">range</span></tt>‘ Metadata</a></li>
+<li><a class="reference internal" href="#absolute-symbol-metadata" id="id923">‘<tt class="docutils literal"><span class="pre">absolute_symbol</span></tt>‘ Metadata</a></li>
+<li><a class="reference internal" href="#callees-metadata" id="id924">‘<tt class="docutils literal"><span class="pre">callees</span></tt>‘ Metadata</a></li>
+<li><a class="reference internal" href="#unpredictable-metadata" id="id925">‘<tt class="docutils literal"><span class="pre">unpredictable</span></tt>‘ Metadata</a></li>
+<li><a class="reference internal" href="#llvm-loop" id="id926">‘<tt class="docutils literal"><span class="pre">llvm.loop</span></tt>‘</a></li>
+<li><a class="reference internal" href="#llvm-loop-vectorize-and-llvm-loop-interleave" id="id927">‘<tt class="docutils literal"><span class="pre">llvm.loop.vectorize</span></tt>‘ and ‘<tt class="docutils literal"><span class="pre">llvm.loop.interleave</span></tt>‘</a></li>
+<li><a class="reference internal" href="#llvm-loop-interleave-count-metadata" id="id928">‘<tt class="docutils literal"><span class="pre">llvm.loop.interleave.count</span></tt>‘ Metadata</a></li>
+<li><a class="reference internal" href="#llvm-loop-vectorize-enable-metadata" id="id929">‘<tt class="docutils literal"><span class="pre">llvm.loop.vectorize.enable</span></tt>‘ Metadata</a></li>
+<li><a class="reference internal" href="#llvm-loop-vectorize-width-metadata" id="id930">‘<tt class="docutils literal"><span class="pre">llvm.loop.vectorize.width</span></tt>‘ Metadata</a></li>
+<li><a class="reference internal" href="#llvm-loop-unroll" id="id931">‘<tt class="docutils literal"><span class="pre">llvm.loop.unroll</span></tt>‘</a></li>
+<li><a class="reference internal" href="#llvm-loop-unroll-count-metadata" id="id932">‘<tt class="docutils literal"><span class="pre">llvm.loop.unroll.count</span></tt>‘ Metadata</a></li>
+<li><a class="reference internal" href="#llvm-loop-unroll-disable-metadata" id="id933">‘<tt class="docutils literal"><span class="pre">llvm.loop.unroll.disable</span></tt>‘ Metadata</a></li>
+<li><a class="reference internal" href="#llvm-loop-unroll-runtime-disable-metadata" id="id934">‘<tt class="docutils literal"><span class="pre">llvm.loop.unroll.runtime.disable</span></tt>‘ Metadata</a></li>
+<li><a class="reference internal" href="#llvm-loop-unroll-enable-metadata" id="id935">‘<tt class="docutils literal"><span class="pre">llvm.loop.unroll.enable</span></tt>‘ Metadata</a></li>
+<li><a class="reference internal" href="#llvm-loop-unroll-full-metadata" id="id936">‘<tt class="docutils literal"><span class="pre">llvm.loop.unroll.full</span></tt>‘ Metadata</a></li>
+<li><a class="reference internal" href="#llvm-loop-licm-versioning-disable-metadata" id="id937">‘<tt class="docutils literal"><span class="pre">llvm.loop.licm_versioning.disable</span></tt>‘ Metadata</a></li>
+<li><a class="reference internal" href="#llvm-loop-distribute-enable-metadata" id="id938">‘<tt class="docutils literal"><span class="pre">llvm.loop.distribute.enable</span></tt>‘ Metadata</a></li>
+<li><a class="reference internal" href="#llvm-mem" id="id939">‘<tt class="docutils literal"><span class="pre">llvm.mem</span></tt>‘</a></li>
+<li><a class="reference internal" href="#llvm-mem-parallel-loop-access-metadata" id="id940">‘<tt class="docutils literal"><span class="pre">llvm.mem.parallel_loop_access</span></tt>‘ Metadata</a></li>
+<li><a class="reference internal" href="#irr-loop-metadata" id="id941">‘<tt class="docutils literal"><span class="pre">irr_loop</span></tt>‘ Metadata</a></li>
+<li><a class="reference internal" href="#invariant-group-metadata" id="id942">‘<tt class="docutils literal"><span class="pre">invariant.group</span></tt>‘ Metadata</a></li>
+<li><a class="reference internal" href="#type-metadata" id="id943">‘<tt class="docutils literal"><span class="pre">type</span></tt>‘ Metadata</a></li>
+<li><a class="reference internal" href="#associated-metadata" id="id944">‘<tt class="docutils literal"><span class="pre">associated</span></tt>‘ Metadata</a></li>
+<li><a class="reference internal" href="#prof-metadata" id="id945">‘<tt class="docutils literal"><span class="pre">prof</span></tt>‘ Metadata</a><ul>
+<li><a class="reference internal" href="#branch-weights" id="id946">branch_weights</a></li>
+<li><a class="reference internal" href="#function-entry-count" id="id947">function_entry_count</a></li>
+<li><a class="reference internal" href="#vp" id="id948">VP</a></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#module-flags-metadata" id="id949">Module Flags Metadata</a><ul>
+<li><a class="reference internal" href="#objective-c-garbage-collection-module-flags-metadata" id="id950">Objective-C Garbage Collection Module Flags Metadata</a></li>
+<li><a class="reference internal" href="#c-type-width-module-flags-metadata" id="id951">C type width Module Flags Metadata</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#automatic-linker-flags-named-metadata" id="id952">Automatic Linker Flags Named Metadata</a></li>
+<li><a class="reference internal" href="#intrinsic-global-variables" id="id953">Intrinsic Global Variables</a><ul>
+<li><a class="reference internal" href="#the-llvm-used-global-variable" id="id954">The ‘<tt class="docutils literal"><span class="pre">llvm.used</span></tt>‘ Global Variable</a></li>
+<li><a class="reference internal" href="#the-llvm-compiler-used-global-variable" id="id955">The ‘<tt class="docutils literal"><span class="pre">llvm.compiler.used</span></tt>‘ Global Variable</a></li>
+<li><a class="reference internal" href="#the-llvm-global-ctors-global-variable" id="id956">The ‘<tt class="docutils literal"><span class="pre">llvm.global_ctors</span></tt>‘ Global Variable</a></li>
+<li><a class="reference internal" href="#the-llvm-global-dtors-global-variable" id="id957">The ‘<tt class="docutils literal"><span class="pre">llvm.global_dtors</span></tt>‘ Global Variable</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#instruction-reference" id="id958">Instruction Reference</a><ul>
+<li><a class="reference internal" href="#terminator-instructions" id="id959">Terminator Instructions</a><ul>
+<li><a class="reference internal" href="#ret-instruction" id="id960">‘<tt class="docutils literal"><span class="pre">ret</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#syntax" id="id961">Syntax:</a></li>
+<li><a class="reference internal" href="#overview" id="id962">Overview:</a></li>
+<li><a class="reference internal" href="#arguments" id="id963">Arguments:</a></li>
+<li><a class="reference internal" href="#id20" id="id964">Semantics:</a></li>
+<li><a class="reference internal" href="#example" id="id965">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#br-instruction" id="id966">‘<tt class="docutils literal"><span class="pre">br</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id21" id="id967">Syntax:</a></li>
+<li><a class="reference internal" href="#id22" id="id968">Overview:</a></li>
+<li><a class="reference internal" href="#id23" id="id969">Arguments:</a></li>
+<li><a class="reference internal" href="#id24" id="id970">Semantics:</a></li>
+<li><a class="reference internal" href="#id25" id="id971">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#switch-instruction" id="id972">‘<tt class="docutils literal"><span class="pre">switch</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id26" id="id973">Syntax:</a></li>
+<li><a class="reference internal" href="#id27" id="id974">Overview:</a></li>
+<li><a class="reference internal" href="#id28" id="id975">Arguments:</a></li>
+<li><a class="reference internal" href="#id29" id="id976">Semantics:</a></li>
+<li><a class="reference internal" href="#implementation" id="id977">Implementation:</a></li>
+<li><a class="reference internal" href="#id30" id="id978">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#indirectbr-instruction" id="id979">‘<tt class="docutils literal"><span class="pre">indirectbr</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id31" id="id980">Syntax:</a></li>
+<li><a class="reference internal" href="#id32" id="id981">Overview:</a></li>
+<li><a class="reference internal" href="#id33" id="id982">Arguments:</a></li>
+<li><a class="reference internal" href="#id34" id="id983">Semantics:</a></li>
+<li><a class="reference internal" href="#id35" id="id984">Implementation:</a></li>
+<li><a class="reference internal" href="#id36" id="id985">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#invoke-instruction" id="id986">‘<tt class="docutils literal"><span class="pre">invoke</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id37" id="id987">Syntax:</a></li>
+<li><a class="reference internal" href="#id38" id="id988">Overview:</a></li>
+<li><a class="reference internal" href="#id39" id="id989">Arguments:</a></li>
+<li><a class="reference internal" href="#id40" id="id990">Semantics:</a></li>
+<li><a class="reference internal" href="#id41" id="id991">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#resume-instruction" id="id992">‘<tt class="docutils literal"><span class="pre">resume</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id42" id="id993">Syntax:</a></li>
+<li><a class="reference internal" href="#id43" id="id994">Overview:</a></li>
+<li><a class="reference internal" href="#id44" id="id995">Arguments:</a></li>
+<li><a class="reference internal" href="#id45" id="id996">Semantics:</a></li>
+<li><a class="reference internal" href="#id46" id="id997">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#catchswitch-instruction" id="id998">‘<tt class="docutils literal"><span class="pre">catchswitch</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id47" id="id999">Syntax:</a></li>
+<li><a class="reference internal" href="#id48" id="id1000">Overview:</a></li>
+<li><a class="reference internal" href="#id49" id="id1001">Arguments:</a></li>
+<li><a class="reference internal" href="#id50" id="id1002">Semantics:</a></li>
+<li><a class="reference internal" href="#id51" id="id1003">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#catchret-instruction" id="id1004">‘<tt class="docutils literal"><span class="pre">catchret</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id52" id="id1005">Syntax:</a></li>
+<li><a class="reference internal" href="#id53" id="id1006">Overview:</a></li>
+<li><a class="reference internal" href="#id54" id="id1007">Arguments:</a></li>
+<li><a class="reference internal" href="#id55" id="id1008">Semantics:</a></li>
+<li><a class="reference internal" href="#id56" id="id1009">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#cleanupret-instruction" id="id1010">‘<tt class="docutils literal"><span class="pre">cleanupret</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id57" id="id1011">Syntax:</a></li>
+<li><a class="reference internal" href="#id58" id="id1012">Overview:</a></li>
+<li><a class="reference internal" href="#id59" id="id1013">Arguments:</a></li>
+<li><a class="reference internal" href="#id62" id="id1014">Semantics:</a></li>
+<li><a class="reference internal" href="#id63" id="id1015">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#unreachable-instruction" id="id1016">‘<tt class="docutils literal"><span class="pre">unreachable</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id64" id="id1017">Syntax:</a></li>
+<li><a class="reference internal" href="#id65" id="id1018">Overview:</a></li>
+<li><a class="reference internal" href="#id66" id="id1019">Semantics:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#binary-operations" id="id1020">Binary Operations</a><ul>
+<li><a class="reference internal" href="#add-instruction" id="id1021">‘<tt class="docutils literal"><span class="pre">add</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id67" id="id1022">Syntax:</a></li>
+<li><a class="reference internal" href="#id68" id="id1023">Overview:</a></li>
+<li><a class="reference internal" href="#id69" id="id1024">Arguments:</a></li>
+<li><a class="reference internal" href="#id70" id="id1025">Semantics:</a></li>
+<li><a class="reference internal" href="#id71" id="id1026">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#fadd-instruction" id="id1027">‘<tt class="docutils literal"><span class="pre">fadd</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id72" id="id1028">Syntax:</a></li>
+<li><a class="reference internal" href="#id73" id="id1029">Overview:</a></li>
+<li><a class="reference internal" href="#id74" id="id1030">Arguments:</a></li>
+<li><a class="reference internal" href="#id75" id="id1031">Semantics:</a></li>
+<li><a class="reference internal" href="#id76" id="id1032">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#sub-instruction" id="id1033">‘<tt class="docutils literal"><span class="pre">sub</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id77" id="id1034">Syntax:</a></li>
+<li><a class="reference internal" href="#id78" id="id1035">Overview:</a></li>
+<li><a class="reference internal" href="#id79" id="id1036">Arguments:</a></li>
+<li><a class="reference internal" href="#id80" id="id1037">Semantics:</a></li>
+<li><a class="reference internal" href="#id81" id="id1038">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#fsub-instruction" id="id1039">‘<tt class="docutils literal"><span class="pre">fsub</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id82" id="id1040">Syntax:</a></li>
+<li><a class="reference internal" href="#id83" id="id1041">Overview:</a></li>
+<li><a class="reference internal" href="#id84" id="id1042">Arguments:</a></li>
+<li><a class="reference internal" href="#id85" id="id1043">Semantics:</a></li>
+<li><a class="reference internal" href="#id86" id="id1044">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#mul-instruction" id="id1045">‘<tt class="docutils literal"><span class="pre">mul</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id87" id="id1046">Syntax:</a></li>
+<li><a class="reference internal" href="#id88" id="id1047">Overview:</a></li>
+<li><a class="reference internal" href="#id89" id="id1048">Arguments:</a></li>
+<li><a class="reference internal" href="#id90" id="id1049">Semantics:</a></li>
+<li><a class="reference internal" href="#id91" id="id1050">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#fmul-instruction" id="id1051">‘<tt class="docutils literal"><span class="pre">fmul</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id92" id="id1052">Syntax:</a></li>
+<li><a class="reference internal" href="#id93" id="id1053">Overview:</a></li>
+<li><a class="reference internal" href="#id94" id="id1054">Arguments:</a></li>
+<li><a class="reference internal" href="#id95" id="id1055">Semantics:</a></li>
+<li><a class="reference internal" href="#id96" id="id1056">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#udiv-instruction" id="id1057">‘<tt class="docutils literal"><span class="pre">udiv</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id97" id="id1058">Syntax:</a></li>
+<li><a class="reference internal" href="#id98" id="id1059">Overview:</a></li>
+<li><a class="reference internal" href="#id99" id="id1060">Arguments:</a></li>
+<li><a class="reference internal" href="#id100" id="id1061">Semantics:</a></li>
+<li><a class="reference internal" href="#id101" id="id1062">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#sdiv-instruction" id="id1063">‘<tt class="docutils literal"><span class="pre">sdiv</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id102" id="id1064">Syntax:</a></li>
+<li><a class="reference internal" href="#id103" id="id1065">Overview:</a></li>
+<li><a class="reference internal" href="#id104" id="id1066">Arguments:</a></li>
+<li><a class="reference internal" href="#id105" id="id1067">Semantics:</a></li>
+<li><a class="reference internal" href="#id106" id="id1068">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#fdiv-instruction" id="id1069">‘<tt class="docutils literal"><span class="pre">fdiv</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id107" id="id1070">Syntax:</a></li>
+<li><a class="reference internal" href="#id108" id="id1071">Overview:</a></li>
+<li><a class="reference internal" href="#id109" id="id1072">Arguments:</a></li>
+<li><a class="reference internal" href="#id110" id="id1073">Semantics:</a></li>
+<li><a class="reference internal" href="#id111" id="id1074">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#urem-instruction" id="id1075">‘<tt class="docutils literal"><span class="pre">urem</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id112" id="id1076">Syntax:</a></li>
+<li><a class="reference internal" href="#id113" id="id1077">Overview:</a></li>
+<li><a class="reference internal" href="#id114" id="id1078">Arguments:</a></li>
+<li><a class="reference internal" href="#id115" id="id1079">Semantics:</a></li>
+<li><a class="reference internal" href="#id116" id="id1080">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#srem-instruction" id="id1081">‘<tt class="docutils literal"><span class="pre">srem</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id117" id="id1082">Syntax:</a></li>
+<li><a class="reference internal" href="#id118" id="id1083">Overview:</a></li>
+<li><a class="reference internal" href="#id119" id="id1084">Arguments:</a></li>
+<li><a class="reference internal" href="#id120" id="id1085">Semantics:</a></li>
+<li><a class="reference internal" href="#id121" id="id1086">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#frem-instruction" id="id1087">‘<tt class="docutils literal"><span class="pre">frem</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id122" id="id1088">Syntax:</a></li>
+<li><a class="reference internal" href="#id123" id="id1089">Overview:</a></li>
+<li><a class="reference internal" href="#id124" id="id1090">Arguments:</a></li>
+<li><a class="reference internal" href="#id125" id="id1091">Semantics:</a></li>
+<li><a class="reference internal" href="#id126" id="id1092">Example:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#bitwise-binary-operations" id="id1093">Bitwise Binary Operations</a><ul>
+<li><a class="reference internal" href="#shl-instruction" id="id1094">‘<tt class="docutils literal"><span class="pre">shl</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id127" id="id1095">Syntax:</a></li>
+<li><a class="reference internal" href="#id128" id="id1096">Overview:</a></li>
+<li><a class="reference internal" href="#id129" id="id1097">Arguments:</a></li>
+<li><a class="reference internal" href="#id130" id="id1098">Semantics:</a></li>
+<li><a class="reference internal" href="#id131" id="id1099">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#lshr-instruction" id="id1100">‘<tt class="docutils literal"><span class="pre">lshr</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id132" id="id1101">Syntax:</a></li>
+<li><a class="reference internal" href="#id133" id="id1102">Overview:</a></li>
+<li><a class="reference internal" href="#id134" id="id1103">Arguments:</a></li>
+<li><a class="reference internal" href="#id135" id="id1104">Semantics:</a></li>
+<li><a class="reference internal" href="#id136" id="id1105">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#ashr-instruction" id="id1106">‘<tt class="docutils literal"><span class="pre">ashr</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id137" id="id1107">Syntax:</a></li>
+<li><a class="reference internal" href="#id138" id="id1108">Overview:</a></li>
+<li><a class="reference internal" href="#id139" id="id1109">Arguments:</a></li>
+<li><a class="reference internal" href="#id140" id="id1110">Semantics:</a></li>
+<li><a class="reference internal" href="#id141" id="id1111">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#and-instruction" id="id1112">‘<tt class="docutils literal"><span class="pre">and</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id142" id="id1113">Syntax:</a></li>
+<li><a class="reference internal" href="#id143" id="id1114">Overview:</a></li>
+<li><a class="reference internal" href="#id144" id="id1115">Arguments:</a></li>
+<li><a class="reference internal" href="#id145" id="id1116">Semantics:</a></li>
+<li><a class="reference internal" href="#id146" id="id1117">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#or-instruction" id="id1118">‘<tt class="docutils literal"><span class="pre">or</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id147" id="id1119">Syntax:</a></li>
+<li><a class="reference internal" href="#id148" id="id1120">Overview:</a></li>
+<li><a class="reference internal" href="#id149" id="id1121">Arguments:</a></li>
+<li><a class="reference internal" href="#id150" id="id1122">Semantics:</a></li>
+<li><a class="reference internal" href="#id151" id="id1123">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#xor-instruction" id="id1124">‘<tt class="docutils literal"><span class="pre">xor</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id152" id="id1125">Syntax:</a></li>
+<li><a class="reference internal" href="#id153" id="id1126">Overview:</a></li>
+<li><a class="reference internal" href="#id154" id="id1127">Arguments:</a></li>
+<li><a class="reference internal" href="#id155" id="id1128">Semantics:</a></li>
+<li><a class="reference internal" href="#id156" id="id1129">Example:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#vector-operations" id="id1130">Vector Operations</a><ul>
+<li><a class="reference internal" href="#extractelement-instruction" id="id1131">‘<tt class="docutils literal"><span class="pre">extractelement</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id157" id="id1132">Syntax:</a></li>
+<li><a class="reference internal" href="#id158" id="id1133">Overview:</a></li>
+<li><a class="reference internal" href="#id159" id="id1134">Arguments:</a></li>
+<li><a class="reference internal" href="#id160" id="id1135">Semantics:</a></li>
+<li><a class="reference internal" href="#id161" id="id1136">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#insertelement-instruction" id="id1137">‘<tt class="docutils literal"><span class="pre">insertelement</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id162" id="id1138">Syntax:</a></li>
+<li><a class="reference internal" href="#id163" id="id1139">Overview:</a></li>
+<li><a class="reference internal" href="#id164" id="id1140">Arguments:</a></li>
+<li><a class="reference internal" href="#id165" id="id1141">Semantics:</a></li>
+<li><a class="reference internal" href="#id166" id="id1142">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#shufflevector-instruction" id="id1143">‘<tt class="docutils literal"><span class="pre">shufflevector</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id167" id="id1144">Syntax:</a></li>
+<li><a class="reference internal" href="#id168" id="id1145">Overview:</a></li>
+<li><a class="reference internal" href="#id169" id="id1146">Arguments:</a></li>
+<li><a class="reference internal" href="#id170" id="id1147">Semantics:</a></li>
+<li><a class="reference internal" href="#id171" id="id1148">Example:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#aggregate-operations" id="id1149">Aggregate Operations</a><ul>
+<li><a class="reference internal" href="#extractvalue-instruction" id="id1150">‘<tt class="docutils literal"><span class="pre">extractvalue</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id172" id="id1151">Syntax:</a></li>
+<li><a class="reference internal" href="#id173" id="id1152">Overview:</a></li>
+<li><a class="reference internal" href="#id174" id="id1153">Arguments:</a></li>
+<li><a class="reference internal" href="#id175" id="id1154">Semantics:</a></li>
+<li><a class="reference internal" href="#id176" id="id1155">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#insertvalue-instruction" id="id1156">‘<tt class="docutils literal"><span class="pre">insertvalue</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id177" id="id1157">Syntax:</a></li>
+<li><a class="reference internal" href="#id178" id="id1158">Overview:</a></li>
+<li><a class="reference internal" href="#id179" id="id1159">Arguments:</a></li>
+<li><a class="reference internal" href="#id180" id="id1160">Semantics:</a></li>
+<li><a class="reference internal" href="#id181" id="id1161">Example:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#memory-access-and-addressing-operations" id="id1162">Memory Access and Addressing Operations</a><ul>
+<li><a class="reference internal" href="#alloca-instruction" id="id1163">‘<tt class="docutils literal"><span class="pre">alloca</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id182" id="id1164">Syntax:</a></li>
+<li><a class="reference internal" href="#id183" id="id1165">Overview:</a></li>
+<li><a class="reference internal" href="#id184" id="id1166">Arguments:</a></li>
+<li><a class="reference internal" href="#id185" id="id1167">Semantics:</a></li>
+<li><a class="reference internal" href="#id186" id="id1168">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#load-instruction" id="id1169">‘<tt class="docutils literal"><span class="pre">load</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id187" id="id1170">Syntax:</a></li>
+<li><a class="reference internal" href="#id188" id="id1171">Overview:</a></li>
+<li><a class="reference internal" href="#id189" id="id1172">Arguments:</a></li>
+<li><a class="reference internal" href="#id190" id="id1173">Semantics:</a></li>
+<li><a class="reference internal" href="#id191" id="id1174">Examples:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#store-instruction" id="id1175">‘<tt class="docutils literal"><span class="pre">store</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id192" id="id1176">Syntax:</a></li>
+<li><a class="reference internal" href="#id193" id="id1177">Overview:</a></li>
+<li><a class="reference internal" href="#id194" id="id1178">Arguments:</a></li>
+<li><a class="reference internal" href="#id195" id="id1179">Semantics:</a></li>
+<li><a class="reference internal" href="#id196" id="id1180">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#fence-instruction" id="id1181">‘<tt class="docutils literal"><span class="pre">fence</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id197" id="id1182">Syntax:</a></li>
+<li><a class="reference internal" href="#id198" id="id1183">Overview:</a></li>
+<li><a class="reference internal" href="#id199" id="id1184">Arguments:</a></li>
+<li><a class="reference internal" href="#id200" id="id1185">Semantics:</a></li>
+<li><a class="reference internal" href="#id201" id="id1186">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#cmpxchg-instruction" id="id1187">‘<tt class="docutils literal"><span class="pre">cmpxchg</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id202" id="id1188">Syntax:</a></li>
+<li><a class="reference internal" href="#id203" id="id1189">Overview:</a></li>
+<li><a class="reference internal" href="#id204" id="id1190">Arguments:</a></li>
+<li><a class="reference internal" href="#id205" id="id1191">Semantics:</a></li>
+<li><a class="reference internal" href="#id206" id="id1192">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#atomicrmw-instruction" id="id1193">‘<tt class="docutils literal"><span class="pre">atomicrmw</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id207" id="id1194">Syntax:</a></li>
+<li><a class="reference internal" href="#id208" id="id1195">Overview:</a></li>
+<li><a class="reference internal" href="#id209" id="id1196">Arguments:</a></li>
+<li><a class="reference internal" href="#id210" id="id1197">Semantics:</a></li>
+<li><a class="reference internal" href="#id211" id="id1198">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#getelementptr-instruction" id="id1199">‘<tt class="docutils literal"><span class="pre">getelementptr</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id212" id="id1200">Syntax:</a></li>
+<li><a class="reference internal" href="#id213" id="id1201">Overview:</a></li>
+<li><a class="reference internal" href="#id214" id="id1202">Arguments:</a></li>
+<li><a class="reference internal" href="#id215" id="id1203">Semantics:</a></li>
+<li><a class="reference internal" href="#id216" id="id1204">Example:</a></li>
+<li><a class="reference internal" href="#vector-of-pointers" id="id1205">Vector of pointers:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#conversion-operations" id="id1206">Conversion Operations</a><ul>
+<li><a class="reference internal" href="#trunc-to-instruction" id="id1207">‘<tt class="docutils literal"><span class="pre">trunc</span> <span class="pre">..</span> <span class="pre">to</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id217" id="id1208">Syntax:</a></li>
+<li><a class="reference internal" href="#id218" id="id1209">Overview:</a></li>
+<li><a class="reference internal" href="#id219" id="id1210">Arguments:</a></li>
+<li><a class="reference internal" href="#id220" id="id1211">Semantics:</a></li>
+<li><a class="reference internal" href="#id221" id="id1212">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#zext-to-instruction" id="id1213">‘<tt class="docutils literal"><span class="pre">zext</span> <span class="pre">..</span> <span class="pre">to</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id222" id="id1214">Syntax:</a></li>
+<li><a class="reference internal" href="#id223" id="id1215">Overview:</a></li>
+<li><a class="reference internal" href="#id224" id="id1216">Arguments:</a></li>
+<li><a class="reference internal" href="#id225" id="id1217">Semantics:</a></li>
+<li><a class="reference internal" href="#id226" id="id1218">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#sext-to-instruction" id="id1219">‘<tt class="docutils literal"><span class="pre">sext</span> <span class="pre">..</span> <span class="pre">to</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id227" id="id1220">Syntax:</a></li>
+<li><a class="reference internal" href="#id228" id="id1221">Overview:</a></li>
+<li><a class="reference internal" href="#id229" id="id1222">Arguments:</a></li>
+<li><a class="reference internal" href="#id230" id="id1223">Semantics:</a></li>
+<li><a class="reference internal" href="#id231" id="id1224">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#fptrunc-to-instruction" id="id1225">‘<tt class="docutils literal"><span class="pre">fptrunc</span> <span class="pre">..</span> <span class="pre">to</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id232" id="id1226">Syntax:</a></li>
+<li><a class="reference internal" href="#id233" id="id1227">Overview:</a></li>
+<li><a class="reference internal" href="#id234" id="id1228">Arguments:</a></li>
+<li><a class="reference internal" href="#id235" id="id1229">Semantics:</a></li>
+<li><a class="reference internal" href="#id236" id="id1230">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#fpext-to-instruction" id="id1231">‘<tt class="docutils literal"><span class="pre">fpext</span> <span class="pre">..</span> <span class="pre">to</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id237" id="id1232">Syntax:</a></li>
+<li><a class="reference internal" href="#id238" id="id1233">Overview:</a></li>
+<li><a class="reference internal" href="#id239" id="id1234">Arguments:</a></li>
+<li><a class="reference internal" href="#id240" id="id1235">Semantics:</a></li>
+<li><a class="reference internal" href="#id241" id="id1236">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#fptoui-to-instruction" id="id1237">‘<tt class="docutils literal"><span class="pre">fptoui</span> <span class="pre">..</span> <span class="pre">to</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id242" id="id1238">Syntax:</a></li>
+<li><a class="reference internal" href="#id243" id="id1239">Overview:</a></li>
+<li><a class="reference internal" href="#id244" id="id1240">Arguments:</a></li>
+<li><a class="reference internal" href="#id245" id="id1241">Semantics:</a></li>
+<li><a class="reference internal" href="#id246" id="id1242">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#fptosi-to-instruction" id="id1243">‘<tt class="docutils literal"><span class="pre">fptosi</span> <span class="pre">..</span> <span class="pre">to</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id247" id="id1244">Syntax:</a></li>
+<li><a class="reference internal" href="#id248" id="id1245">Overview:</a></li>
+<li><a class="reference internal" href="#id249" id="id1246">Arguments:</a></li>
+<li><a class="reference internal" href="#id250" id="id1247">Semantics:</a></li>
+<li><a class="reference internal" href="#id251" id="id1248">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#uitofp-to-instruction" id="id1249">‘<tt class="docutils literal"><span class="pre">uitofp</span> <span class="pre">..</span> <span class="pre">to</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id252" id="id1250">Syntax:</a></li>
+<li><a class="reference internal" href="#id253" id="id1251">Overview:</a></li>
+<li><a class="reference internal" href="#id254" id="id1252">Arguments:</a></li>
+<li><a class="reference internal" href="#id255" id="id1253">Semantics:</a></li>
+<li><a class="reference internal" href="#id256" id="id1254">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#sitofp-to-instruction" id="id1255">‘<tt class="docutils literal"><span class="pre">sitofp</span> <span class="pre">..</span> <span class="pre">to</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id257" id="id1256">Syntax:</a></li>
+<li><a class="reference internal" href="#id258" id="id1257">Overview:</a></li>
+<li><a class="reference internal" href="#id259" id="id1258">Arguments:</a></li>
+<li><a class="reference internal" href="#id260" id="id1259">Semantics:</a></li>
+<li><a class="reference internal" href="#id261" id="id1260">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#ptrtoint-to-instruction" id="id1261">‘<tt class="docutils literal"><span class="pre">ptrtoint</span> <span class="pre">..</span> <span class="pre">to</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id262" id="id1262">Syntax:</a></li>
+<li><a class="reference internal" href="#id263" id="id1263">Overview:</a></li>
+<li><a class="reference internal" href="#id264" id="id1264">Arguments:</a></li>
+<li><a class="reference internal" href="#id265" id="id1265">Semantics:</a></li>
+<li><a class="reference internal" href="#id266" id="id1266">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#inttoptr-to-instruction" id="id1267">‘<tt class="docutils literal"><span class="pre">inttoptr</span> <span class="pre">..</span> <span class="pre">to</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id267" id="id1268">Syntax:</a></li>
+<li><a class="reference internal" href="#id268" id="id1269">Overview:</a></li>
+<li><a class="reference internal" href="#id269" id="id1270">Arguments:</a></li>
+<li><a class="reference internal" href="#id270" id="id1271">Semantics:</a></li>
+<li><a class="reference internal" href="#id271" id="id1272">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#bitcast-to-instruction" id="id1273">‘<tt class="docutils literal"><span class="pre">bitcast</span> <span class="pre">..</span> <span class="pre">to</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id272" id="id1274">Syntax:</a></li>
+<li><a class="reference internal" href="#id273" id="id1275">Overview:</a></li>
+<li><a class="reference internal" href="#id274" id="id1276">Arguments:</a></li>
+<li><a class="reference internal" href="#id275" id="id1277">Semantics:</a></li>
+<li><a class="reference internal" href="#id276" id="id1278">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#addrspacecast-to-instruction" id="id1279">‘<tt class="docutils literal"><span class="pre">addrspacecast</span> <span class="pre">..</span> <span class="pre">to</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id277" id="id1280">Syntax:</a></li>
+<li><a class="reference internal" href="#id278" id="id1281">Overview:</a></li>
+<li><a class="reference internal" href="#id279" id="id1282">Arguments:</a></li>
+<li><a class="reference internal" href="#id280" id="id1283">Semantics:</a></li>
+<li><a class="reference internal" href="#id281" id="id1284">Example:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#other-operations" id="id1285">Other Operations</a><ul>
+<li><a class="reference internal" href="#icmp-instruction" id="id1286">‘<tt class="docutils literal"><span class="pre">icmp</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id282" id="id1287">Syntax:</a></li>
+<li><a class="reference internal" href="#id283" id="id1288">Overview:</a></li>
+<li><a class="reference internal" href="#id284" id="id1289">Arguments:</a></li>
+<li><a class="reference internal" href="#id285" id="id1290">Semantics:</a></li>
+<li><a class="reference internal" href="#id286" id="id1291">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#fcmp-instruction" id="id1292">‘<tt class="docutils literal"><span class="pre">fcmp</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id287" id="id1293">Syntax:</a></li>
+<li><a class="reference internal" href="#id288" id="id1294">Overview:</a></li>
+<li><a class="reference internal" href="#id289" id="id1295">Arguments:</a></li>
+<li><a class="reference internal" href="#id290" id="id1296">Semantics:</a></li>
+<li><a class="reference internal" href="#id291" id="id1297">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#phi-instruction" id="id1298">‘<tt class="docutils literal"><span class="pre">phi</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id292" id="id1299">Syntax:</a></li>
+<li><a class="reference internal" href="#id293" id="id1300">Overview:</a></li>
+<li><a class="reference internal" href="#id294" id="id1301">Arguments:</a></li>
+<li><a class="reference internal" href="#id295" id="id1302">Semantics:</a></li>
+<li><a class="reference internal" href="#id296" id="id1303">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#select-instruction" id="id1304">‘<tt class="docutils literal"><span class="pre">select</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id297" id="id1305">Syntax:</a></li>
+<li><a class="reference internal" href="#id298" id="id1306">Overview:</a></li>
+<li><a class="reference internal" href="#id299" id="id1307">Arguments:</a></li>
+<li><a class="reference internal" href="#id300" id="id1308">Semantics:</a></li>
+<li><a class="reference internal" href="#id301" id="id1309">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#call-instruction" id="id1310">‘<tt class="docutils literal"><span class="pre">call</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id302" id="id1311">Syntax:</a></li>
+<li><a class="reference internal" href="#id303" id="id1312">Overview:</a></li>
+<li><a class="reference internal" href="#id304" id="id1313">Arguments:</a></li>
+<li><a class="reference internal" href="#id305" id="id1314">Semantics:</a></li>
+<li><a class="reference internal" href="#id306" id="id1315">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#va-arg-instruction" id="id1316">‘<tt class="docutils literal"><span class="pre">va_arg</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id307" id="id1317">Syntax:</a></li>
+<li><a class="reference internal" href="#id308" id="id1318">Overview:</a></li>
+<li><a class="reference internal" href="#id309" id="id1319">Arguments:</a></li>
+<li><a class="reference internal" href="#id310" id="id1320">Semantics:</a></li>
+<li><a class="reference internal" href="#id311" id="id1321">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#landingpad-instruction" id="id1322">‘<tt class="docutils literal"><span class="pre">landingpad</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id312" id="id1323">Syntax:</a></li>
+<li><a class="reference internal" href="#id313" id="id1324">Overview:</a></li>
+<li><a class="reference internal" href="#id315" id="id1325">Arguments:</a></li>
+<li><a class="reference internal" href="#id316" id="id1326">Semantics:</a></li>
+<li><a class="reference internal" href="#id317" id="id1327">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#catchpad-instruction" id="id1328">‘<tt class="docutils literal"><span class="pre">catchpad</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id318" id="id1329">Syntax:</a></li>
+<li><a class="reference internal" href="#id319" id="id1330">Overview:</a></li>
+<li><a class="reference internal" href="#id321" id="id1331">Arguments:</a></li>
+<li><a class="reference internal" href="#id322" id="id1332">Semantics:</a></li>
+<li><a class="reference internal" href="#id324" id="id1333">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#cleanuppad-instruction" id="id1334">‘<tt class="docutils literal"><span class="pre">cleanuppad</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id325" id="id1335">Syntax:</a></li>
+<li><a class="reference internal" href="#id326" id="id1336">Overview:</a></li>
+<li><a class="reference internal" href="#id328" id="id1337">Arguments:</a></li>
+<li><a class="reference internal" href="#id329" id="id1338">Semantics:</a></li>
+<li><a class="reference internal" href="#id331" id="id1339">Example:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#intrinsic-functions" id="id1340">Intrinsic Functions</a><ul>
+<li><a class="reference internal" href="#variable-argument-handling-intrinsics" id="id1341">Variable Argument Handling Intrinsics</a><ul>
+<li><a class="reference internal" href="#llvm-va-start-intrinsic" id="id1342">‘<tt class="docutils literal"><span class="pre">llvm.va_start</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id332" id="id1343">Syntax:</a></li>
+<li><a class="reference internal" href="#id333" id="id1344">Overview:</a></li>
+<li><a class="reference internal" href="#id334" id="id1345">Arguments:</a></li>
+<li><a class="reference internal" href="#id335" id="id1346">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-va-end-intrinsic" id="id1347">‘<tt class="docutils literal"><span class="pre">llvm.va_end</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id336" id="id1348">Syntax:</a></li>
+<li><a class="reference internal" href="#id337" id="id1349">Overview:</a></li>
+<li><a class="reference internal" href="#id338" id="id1350">Arguments:</a></li>
+<li><a class="reference internal" href="#id339" id="id1351">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-va-copy-intrinsic" id="id1352">‘<tt class="docutils literal"><span class="pre">llvm.va_copy</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id340" id="id1353">Syntax:</a></li>
+<li><a class="reference internal" href="#id341" id="id1354">Overview:</a></li>
+<li><a class="reference internal" href="#id342" id="id1355">Arguments:</a></li>
+<li><a class="reference internal" href="#id343" id="id1356">Semantics:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#accurate-garbage-collection-intrinsics" id="id1357">Accurate Garbage Collection Intrinsics</a><ul>
+<li><a class="reference internal" href="#experimental-statepoint-intrinsics" id="id1358">Experimental Statepoint Intrinsics</a></li>
+<li><a class="reference internal" href="#llvm-gcroot-intrinsic" id="id1359">‘<tt class="docutils literal"><span class="pre">llvm.gcroot</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id345" id="id1360">Syntax:</a></li>
+<li><a class="reference internal" href="#id346" id="id1361">Overview:</a></li>
+<li><a class="reference internal" href="#id347" id="id1362">Arguments:</a></li>
+<li><a class="reference internal" href="#id348" id="id1363">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-gcread-intrinsic" id="id1364">‘<tt class="docutils literal"><span class="pre">llvm.gcread</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id349" id="id1365">Syntax:</a></li>
+<li><a class="reference internal" href="#id350" id="id1366">Overview:</a></li>
+<li><a class="reference internal" href="#id351" id="id1367">Arguments:</a></li>
+<li><a class="reference internal" href="#id352" id="id1368">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-gcwrite-intrinsic" id="id1369">‘<tt class="docutils literal"><span class="pre">llvm.gcwrite</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id353" id="id1370">Syntax:</a></li>
+<li><a class="reference internal" href="#id354" id="id1371">Overview:</a></li>
+<li><a class="reference internal" href="#id355" id="id1372">Arguments:</a></li>
+<li><a class="reference internal" href="#id356" id="id1373">Semantics:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#code-generator-intrinsics" id="id1374">Code Generator Intrinsics</a><ul>
+<li><a class="reference internal" href="#llvm-returnaddress-intrinsic" id="id1375">‘<tt class="docutils literal"><span class="pre">llvm.returnaddress</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id357" id="id1376">Syntax:</a></li>
+<li><a class="reference internal" href="#id358" id="id1377">Overview:</a></li>
+<li><a class="reference internal" href="#id359" id="id1378">Arguments:</a></li>
+<li><a class="reference internal" href="#id360" id="id1379">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-addressofreturnaddress-intrinsic" id="id1380">‘<tt class="docutils literal"><span class="pre">llvm.addressofreturnaddress</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id361" id="id1381">Syntax:</a></li>
+<li><a class="reference internal" href="#id362" id="id1382">Overview:</a></li>
+<li><a class="reference internal" href="#id363" id="id1383">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-frameaddress-intrinsic" id="id1384">‘<tt class="docutils literal"><span class="pre">llvm.frameaddress</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id364" id="id1385">Syntax:</a></li>
+<li><a class="reference internal" href="#id365" id="id1386">Overview:</a></li>
+<li><a class="reference internal" href="#id366" id="id1387">Arguments:</a></li>
+<li><a class="reference internal" href="#id367" id="id1388">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-localescape-and-llvm-localrecover-intrinsics" id="id1389">‘<tt class="docutils literal"><span class="pre">llvm.localescape</span></tt>‘ and ‘<tt class="docutils literal"><span class="pre">llvm.localrecover</span></tt>‘ Intrinsics</a><ul>
+<li><a class="reference internal" href="#id368" id="id1390">Syntax:</a></li>
+<li><a class="reference internal" href="#id369" id="id1391">Overview:</a></li>
+<li><a class="reference internal" href="#id370" id="id1392">Arguments:</a></li>
+<li><a class="reference internal" href="#id371" id="id1393">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-read-register-and-llvm-write-register-intrinsics" id="id1394">‘<tt class="docutils literal"><span class="pre">llvm.read_register</span></tt>‘ and ‘<tt class="docutils literal"><span class="pre">llvm.write_register</span></tt>‘ Intrinsics</a><ul>
+<li><a class="reference internal" href="#id372" id="id1395">Syntax:</a></li>
+<li><a class="reference internal" href="#id373" id="id1396">Overview:</a></li>
+<li><a class="reference internal" href="#id374" id="id1397">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-stacksave-intrinsic" id="id1398">‘<tt class="docutils literal"><span class="pre">llvm.stacksave</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id375" id="id1399">Syntax:</a></li>
+<li><a class="reference internal" href="#id376" id="id1400">Overview:</a></li>
+<li><a class="reference internal" href="#id377" id="id1401">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-stackrestore-intrinsic" id="id1402">‘<tt class="docutils literal"><span class="pre">llvm.stackrestore</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id378" id="id1403">Syntax:</a></li>
+<li><a class="reference internal" href="#id379" id="id1404">Overview:</a></li>
+<li><a class="reference internal" href="#id380" id="id1405">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-get-dynamic-area-offset-intrinsic" id="id1406">‘<tt class="docutils literal"><span class="pre">llvm.get.dynamic.area.offset</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id381" id="id1407">Syntax:</a></li>
+<li><a class="reference internal" href="#id382" id="id1408">Overview:</a></li>
+<li><a class="reference internal" href="#id383" id="id1409">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-prefetch-intrinsic" id="id1410">‘<tt class="docutils literal"><span class="pre">llvm.prefetch</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id384" id="id1411">Syntax:</a></li>
+<li><a class="reference internal" href="#id385" id="id1412">Overview:</a></li>
+<li><a class="reference internal" href="#id386" id="id1413">Arguments:</a></li>
+<li><a class="reference internal" href="#id387" id="id1414">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-pcmarker-intrinsic" id="id1415">‘<tt class="docutils literal"><span class="pre">llvm.pcmarker</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id388" id="id1416">Syntax:</a></li>
+<li><a class="reference internal" href="#id389" id="id1417">Overview:</a></li>
+<li><a class="reference internal" href="#id390" id="id1418">Arguments:</a></li>
+<li><a class="reference internal" href="#id391" id="id1419">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-readcyclecounter-intrinsic" id="id1420">‘<tt class="docutils literal"><span class="pre">llvm.readcyclecounter</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id392" id="id1421">Syntax:</a></li>
+<li><a class="reference internal" href="#id393" id="id1422">Overview:</a></li>
+<li><a class="reference internal" href="#id394" id="id1423">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-clear-cache-intrinsic" id="id1424">‘<tt class="docutils literal"><span class="pre">llvm.clear_cache</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id395" id="id1425">Syntax:</a></li>
+<li><a class="reference internal" href="#id396" id="id1426">Overview:</a></li>
+<li><a class="reference internal" href="#id397" id="id1427">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-instrprof-increment-intrinsic" id="id1428">‘<tt class="docutils literal"><span class="pre">llvm.instrprof_increment</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id398" id="id1429">Syntax:</a></li>
+<li><a class="reference internal" href="#id399" id="id1430">Overview:</a></li>
+<li><a class="reference internal" href="#id400" id="id1431">Arguments:</a></li>
+<li><a class="reference internal" href="#id401" id="id1432">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-instrprof-increment-step-intrinsic" id="id1433">‘<tt class="docutils literal"><span class="pre">llvm.instrprof_increment_step</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id402" id="id1434">Syntax:</a></li>
+<li><a class="reference internal" href="#id403" id="id1435">Overview:</a></li>
+<li><a class="reference internal" href="#id404" id="id1436">Arguments:</a></li>
+<li><a class="reference internal" href="#id405" id="id1437">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-instrprof-value-profile-intrinsic" id="id1438">‘<tt class="docutils literal"><span class="pre">llvm.instrprof_value_profile</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id406" id="id1439">Syntax:</a></li>
+<li><a class="reference internal" href="#id407" id="id1440">Overview:</a></li>
+<li><a class="reference internal" href="#id408" id="id1441">Arguments:</a></li>
+<li><a class="reference internal" href="#id409" id="id1442">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-thread-pointer-intrinsic" id="id1443">‘<tt class="docutils literal"><span class="pre">llvm.thread.pointer</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id410" id="id1444">Syntax:</a></li>
+<li><a class="reference internal" href="#id411" id="id1445">Overview:</a></li>
+<li><a class="reference internal" href="#id412" id="id1446">Semantics:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#standard-c-library-intrinsics" id="id1447">Standard C Library Intrinsics</a><ul>
+<li><a class="reference internal" href="#llvm-memcpy-intrinsic" id="id1448">‘<tt class="docutils literal"><span class="pre">llvm.memcpy</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id413" id="id1449">Syntax:</a></li>
+<li><a class="reference internal" href="#id414" id="id1450">Overview:</a></li>
+<li><a class="reference internal" href="#id415" id="id1451">Arguments:</a></li>
+<li><a class="reference internal" href="#id416" id="id1452">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-memmove-intrinsic" id="id1453">‘<tt class="docutils literal"><span class="pre">llvm.memmove</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id417" id="id1454">Syntax:</a></li>
+<li><a class="reference internal" href="#id418" id="id1455">Overview:</a></li>
+<li><a class="reference internal" href="#id419" id="id1456">Arguments:</a></li>
+<li><a class="reference internal" href="#id420" id="id1457">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-memset-intrinsics" id="id1458">‘<tt class="docutils literal"><span class="pre">llvm.memset.*</span></tt>‘ Intrinsics</a><ul>
+<li><a class="reference internal" href="#id421" id="id1459">Syntax:</a></li>
+<li><a class="reference internal" href="#id422" id="id1460">Overview:</a></li>
+<li><a class="reference internal" href="#id423" id="id1461">Arguments:</a></li>
+<li><a class="reference internal" href="#id424" id="id1462">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-sqrt-intrinsic" id="id1463">‘<tt class="docutils literal"><span class="pre">llvm.sqrt.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id425" id="id1464">Syntax:</a></li>
+<li><a class="reference internal" href="#id426" id="id1465">Overview:</a></li>
+<li><a class="reference internal" href="#id427" id="id1466">Arguments:</a></li>
+<li><a class="reference internal" href="#id428" id="id1467">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-powi-intrinsic" id="id1468">‘<tt class="docutils literal"><span class="pre">llvm.powi.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id429" id="id1469">Syntax:</a></li>
+<li><a class="reference internal" href="#id430" id="id1470">Overview:</a></li>
+<li><a class="reference internal" href="#id431" id="id1471">Arguments:</a></li>
+<li><a class="reference internal" href="#id432" id="id1472">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-sin-intrinsic" id="id1473">‘<tt class="docutils literal"><span class="pre">llvm.sin.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id433" id="id1474">Syntax:</a></li>
+<li><a class="reference internal" href="#id434" id="id1475">Overview:</a></li>
+<li><a class="reference internal" href="#id435" id="id1476">Arguments:</a></li>
+<li><a class="reference internal" href="#id436" id="id1477">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-cos-intrinsic" id="id1478">‘<tt class="docutils literal"><span class="pre">llvm.cos.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id437" id="id1479">Syntax:</a></li>
+<li><a class="reference internal" href="#id438" id="id1480">Overview:</a></li>
+<li><a class="reference internal" href="#id439" id="id1481">Arguments:</a></li>
+<li><a class="reference internal" href="#id440" id="id1482">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-pow-intrinsic" id="id1483">‘<tt class="docutils literal"><span class="pre">llvm.pow.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id441" id="id1484">Syntax:</a></li>
+<li><a class="reference internal" href="#id442" id="id1485">Overview:</a></li>
+<li><a class="reference internal" href="#id443" id="id1486">Arguments:</a></li>
+<li><a class="reference internal" href="#id444" id="id1487">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-exp-intrinsic" id="id1488">‘<tt class="docutils literal"><span class="pre">llvm.exp.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id445" id="id1489">Syntax:</a></li>
+<li><a class="reference internal" href="#id446" id="id1490">Overview:</a></li>
+<li><a class="reference internal" href="#id447" id="id1491">Arguments:</a></li>
+<li><a class="reference internal" href="#id448" id="id1492">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-exp2-intrinsic" id="id1493">‘<tt class="docutils literal"><span class="pre">llvm.exp2.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id449" id="id1494">Syntax:</a></li>
+<li><a class="reference internal" href="#id450" id="id1495">Overview:</a></li>
+<li><a class="reference internal" href="#id451" id="id1496">Arguments:</a></li>
+<li><a class="reference internal" href="#id452" id="id1497">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-log-intrinsic" id="id1498">‘<tt class="docutils literal"><span class="pre">llvm.log.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id453" id="id1499">Syntax:</a></li>
+<li><a class="reference internal" href="#id454" id="id1500">Overview:</a></li>
+<li><a class="reference internal" href="#id455" id="id1501">Arguments:</a></li>
+<li><a class="reference internal" href="#id456" id="id1502">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-log10-intrinsic" id="id1503">‘<tt class="docutils literal"><span class="pre">llvm.log10.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id457" id="id1504">Syntax:</a></li>
+<li><a class="reference internal" href="#id458" id="id1505">Overview:</a></li>
+<li><a class="reference internal" href="#id459" id="id1506">Arguments:</a></li>
+<li><a class="reference internal" href="#id460" id="id1507">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-log2-intrinsic" id="id1508">‘<tt class="docutils literal"><span class="pre">llvm.log2.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id461" id="id1509">Syntax:</a></li>
+<li><a class="reference internal" href="#id462" id="id1510">Overview:</a></li>
+<li><a class="reference internal" href="#id463" id="id1511">Arguments:</a></li>
+<li><a class="reference internal" href="#id464" id="id1512">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-fma-intrinsic" id="id1513">‘<tt class="docutils literal"><span class="pre">llvm.fma.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id465" id="id1514">Syntax:</a></li>
+<li><a class="reference internal" href="#id466" id="id1515">Overview:</a></li>
+<li><a class="reference internal" href="#id467" id="id1516">Arguments:</a></li>
+<li><a class="reference internal" href="#id468" id="id1517">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-fabs-intrinsic" id="id1518">‘<tt class="docutils literal"><span class="pre">llvm.fabs.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id469" id="id1519">Syntax:</a></li>
+<li><a class="reference internal" href="#id470" id="id1520">Overview:</a></li>
+<li><a class="reference internal" href="#id471" id="id1521">Arguments:</a></li>
+<li><a class="reference internal" href="#id472" id="id1522">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-minnum-intrinsic" id="id1523">‘<tt class="docutils literal"><span class="pre">llvm.minnum.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id473" id="id1524">Syntax:</a></li>
+<li><a class="reference internal" href="#id474" id="id1525">Overview:</a></li>
+<li><a class="reference internal" href="#id475" id="id1526">Arguments:</a></li>
+<li><a class="reference internal" href="#id476" id="id1527">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-maxnum-intrinsic" id="id1528">‘<tt class="docutils literal"><span class="pre">llvm.maxnum.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id477" id="id1529">Syntax:</a></li>
+<li><a class="reference internal" href="#id478" id="id1530">Overview:</a></li>
+<li><a class="reference internal" href="#id479" id="id1531">Arguments:</a></li>
+<li><a class="reference internal" href="#id480" id="id1532">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-copysign-intrinsic" id="id1533">‘<tt class="docutils literal"><span class="pre">llvm.copysign.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id481" id="id1534">Syntax:</a></li>
+<li><a class="reference internal" href="#id482" id="id1535">Overview:</a></li>
+<li><a class="reference internal" href="#id483" id="id1536">Arguments:</a></li>
+<li><a class="reference internal" href="#id484" id="id1537">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-floor-intrinsic" id="id1538">‘<tt class="docutils literal"><span class="pre">llvm.floor.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id485" id="id1539">Syntax:</a></li>
+<li><a class="reference internal" href="#id486" id="id1540">Overview:</a></li>
+<li><a class="reference internal" href="#id487" id="id1541">Arguments:</a></li>
+<li><a class="reference internal" href="#id488" id="id1542">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-ceil-intrinsic" id="id1543">‘<tt class="docutils literal"><span class="pre">llvm.ceil.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id489" id="id1544">Syntax:</a></li>
+<li><a class="reference internal" href="#id490" id="id1545">Overview:</a></li>
+<li><a class="reference internal" href="#id491" id="id1546">Arguments:</a></li>
+<li><a class="reference internal" href="#id492" id="id1547">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-trunc-intrinsic" id="id1548">‘<tt class="docutils literal"><span class="pre">llvm.trunc.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id493" id="id1549">Syntax:</a></li>
+<li><a class="reference internal" href="#id494" id="id1550">Overview:</a></li>
+<li><a class="reference internal" href="#id495" id="id1551">Arguments:</a></li>
+<li><a class="reference internal" href="#id496" id="id1552">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-rint-intrinsic" id="id1553">‘<tt class="docutils literal"><span class="pre">llvm.rint.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id497" id="id1554">Syntax:</a></li>
+<li><a class="reference internal" href="#id498" id="id1555">Overview:</a></li>
+<li><a class="reference internal" href="#id499" id="id1556">Arguments:</a></li>
+<li><a class="reference internal" href="#id500" id="id1557">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-nearbyint-intrinsic" id="id1558">‘<tt class="docutils literal"><span class="pre">llvm.nearbyint.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id501" id="id1559">Syntax:</a></li>
+<li><a class="reference internal" href="#id502" id="id1560">Overview:</a></li>
+<li><a class="reference internal" href="#id503" id="id1561">Arguments:</a></li>
+<li><a class="reference internal" href="#id504" id="id1562">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-round-intrinsic" id="id1563">‘<tt class="docutils literal"><span class="pre">llvm.round.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id505" id="id1564">Syntax:</a></li>
+<li><a class="reference internal" href="#id506" id="id1565">Overview:</a></li>
+<li><a class="reference internal" href="#id507" id="id1566">Arguments:</a></li>
+<li><a class="reference internal" href="#id508" id="id1567">Semantics:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#bit-manipulation-intrinsics" id="id1568">Bit Manipulation Intrinsics</a><ul>
+<li><a class="reference internal" href="#llvm-bitreverse-intrinsics" id="id1569">‘<tt class="docutils literal"><span class="pre">llvm.bitreverse.*</span></tt>‘ Intrinsics</a><ul>
+<li><a class="reference internal" href="#id509" id="id1570">Syntax:</a></li>
+<li><a class="reference internal" href="#id510" id="id1571">Overview:</a></li>
+<li><a class="reference internal" href="#id511" id="id1572">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-bswap-intrinsics" id="id1573">‘<tt class="docutils literal"><span class="pre">llvm.bswap.*</span></tt>‘ Intrinsics</a><ul>
+<li><a class="reference internal" href="#id512" id="id1574">Syntax:</a></li>
+<li><a class="reference internal" href="#id513" id="id1575">Overview:</a></li>
+<li><a class="reference internal" href="#id514" id="id1576">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-ctpop-intrinsic" id="id1577">‘<tt class="docutils literal"><span class="pre">llvm.ctpop.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id515" id="id1578">Syntax:</a></li>
+<li><a class="reference internal" href="#id516" id="id1579">Overview:</a></li>
+<li><a class="reference internal" href="#id517" id="id1580">Arguments:</a></li>
+<li><a class="reference internal" href="#id518" id="id1581">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-ctlz-intrinsic" id="id1582">‘<tt class="docutils literal"><span class="pre">llvm.ctlz.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id519" id="id1583">Syntax:</a></li>
+<li><a class="reference internal" href="#id520" id="id1584">Overview:</a></li>
+<li><a class="reference internal" href="#id521" id="id1585">Arguments:</a></li>
+<li><a class="reference internal" href="#id522" id="id1586">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-cttz-intrinsic" id="id1587">‘<tt class="docutils literal"><span class="pre">llvm.cttz.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id523" id="id1588">Syntax:</a></li>
+<li><a class="reference internal" href="#id524" id="id1589">Overview:</a></li>
+<li><a class="reference internal" href="#id525" id="id1590">Arguments:</a></li>
+<li><a class="reference internal" href="#id526" id="id1591">Semantics:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#arithmetic-with-overflow-intrinsics" id="id1592">Arithmetic with Overflow Intrinsics</a><ul>
+<li><a class="reference internal" href="#llvm-sadd-with-overflow-intrinsics" id="id1593">‘<tt class="docutils literal"><span class="pre">llvm.sadd.with.overflow.*</span></tt>‘ Intrinsics</a><ul>
+<li><a class="reference internal" href="#id527" id="id1594">Syntax:</a></li>
+<li><a class="reference internal" href="#id528" id="id1595">Overview:</a></li>
+<li><a class="reference internal" href="#id529" id="id1596">Arguments:</a></li>
+<li><a class="reference internal" href="#id530" id="id1597">Semantics:</a></li>
+<li><a class="reference internal" href="#id531" id="id1598">Examples:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-uadd-with-overflow-intrinsics" id="id1599">‘<tt class="docutils literal"><span class="pre">llvm.uadd.with.overflow.*</span></tt>‘ Intrinsics</a><ul>
+<li><a class="reference internal" href="#id532" id="id1600">Syntax:</a></li>
+<li><a class="reference internal" href="#id533" id="id1601">Overview:</a></li>
+<li><a class="reference internal" href="#id534" id="id1602">Arguments:</a></li>
+<li><a class="reference internal" href="#id535" id="id1603">Semantics:</a></li>
+<li><a class="reference internal" href="#id536" id="id1604">Examples:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-ssub-with-overflow-intrinsics" id="id1605">‘<tt class="docutils literal"><span class="pre">llvm.ssub.with.overflow.*</span></tt>‘ Intrinsics</a><ul>
+<li><a class="reference internal" href="#id537" id="id1606">Syntax:</a></li>
+<li><a class="reference internal" href="#id538" id="id1607">Overview:</a></li>
+<li><a class="reference internal" href="#id539" id="id1608">Arguments:</a></li>
+<li><a class="reference internal" href="#id540" id="id1609">Semantics:</a></li>
+<li><a class="reference internal" href="#id541" id="id1610">Examples:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-usub-with-overflow-intrinsics" id="id1611">‘<tt class="docutils literal"><span class="pre">llvm.usub.with.overflow.*</span></tt>‘ Intrinsics</a><ul>
+<li><a class="reference internal" href="#id542" id="id1612">Syntax:</a></li>
+<li><a class="reference internal" href="#id543" id="id1613">Overview:</a></li>
+<li><a class="reference internal" href="#id544" id="id1614">Arguments:</a></li>
+<li><a class="reference internal" href="#id545" id="id1615">Semantics:</a></li>
+<li><a class="reference internal" href="#id546" id="id1616">Examples:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-smul-with-overflow-intrinsics" id="id1617">‘<tt class="docutils literal"><span class="pre">llvm.smul.with.overflow.*</span></tt>‘ Intrinsics</a><ul>
+<li><a class="reference internal" href="#id547" id="id1618">Syntax:</a></li>
+<li><a class="reference internal" href="#id548" id="id1619">Overview:</a></li>
+<li><a class="reference internal" href="#id549" id="id1620">Arguments:</a></li>
+<li><a class="reference internal" href="#id550" id="id1621">Semantics:</a></li>
+<li><a class="reference internal" href="#id551" id="id1622">Examples:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-umul-with-overflow-intrinsics" id="id1623">‘<tt class="docutils literal"><span class="pre">llvm.umul.with.overflow.*</span></tt>‘ Intrinsics</a><ul>
+<li><a class="reference internal" href="#id552" id="id1624">Syntax:</a></li>
+<li><a class="reference internal" href="#id553" id="id1625">Overview:</a></li>
+<li><a class="reference internal" href="#id554" id="id1626">Arguments:</a></li>
+<li><a class="reference internal" href="#id555" id="id1627">Semantics:</a></li>
+<li><a class="reference internal" href="#id556" id="id1628">Examples:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#specialised-arithmetic-intrinsics" id="id1629">Specialised Arithmetic Intrinsics</a><ul>
+<li><a class="reference internal" href="#llvm-canonicalize-intrinsic" id="id1630">‘<tt class="docutils literal"><span class="pre">llvm.canonicalize.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id557" id="id1631">Syntax:</a></li>
+<li><a class="reference internal" href="#id558" id="id1632">Overview:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-fmuladd-intrinsic" id="id1633">‘<tt class="docutils literal"><span class="pre">llvm.fmuladd.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id559" id="id1634">Syntax:</a></li>
+<li><a class="reference internal" href="#id560" id="id1635">Overview:</a></li>
+<li><a class="reference internal" href="#id561" id="id1636">Arguments:</a></li>
+<li><a class="reference internal" href="#id562" id="id1637">Semantics:</a></li>
+<li><a class="reference internal" href="#id563" id="id1638">Examples:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#experimental-vector-reduction-intrinsics" id="id1639">Experimental Vector Reduction Intrinsics</a><ul>
+<li><a class="reference internal" href="#llvm-experimental-vector-reduce-add-intrinsic" id="id1640">‘<tt class="docutils literal"><span class="pre">llvm.experimental.vector.reduce.add.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id564" id="id1641">Syntax:</a></li>
+<li><a class="reference internal" href="#id565" id="id1642">Overview:</a></li>
+<li><a class="reference internal" href="#id566" id="id1643">Arguments:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-vector-reduce-fadd-intrinsic" id="id1644">‘<tt class="docutils literal"><span class="pre">llvm.experimental.vector.reduce.fadd.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id567" id="id1645">Syntax:</a></li>
+<li><a class="reference internal" href="#id568" id="id1646">Overview:</a></li>
+<li><a class="reference internal" href="#id569" id="id1647">Arguments:</a></li>
+<li><a class="reference internal" href="#id570" id="id1648">Examples:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-vector-reduce-mul-intrinsic" id="id1649">‘<tt class="docutils literal"><span class="pre">llvm.experimental.vector.reduce.mul.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id571" id="id1650">Syntax:</a></li>
+<li><a class="reference internal" href="#id572" id="id1651">Overview:</a></li>
+<li><a class="reference internal" href="#id573" id="id1652">Arguments:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-vector-reduce-fmul-intrinsic" id="id1653">‘<tt class="docutils literal"><span class="pre">llvm.experimental.vector.reduce.fmul.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id574" id="id1654">Syntax:</a></li>
+<li><a class="reference internal" href="#id575" id="id1655">Overview:</a></li>
+<li><a class="reference internal" href="#id576" id="id1656">Arguments:</a></li>
+<li><a class="reference internal" href="#id577" id="id1657">Examples:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-vector-reduce-and-intrinsic" id="id1658">‘<tt class="docutils literal"><span class="pre">llvm.experimental.vector.reduce.and.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id578" id="id1659">Syntax:</a></li>
+<li><a class="reference internal" href="#id579" id="id1660">Overview:</a></li>
+<li><a class="reference internal" href="#id580" id="id1661">Arguments:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-vector-reduce-or-intrinsic" id="id1662">‘<tt class="docutils literal"><span class="pre">llvm.experimental.vector.reduce.or.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id581" id="id1663">Syntax:</a></li>
+<li><a class="reference internal" href="#id582" id="id1664">Overview:</a></li>
+<li><a class="reference internal" href="#id583" id="id1665">Arguments:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-vector-reduce-xor-intrinsic" id="id1666">‘<tt class="docutils literal"><span class="pre">llvm.experimental.vector.reduce.xor.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id584" id="id1667">Syntax:</a></li>
+<li><a class="reference internal" href="#id585" id="id1668">Overview:</a></li>
+<li><a class="reference internal" href="#id586" id="id1669">Arguments:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-vector-reduce-smax-intrinsic" id="id1670">‘<tt class="docutils literal"><span class="pre">llvm.experimental.vector.reduce.smax.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id587" id="id1671">Syntax:</a></li>
+<li><a class="reference internal" href="#id588" id="id1672">Overview:</a></li>
+<li><a class="reference internal" href="#id589" id="id1673">Arguments:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-vector-reduce-smin-intrinsic" id="id1674">‘<tt class="docutils literal"><span class="pre">llvm.experimental.vector.reduce.smin.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id590" id="id1675">Syntax:</a></li>
+<li><a class="reference internal" href="#id591" id="id1676">Overview:</a></li>
+<li><a class="reference internal" href="#id592" id="id1677">Arguments:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-vector-reduce-umax-intrinsic" id="id1678">‘<tt class="docutils literal"><span class="pre">llvm.experimental.vector.reduce.umax.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id593" id="id1679">Syntax:</a></li>
+<li><a class="reference internal" href="#id594" id="id1680">Overview:</a></li>
+<li><a class="reference internal" href="#id595" id="id1681">Arguments:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-vector-reduce-umin-intrinsic" id="id1682">‘<tt class="docutils literal"><span class="pre">llvm.experimental.vector.reduce.umin.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id596" id="id1683">Syntax:</a></li>
+<li><a class="reference internal" href="#id597" id="id1684">Overview:</a></li>
+<li><a class="reference internal" href="#id598" id="id1685">Arguments:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-vector-reduce-fmax-intrinsic" id="id1686">‘<tt class="docutils literal"><span class="pre">llvm.experimental.vector.reduce.fmax.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id599" id="id1687">Syntax:</a></li>
+<li><a class="reference internal" href="#id600" id="id1688">Overview:</a></li>
+<li><a class="reference internal" href="#id601" id="id1689">Arguments:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-vector-reduce-fmin-intrinsic" id="id1690">‘<tt class="docutils literal"><span class="pre">llvm.experimental.vector.reduce.fmin.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id602" id="id1691">Syntax:</a></li>
+<li><a class="reference internal" href="#id603" id="id1692">Overview:</a></li>
+<li><a class="reference internal" href="#id604" id="id1693">Arguments:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#half-precision-floating-point-intrinsics" id="id1694">Half Precision Floating Point Intrinsics</a><ul>
+<li><a class="reference internal" href="#llvm-convert-to-fp16-intrinsic" id="id1695">‘<tt class="docutils literal"><span class="pre">llvm.convert.to.fp16</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id605" id="id1696">Syntax:</a></li>
+<li><a class="reference internal" href="#id606" id="id1697">Overview:</a></li>
+<li><a class="reference internal" href="#id607" id="id1698">Arguments:</a></li>
+<li><a class="reference internal" href="#id608" id="id1699">Semantics:</a></li>
+<li><a class="reference internal" href="#id609" id="id1700">Examples:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-convert-from-fp16-intrinsic" id="id1701">‘<tt class="docutils literal"><span class="pre">llvm.convert.from.fp16</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id610" id="id1702">Syntax:</a></li>
+<li><a class="reference internal" href="#id611" id="id1703">Overview:</a></li>
+<li><a class="reference internal" href="#id612" id="id1704">Arguments:</a></li>
+<li><a class="reference internal" href="#id613" id="id1705">Semantics:</a></li>
+<li><a class="reference internal" href="#id614" id="id1706">Examples:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#debugger-intrinsics" id="id1707">Debugger Intrinsics</a></li>
+<li><a class="reference internal" href="#exception-handling-intrinsics" id="id1708">Exception Handling Intrinsics</a></li>
+<li><a class="reference internal" href="#trampoline-intrinsics" id="id1709">Trampoline Intrinsics</a><ul>
+<li><a class="reference internal" href="#llvm-init-trampoline-intrinsic" id="id1710">‘<tt class="docutils literal"><span class="pre">llvm.init.trampoline</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id615" id="id1711">Syntax:</a></li>
+<li><a class="reference internal" href="#id616" id="id1712">Overview:</a></li>
+<li><a class="reference internal" href="#id617" id="id1713">Arguments:</a></li>
+<li><a class="reference internal" href="#id618" id="id1714">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-adjust-trampoline-intrinsic" id="id1715">‘<tt class="docutils literal"><span class="pre">llvm.adjust.trampoline</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id619" id="id1716">Syntax:</a></li>
+<li><a class="reference internal" href="#id620" id="id1717">Overview:</a></li>
+<li><a class="reference internal" href="#id621" id="id1718">Arguments:</a></li>
+<li><a class="reference internal" href="#id622" id="id1719">Semantics:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#masked-vector-load-and-store-intrinsics" id="id1720">Masked Vector Load and Store Intrinsics</a><ul>
+<li><a class="reference internal" href="#llvm-masked-load-intrinsics" id="id1721">‘<tt class="docutils literal"><span class="pre">llvm.masked.load.*</span></tt>‘ Intrinsics</a><ul>
+<li><a class="reference internal" href="#id623" id="id1722">Syntax:</a></li>
+<li><a class="reference internal" href="#id624" id="id1723">Overview:</a></li>
+<li><a class="reference internal" href="#id625" id="id1724">Arguments:</a></li>
+<li><a class="reference internal" href="#id626" id="id1725">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-masked-store-intrinsics" id="id1726">‘<tt class="docutils literal"><span class="pre">llvm.masked.store.*</span></tt>‘ Intrinsics</a><ul>
+<li><a class="reference internal" href="#id627" id="id1727">Syntax:</a></li>
+<li><a class="reference internal" href="#id628" id="id1728">Overview:</a></li>
+<li><a class="reference internal" href="#id629" id="id1729">Arguments:</a></li>
+<li><a class="reference internal" href="#id630" id="id1730">Semantics:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#masked-vector-gather-and-scatter-intrinsics" id="id1731">Masked Vector Gather and Scatter Intrinsics</a><ul>
+<li><a class="reference internal" href="#llvm-masked-gather-intrinsics" id="id1732">‘<tt class="docutils literal"><span class="pre">llvm.masked.gather.*</span></tt>‘ Intrinsics</a><ul>
+<li><a class="reference internal" href="#id631" id="id1733">Syntax:</a></li>
+<li><a class="reference internal" href="#id632" id="id1734">Overview:</a></li>
+<li><a class="reference internal" href="#id633" id="id1735">Arguments:</a></li>
+<li><a class="reference internal" href="#id634" id="id1736">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-masked-scatter-intrinsics" id="id1737">‘<tt class="docutils literal"><span class="pre">llvm.masked.scatter.*</span></tt>‘ Intrinsics</a><ul>
+<li><a class="reference internal" href="#id635" id="id1738">Syntax:</a></li>
+<li><a class="reference internal" href="#id636" id="id1739">Overview:</a></li>
+<li><a class="reference internal" href="#id637" id="id1740">Arguments:</a></li>
+<li><a class="reference internal" href="#id638" id="id1741">Semantics:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#memory-use-markers" id="id1742">Memory Use Markers</a><ul>
+<li><a class="reference internal" href="#llvm-lifetime-start-intrinsic" id="id1743">‘<tt class="docutils literal"><span class="pre">llvm.lifetime.start</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id639" id="id1744">Syntax:</a></li>
+<li><a class="reference internal" href="#id640" id="id1745">Overview:</a></li>
+<li><a class="reference internal" href="#id641" id="id1746">Arguments:</a></li>
+<li><a class="reference internal" href="#id642" id="id1747">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-lifetime-end-intrinsic" id="id1748">‘<tt class="docutils literal"><span class="pre">llvm.lifetime.end</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id643" id="id1749">Syntax:</a></li>
+<li><a class="reference internal" href="#id644" id="id1750">Overview:</a></li>
+<li><a class="reference internal" href="#id645" id="id1751">Arguments:</a></li>
+<li><a class="reference internal" href="#id646" id="id1752">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-invariant-start-intrinsic" id="id1753">‘<tt class="docutils literal"><span class="pre">llvm.invariant.start</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id647" id="id1754">Syntax:</a></li>
+<li><a class="reference internal" href="#id648" id="id1755">Overview:</a></li>
+<li><a class="reference internal" href="#id649" id="id1756">Arguments:</a></li>
+<li><a class="reference internal" href="#id650" id="id1757">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-invariant-end-intrinsic" id="id1758">‘<tt class="docutils literal"><span class="pre">llvm.invariant.end</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id651" id="id1759">Syntax:</a></li>
+<li><a class="reference internal" href="#id652" id="id1760">Overview:</a></li>
+<li><a class="reference internal" href="#id653" id="id1761">Arguments:</a></li>
+<li><a class="reference internal" href="#id654" id="id1762">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-invariant-group-barrier-intrinsic" id="id1763">‘<tt class="docutils literal"><span class="pre">llvm.invariant.group.barrier</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id655" id="id1764">Syntax:</a></li>
+<li><a class="reference internal" href="#id656" id="id1765">Overview:</a></li>
+<li><a class="reference internal" href="#id657" id="id1766">Arguments:</a></li>
+<li><a class="reference internal" href="#id658" id="id1767">Semantics:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#constrained-floating-point-intrinsics" id="id1768">Constrained Floating Point Intrinsics</a><ul>
+<li><a class="reference internal" href="#llvm-experimental-constrained-fadd-intrinsic" id="id1769">‘<tt class="docutils literal"><span class="pre">llvm.experimental.constrained.fadd</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id659" id="id1770">Syntax:</a></li>
+<li><a class="reference internal" href="#id660" id="id1771">Overview:</a></li>
+<li><a class="reference internal" href="#id661" id="id1772">Arguments:</a></li>
+<li><a class="reference internal" href="#id662" id="id1773">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-constrained-fsub-intrinsic" id="id1774">‘<tt class="docutils literal"><span class="pre">llvm.experimental.constrained.fsub</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id663" id="id1775">Syntax:</a></li>
+<li><a class="reference internal" href="#id664" id="id1776">Overview:</a></li>
+<li><a class="reference internal" href="#id665" id="id1777">Arguments:</a></li>
+<li><a class="reference internal" href="#id666" id="id1778">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-constrained-fmul-intrinsic" id="id1779">‘<tt class="docutils literal"><span class="pre">llvm.experimental.constrained.fmul</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id667" id="id1780">Syntax:</a></li>
+<li><a class="reference internal" href="#id668" id="id1781">Overview:</a></li>
+<li><a class="reference internal" href="#id669" id="id1782">Arguments:</a></li>
+<li><a class="reference internal" href="#id670" id="id1783">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-constrained-fdiv-intrinsic" id="id1784">‘<tt class="docutils literal"><span class="pre">llvm.experimental.constrained.fdiv</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id671" id="id1785">Syntax:</a></li>
+<li><a class="reference internal" href="#id672" id="id1786">Overview:</a></li>
+<li><a class="reference internal" href="#id673" id="id1787">Arguments:</a></li>
+<li><a class="reference internal" href="#id674" id="id1788">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-constrained-frem-intrinsic" id="id1789">‘<tt class="docutils literal"><span class="pre">llvm.experimental.constrained.frem</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id675" id="id1790">Syntax:</a></li>
+<li><a class="reference internal" href="#id676" id="id1791">Overview:</a></li>
+<li><a class="reference internal" href="#id677" id="id1792">Arguments:</a></li>
+<li><a class="reference internal" href="#id678" id="id1793">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-constrained-fma-intrinsic" id="id1794">‘<tt class="docutils literal"><span class="pre">llvm.experimental.constrained.fma</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id679" id="id1795">Syntax:</a></li>
+<li><a class="reference internal" href="#id680" id="id1796">Overview:</a></li>
+<li><a class="reference internal" href="#id681" id="id1797">Arguments:</a></li>
+<li><a class="reference internal" href="#id682" id="id1798">Semantics:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#constrained-libm-equivalent-intrinsics" id="id1799">Constrained libm-equivalent Intrinsics</a><ul>
+<li><a class="reference internal" href="#llvm-experimental-constrained-sqrt-intrinsic" id="id1800">‘<tt class="docutils literal"><span class="pre">llvm.experimental.constrained.sqrt</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id683" id="id1801">Syntax:</a></li>
+<li><a class="reference internal" href="#id684" id="id1802">Overview:</a></li>
+<li><a class="reference internal" href="#id685" id="id1803">Arguments:</a></li>
+<li><a class="reference internal" href="#id686" id="id1804">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-constrained-pow-intrinsic" id="id1805">‘<tt class="docutils literal"><span class="pre">llvm.experimental.constrained.pow</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id687" id="id1806">Syntax:</a></li>
+<li><a class="reference internal" href="#id688" id="id1807">Overview:</a></li>
+<li><a class="reference internal" href="#id689" id="id1808">Arguments:</a></li>
+<li><a class="reference internal" href="#id690" id="id1809">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-constrained-powi-intrinsic" id="id1810">‘<tt class="docutils literal"><span class="pre">llvm.experimental.constrained.powi</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id691" id="id1811">Syntax:</a></li>
+<li><a class="reference internal" href="#id692" id="id1812">Overview:</a></li>
+<li><a class="reference internal" href="#id693" id="id1813">Arguments:</a></li>
+<li><a class="reference internal" href="#id694" id="id1814">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-constrained-sin-intrinsic" id="id1815">‘<tt class="docutils literal"><span class="pre">llvm.experimental.constrained.sin</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id695" id="id1816">Syntax:</a></li>
+<li><a class="reference internal" href="#id696" id="id1817">Overview:</a></li>
+<li><a class="reference internal" href="#id697" id="id1818">Arguments:</a></li>
+<li><a class="reference internal" href="#id698" id="id1819">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-constrained-cos-intrinsic" id="id1820">‘<tt class="docutils literal"><span class="pre">llvm.experimental.constrained.cos</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id699" id="id1821">Syntax:</a></li>
+<li><a class="reference internal" href="#id700" id="id1822">Overview:</a></li>
+<li><a class="reference internal" href="#id701" id="id1823">Arguments:</a></li>
+<li><a class="reference internal" href="#id702" id="id1824">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-constrained-exp-intrinsic" id="id1825">‘<tt class="docutils literal"><span class="pre">llvm.experimental.constrained.exp</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id703" id="id1826">Syntax:</a></li>
+<li><a class="reference internal" href="#id704" id="id1827">Overview:</a></li>
+<li><a class="reference internal" href="#id705" id="id1828">Arguments:</a></li>
+<li><a class="reference internal" href="#id706" id="id1829">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-constrained-exp2-intrinsic" id="id1830">‘<tt class="docutils literal"><span class="pre">llvm.experimental.constrained.exp2</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id707" id="id1831">Syntax:</a></li>
+<li><a class="reference internal" href="#id708" id="id1832">Overview:</a></li>
+<li><a class="reference internal" href="#id709" id="id1833">Arguments:</a></li>
+<li><a class="reference internal" href="#id710" id="id1834">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-constrained-log-intrinsic" id="id1835">‘<tt class="docutils literal"><span class="pre">llvm.experimental.constrained.log</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id711" id="id1836">Syntax:</a></li>
+<li><a class="reference internal" href="#id712" id="id1837">Overview:</a></li>
+<li><a class="reference internal" href="#id713" id="id1838">Arguments:</a></li>
+<li><a class="reference internal" href="#id714" id="id1839">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-constrained-log10-intrinsic" id="id1840">‘<tt class="docutils literal"><span class="pre">llvm.experimental.constrained.log10</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id715" id="id1841">Syntax:</a></li>
+<li><a class="reference internal" href="#id716" id="id1842">Overview:</a></li>
+<li><a class="reference internal" href="#id717" id="id1843">Arguments:</a></li>
+<li><a class="reference internal" href="#id718" id="id1844">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-constrained-log2-intrinsic" id="id1845">‘<tt class="docutils literal"><span class="pre">llvm.experimental.constrained.log2</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id719" id="id1846">Syntax:</a></li>
+<li><a class="reference internal" href="#id720" id="id1847">Overview:</a></li>
+<li><a class="reference internal" href="#id721" id="id1848">Arguments:</a></li>
+<li><a class="reference internal" href="#id722" id="id1849">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-constrained-rint-intrinsic" id="id1850">‘<tt class="docutils literal"><span class="pre">llvm.experimental.constrained.rint</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id723" id="id1851">Syntax:</a></li>
+<li><a class="reference internal" href="#id724" id="id1852">Overview:</a></li>
+<li><a class="reference internal" href="#id725" id="id1853">Arguments:</a></li>
+<li><a class="reference internal" href="#id726" id="id1854">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-constrained-nearbyint-intrinsic" id="id1855">‘<tt class="docutils literal"><span class="pre">llvm.experimental.constrained.nearbyint</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id727" id="id1856">Syntax:</a></li>
+<li><a class="reference internal" href="#id728" id="id1857">Overview:</a></li>
+<li><a class="reference internal" href="#id729" id="id1858">Arguments:</a></li>
+<li><a class="reference internal" href="#id730" id="id1859">Semantics:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#general-intrinsics" id="id1860">General Intrinsics</a><ul>
+<li><a class="reference internal" href="#llvm-var-annotation-intrinsic" id="id1861">‘<tt class="docutils literal"><span class="pre">llvm.var.annotation</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id731" id="id1862">Syntax:</a></li>
+<li><a class="reference internal" href="#id732" id="id1863">Overview:</a></li>
+<li><a class="reference internal" href="#id733" id="id1864">Arguments:</a></li>
+<li><a class="reference internal" href="#id734" id="id1865">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-ptr-annotation-intrinsic" id="id1866">‘<tt class="docutils literal"><span class="pre">llvm.ptr.annotation.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id735" id="id1867">Syntax:</a></li>
+<li><a class="reference internal" href="#id736" id="id1868">Overview:</a></li>
+<li><a class="reference internal" href="#id737" id="id1869">Arguments:</a></li>
+<li><a class="reference internal" href="#id738" id="id1870">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-annotation-intrinsic" id="id1871">‘<tt class="docutils literal"><span class="pre">llvm.annotation.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id739" id="id1872">Syntax:</a></li>
+<li><a class="reference internal" href="#id740" id="id1873">Overview:</a></li>
+<li><a class="reference internal" href="#id741" id="id1874">Arguments:</a></li>
+<li><a class="reference internal" href="#id742" id="id1875">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-codeview-annotation-intrinsic" id="id1876">‘<tt class="docutils literal"><span class="pre">llvm.codeview.annotation</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id743" id="id1877">Syntax:</a></li>
+<li><a class="reference internal" href="#id744" id="id1878">Arguments:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-trap-intrinsic" id="id1879">‘<tt class="docutils literal"><span class="pre">llvm.trap</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id745" id="id1880">Syntax:</a></li>
+<li><a class="reference internal" href="#id746" id="id1881">Overview:</a></li>
+<li><a class="reference internal" href="#id747" id="id1882">Arguments:</a></li>
+<li><a class="reference internal" href="#id748" id="id1883">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-debugtrap-intrinsic" id="id1884">‘<tt class="docutils literal"><span class="pre">llvm.debugtrap</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id749" id="id1885">Syntax:</a></li>
+<li><a class="reference internal" href="#id750" id="id1886">Overview:</a></li>
+<li><a class="reference internal" href="#id751" id="id1887">Arguments:</a></li>
+<li><a class="reference internal" href="#id752" id="id1888">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-stackprotector-intrinsic" id="id1889">‘<tt class="docutils literal"><span class="pre">llvm.stackprotector</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id753" id="id1890">Syntax:</a></li>
+<li><a class="reference internal" href="#id754" id="id1891">Overview:</a></li>
+<li><a class="reference internal" href="#id755" id="id1892">Arguments:</a></li>
+<li><a class="reference internal" href="#id756" id="id1893">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-stackguard-intrinsic" id="id1894">‘<tt class="docutils literal"><span class="pre">llvm.stackguard</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id757" id="id1895">Syntax:</a></li>
+<li><a class="reference internal" href="#id758" id="id1896">Overview:</a></li>
+<li><a class="reference internal" href="#id759" id="id1897">Arguments:</a></li>
+<li><a class="reference internal" href="#id760" id="id1898">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-objectsize-intrinsic" id="id1899">‘<tt class="docutils literal"><span class="pre">llvm.objectsize</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id761" id="id1900">Syntax:</a></li>
+<li><a class="reference internal" href="#id762" id="id1901">Overview:</a></li>
+<li><a class="reference internal" href="#id763" id="id1902">Arguments:</a></li>
+<li><a class="reference internal" href="#id764" id="id1903">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-expect-intrinsic" id="id1904">‘<tt class="docutils literal"><span class="pre">llvm.expect</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id765" id="id1905">Syntax:</a></li>
+<li><a class="reference internal" href="#id766" id="id1906">Overview:</a></li>
+<li><a class="reference internal" href="#id767" id="id1907">Arguments:</a></li>
+<li><a class="reference internal" href="#id768" id="id1908">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-assume-intrinsic" id="id1909">‘<tt class="docutils literal"><span class="pre">llvm.assume</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id769" id="id1910">Syntax:</a></li>
+<li><a class="reference internal" href="#id770" id="id1911">Overview:</a></li>
+<li><a class="reference internal" href="#id771" id="id1912">Arguments:</a></li>
+<li><a class="reference internal" href="#id772" id="id1913">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-ssa-copy-intrinsic" id="id1914">‘<tt class="docutils literal"><span class="pre">llvm.ssa_copy</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id773" id="id1915">Syntax:</a></li>
+<li><a class="reference internal" href="#id774" id="id1916">Arguments:</a></li>
+<li><a class="reference internal" href="#id775" id="id1917">Overview:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-type-test-intrinsic" id="id1918">‘<tt class="docutils literal"><span class="pre">llvm.type.test</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id776" id="id1919">Syntax:</a></li>
+<li><a class="reference internal" href="#id777" id="id1920">Arguments:</a></li>
+<li><a class="reference internal" href="#id778" id="id1921">Overview:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-type-checked-load-intrinsic" id="id1922">‘<tt class="docutils literal"><span class="pre">llvm.type.checked.load</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id779" id="id1923">Syntax:</a></li>
+<li><a class="reference internal" href="#id780" id="id1924">Arguments:</a></li>
+<li><a class="reference internal" href="#id781" id="id1925">Overview:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-donothing-intrinsic" id="id1926">‘<tt class="docutils literal"><span class="pre">llvm.donothing</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id782" id="id1927">Syntax:</a></li>
+<li><a class="reference internal" href="#id783" id="id1928">Overview:</a></li>
+<li><a class="reference internal" href="#id784" id="id1929">Arguments:</a></li>
+<li><a class="reference internal" href="#id785" id="id1930">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-deoptimize-intrinsic" id="id1931">‘<tt class="docutils literal"><span class="pre">llvm.experimental.deoptimize</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id786" id="id1932">Syntax:</a></li>
+<li><a class="reference internal" href="#id787" id="id1933">Overview:</a></li>
+<li><a class="reference internal" href="#id788" id="id1934">Arguments:</a></li>
+<li><a class="reference internal" href="#id789" id="id1935">Semantics:</a></li>
+<li><a class="reference internal" href="#lowering" id="id1936">Lowering:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-guard-intrinsic" id="id1937">‘<tt class="docutils literal"><span class="pre">llvm.experimental.guard</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id790" id="id1938">Syntax:</a></li>
+<li><a class="reference internal" href="#id791" id="id1939">Overview:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-load-relative-intrinsic" id="id1940">‘<tt class="docutils literal"><span class="pre">llvm.load.relative</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id792" id="id1941">Syntax:</a></li>
+<li><a class="reference internal" href="#id793" id="id1942">Overview:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-sideeffect-intrinsic" id="id1943">‘<tt class="docutils literal"><span class="pre">llvm.sideeffect</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id794" id="id1944">Syntax:</a></li>
+<li><a class="reference internal" href="#id795" id="id1945">Overview:</a></li>
+<li><a class="reference internal" href="#id796" id="id1946">Arguments:</a></li>
+<li><a class="reference internal" href="#id797" id="id1947">Semantics:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#stack-map-intrinsics" id="id1948">Stack Map Intrinsics</a></li>
+<li><a class="reference internal" href="#element-wise-atomic-memory-intrinsics" id="id1949">Element Wise Atomic Memory Intrinsics</a><ul>
+<li><a class="reference internal" href="#llvm-memcpy-element-unordered-atomic-intrinsic" id="id1950">‘<tt class="docutils literal"><span class="pre">llvm.memcpy.element.unordered.atomic</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id798" id="id1951">Syntax:</a></li>
+<li><a class="reference internal" href="#id799" id="id1952">Overview:</a></li>
+<li><a class="reference internal" href="#id800" id="id1953">Arguments:</a></li>
+<li><a class="reference internal" href="#id801" id="id1954">Semantics:</a></li>
+<li><a class="reference internal" href="#id802" id="id1955">Lowering:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-memmove-element-unordered-atomic-intrinsic" id="id1956">‘<tt class="docutils literal"><span class="pre">llvm.memmove.element.unordered.atomic</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id803" id="id1957">Syntax:</a></li>
+<li><a class="reference internal" href="#id804" id="id1958">Overview:</a></li>
+<li><a class="reference internal" href="#id805" id="id1959">Arguments:</a></li>
+<li><a class="reference internal" href="#id806" id="id1960">Semantics:</a></li>
+<li><a class="reference internal" href="#id807" id="id1961">Lowering:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-memset-element-unordered-atomic-intrinsic" id="id1962">‘<tt class="docutils literal"><span class="pre">llvm.memset.element.unordered.atomic</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id808" id="id1963">Syntax:</a></li>
+<li><a class="reference internal" href="#id809" id="id1964">Overview:</a></li>
+<li><a class="reference internal" href="#id810" id="id1965">Arguments:</a></li>
+<li><a class="reference internal" href="#id811" id="id1966">Semantics:</a></li>
+<li><a class="reference internal" href="#id812" id="id1967">Lowering:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</div>
+<div class="section" id="abstract">
+<h2><a class="toc-backref" href="#id813">Abstract</a><a class="headerlink" href="#abstract" title="Permalink to this headline">¶</a></h2>
+<p>This document is a reference manual for the LLVM assembly language. LLVM
+is a Static Single Assignment (SSA) based representation that provides
+type safety, low-level operations, flexibility, and the capability of
+representing ‘all’ high-level languages cleanly. It is the common code
+representation used throughout all phases of the LLVM compilation
+strategy.</p>
+</div>
+<div class="section" id="introduction">
+<h2><a class="toc-backref" href="#id814">Introduction</a><a class="headerlink" href="#introduction" title="Permalink to this headline">¶</a></h2>
+<p>The LLVM code representation is designed to be used in three different
+forms: as an in-memory compiler IR, as an on-disk bitcode representation
+(suitable for fast loading by a Just-In-Time compiler), and as a human
+readable assembly language representation. This allows LLVM to provide a
+powerful intermediate representation for efficient compiler
+transformations and analysis, while providing a natural means to debug
+and visualize the transformations. The three different forms of LLVM are
+all equivalent. This document describes the human readable
+representation and notation.</p>
+<p>The LLVM representation aims to be light-weight and low-level while
+being expressive, typed, and extensible at the same time. It aims to be
+a “universal IR” of sorts, by being at a low enough level that
+high-level ideas may be cleanly mapped to it (similar to how
+microprocessors are “universal IR’s”, allowing many source languages to
+be mapped to them). By providing type information, LLVM can be used as
+the target of optimizations: for example, through pointer analysis, it
+can be proven that a C automatic variable is never accessed outside of
+the current function, allowing it to be promoted to a simple SSA value
+instead of a memory location.</p>
+<div class="section" id="well-formedness">
+<span id="wellformed"></span><h3><a class="toc-backref" href="#id815">Well-Formedness</a><a class="headerlink" href="#well-formedness" title="Permalink to this headline">¶</a></h3>
+<p>It is important to note that this document describes ‘well formed’ LLVM
+assembly language. There is a difference between what the parser accepts
+and what is considered ‘well formed’. For example, the following
+instruction is syntactically okay, but not well formed:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%x</span> <span class="p">=</span> <span class="k">add</span> <span class="k">i32</span> <span class="m">1</span><span class="p">,</span> <span class="nv">%x</span>
+</pre></div>
+</div>
+<p>because the definition of <tt class="docutils literal"><span class="pre">%x</span></tt> does not dominate all of its uses. The
+LLVM infrastructure provides a verification pass that may be used to
+verify that an LLVM module is well formed. This pass is automatically
+run by the parser after parsing input assembly and by the optimizer
+before it outputs bitcode. The violations pointed out by the verifier
+pass indicate bugs in transformation passes or input to the parser.</p>
+</div>
+</div>
+<div class="section" id="identifiers">
+<span id="id1"></span><h2><a class="toc-backref" href="#id816">Identifiers</a><a class="headerlink" href="#identifiers" title="Permalink to this headline">¶</a></h2>
+<p>LLVM identifiers come in two basic types: global and local. Global
+identifiers (functions, global variables) begin with the <tt class="docutils literal"><span class="pre">'@'</span></tt>
+character. Local identifiers (register names, types) begin with the
+<tt class="docutils literal"><span class="pre">'%'</span></tt> character. Additionally, there are three different formats for
+identifiers, for different purposes:</p>
+<ol class="arabic simple">
+<li>Named values are represented as a string of characters with their
+prefix. For example, <tt class="docutils literal"><span class="pre">%foo</span></tt>, <tt class="docutils literal"><span class="pre">@DivisionByZero</span></tt>,
+<tt class="docutils literal"><span class="pre">%a.really.long.identifier</span></tt>. The actual regular expression used is
+‘<tt class="docutils literal"><span class="pre">[%@][-a-zA-Z$._][-a-zA-Z$._0-9]*</span></tt>‘. Identifiers that require other
+characters in their names can be surrounded with quotes. Special
+characters may be escaped using <tt class="docutils literal"><span class="pre">"\xx"</span></tt> where <tt class="docutils literal"><span class="pre">xx</span></tt> is the ASCII
+code for the character in hexadecimal. In this way, any character can
+be used in a name value, even quotes themselves. The <tt class="docutils literal"><span class="pre">"\01"</span></tt> prefix
+can be used on global variables to suppress mangling.</li>
+<li>Unnamed values are represented as an unsigned numeric value with
+their prefix. For example, <tt class="docutils literal"><span class="pre">%12</span></tt>, <tt class="docutils literal"><span class="pre">@2</span></tt>, <tt class="docutils literal"><span class="pre">%44</span></tt>.</li>
+<li>Constants, which are described in the section <a class="reference internal" href="#constants">Constants</a> below.</li>
+</ol>
+<p>LLVM requires that values start with a prefix for two reasons: Compilers
+don’t need to worry about name clashes with reserved words, and the set
+of reserved words may be expanded in the future without penalty.
+Additionally, unnamed identifiers allow a compiler to quickly come up
+with a temporary variable without having to avoid symbol table
+conflicts.</p>
+<p>Reserved words in LLVM are very similar to reserved words in other
+languages. There are keywords for different opcodes (‘<tt class="docutils literal"><span class="pre">add</span></tt>‘,
+‘<tt class="docutils literal"><span class="pre">bitcast</span></tt>‘, ‘<tt class="docutils literal"><span class="pre">ret</span></tt>‘, etc...), for primitive type names (‘<tt class="docutils literal"><span class="pre">void</span></tt>‘,
+‘<tt class="docutils literal"><span class="pre">i32</span></tt>‘, etc...), and others. These reserved words cannot conflict
+with variable names, because none of them start with a prefix character
+(<tt class="docutils literal"><span class="pre">'%'</span></tt> or <tt class="docutils literal"><span class="pre">'@'</span></tt>).</p>
+<p>Here is an example of LLVM code to multiply the integer variable
+‘<tt class="docutils literal"><span class="pre">%X</span></tt>‘ by 8:</p>
+<p>The easy way:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%result</span> <span class="p">=</span> <span class="k">mul</span> <span class="k">i32</span> <span class="nv">%X</span><span class="p">,</span> <span class="m">8</span>
+</pre></div>
+</div>
+<p>After strength reduction:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%result</span> <span class="p">=</span> <span class="k">shl</span> <span class="k">i32</span> <span class="nv">%X</span><span class="p">,</span> <span class="m">3</span>
+</pre></div>
+</div>
+<p>And the hard way:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv-Anonymous">%0</span> <span class="p">=</span> <span class="k">add</span> <span class="k">i32</span> <span class="nv">%X</span><span class="p">,</span> <span class="nv">%X</span>           <span class="c">; yields i32:%0</span>
+<span class="nv-Anonymous">%1</span> <span class="p">=</span> <span class="k">add</span> <span class="k">i32</span> <span class="nv-Anonymous">%0</span><span class="p">,</span> <span class="nv-Anonymous">%0</span>           <span class="c">; yields i32:%1</span>
+<span class="nv">%result</span> <span class="p">=</span> <span class="k">add</span> <span class="k">i32</span> <span class="nv-Anonymous">%1</span><span class="p">,</span> <span class="nv-Anonymous">%1</span>
+</pre></div>
+</div>
+<p>This last way of multiplying <tt class="docutils literal"><span class="pre">%X</span></tt> by 8 illustrates several important
+lexical features of LLVM:</p>
+<ol class="arabic simple">
+<li>Comments are delimited with a ‘<tt class="docutils literal"><span class="pre">;</span></tt>‘ and go until the end of line.</li>
+<li>Unnamed temporaries are created when the result of a computation is
+not assigned to a named value.</li>
+<li>Unnamed temporaries are numbered sequentially (using a per-function
+incrementing counter, starting with 0). Note that basic blocks and unnamed
+function parameters are included in this numbering. For example, if the
+entry basic block is not given a label name and all function parameters are
+named, then it will get number 0.</li>
+</ol>
+<p>It also shows a convention that we follow in this document. When
+demonstrating instructions, we will follow an instruction with a comment
+that defines the type and name of value produced.</p>
+</div>
+<div class="section" id="high-level-structure">
+<h2><a class="toc-backref" href="#id817">High Level Structure</a><a class="headerlink" href="#high-level-structure" title="Permalink to this headline">¶</a></h2>
+<div class="section" id="module-structure">
+<h3><a class="toc-backref" href="#id818">Module Structure</a><a class="headerlink" href="#module-structure" title="Permalink to this headline">¶</a></h3>
+<p>LLVM programs are composed of <tt class="docutils literal"><span class="pre">Module</span></tt>‘s, each of which is a
+translation unit of the input programs. Each module consists of
+functions, global variables, and symbol table entries. Modules may be
+combined together with the LLVM linker, which merges function (and
+global variable) definitions, resolves forward declarations, and merges
+symbol table entries. Here is an example of the “hello world” module:</p>
+<div class="highlight-llvm"><pre>; Declare the string constant as a global constant.
+ at .str = private unnamed_addr constant [13 x i8] c"hello world\0A\00"
+
+; External declaration of the puts function
+declare i32 @puts(i8* nocapture) nounwind
+
+; Definition of main function
+define i32 @main() {   ; i32()*
+  ; Convert [13 x i8]* to i8*...
+  %cast210 = getelementptr [13 x i8], [13 x i8]* @.str, i64 0, i64 0
+
+  ; Call puts function to write out the string to stdout.
+  call i32 @puts(i8* %cast210)
+  ret i32 0
+}
+
+; Named metadata
+!0 = !{i32 42, null, !"string"}
+!foo = !{!0}</pre>
+</div>
+<p>This example is made up of a <a class="reference internal" href="#globalvars"><em>global variable</em></a> named
+“<tt class="docutils literal"><span class="pre">.str</span></tt>”, an external declaration of the “<tt class="docutils literal"><span class="pre">puts</span></tt>” function, a
+<a class="reference internal" href="#functionstructure"><em>function definition</em></a> for “<tt class="docutils literal"><span class="pre">main</span></tt>” and
+<a class="reference internal" href="#namedmetadatastructure"><em>named metadata</em></a> “<tt class="docutils literal"><span class="pre">foo</span></tt>”.</p>
+<p>In general, a module is made up of a list of global values (where both
+functions and global variables are global values). Global values are
+represented by a pointer to a memory location (in this case, a pointer
+to an array of char, and a pointer to a function), and have one of the
+following <a class="reference internal" href="#linkage"><em>linkage types</em></a>.</p>
+</div>
+<div class="section" id="linkage-types">
+<span id="linkage"></span><h3><a class="toc-backref" href="#id819">Linkage Types</a><a class="headerlink" href="#linkage-types" title="Permalink to this headline">¶</a></h3>
+<p>All Global Variables and Functions have one of the following types of
+linkage:</p>
+<dl class="docutils">
+<dt><tt class="docutils literal"><span class="pre">private</span></tt></dt>
+<dd>Global values with “<tt class="docutils literal"><span class="pre">private</span></tt>” linkage are only directly
+accessible by objects in the current module. In particular, linking
+code into a module with a private global value may cause the
+private to be renamed as necessary to avoid collisions. Because the
+symbol is private to the module, all references can be updated. This
+doesn’t show up in any symbol table in the object file.</dd>
+<dt><tt class="docutils literal"><span class="pre">internal</span></tt></dt>
+<dd>Similar to private, but the value shows as a local symbol
+(<tt class="docutils literal"><span class="pre">STB_LOCAL</span></tt> in the case of ELF) in the object file. This
+corresponds to the notion of the ‘<tt class="docutils literal"><span class="pre">static</span></tt>‘ keyword in C.</dd>
+<dt><tt class="docutils literal"><span class="pre">available_externally</span></tt></dt>
+<dd>Globals with “<tt class="docutils literal"><span class="pre">available_externally</span></tt>” linkage are never emitted into
+the object file corresponding to the LLVM module. From the linker’s
+perspective, an <tt class="docutils literal"><span class="pre">available_externally</span></tt> global is equivalent to
+an external declaration. They exist to allow inlining and other
+optimizations to take place given knowledge of the definition of the
+global, which is known to be somewhere outside the module. Globals
+with <tt class="docutils literal"><span class="pre">available_externally</span></tt> linkage are allowed to be discarded at
+will, and allow inlining and other optimizations. This linkage type is
+only allowed on definitions, not declarations.</dd>
+<dt><tt class="docutils literal"><span class="pre">linkonce</span></tt></dt>
+<dd>Globals with “<tt class="docutils literal"><span class="pre">linkonce</span></tt>” linkage are merged with other globals of
+the same name when linkage occurs. This can be used to implement
+some forms of inline functions, templates, or other code which must
+be generated in each translation unit that uses it, but where the
+body may be overridden with a more definitive definition later.
+Unreferenced <tt class="docutils literal"><span class="pre">linkonce</span></tt> globals are allowed to be discarded. Note
+that <tt class="docutils literal"><span class="pre">linkonce</span></tt> linkage does not actually allow the optimizer to
+inline the body of this function into callers because it doesn’t
+know if this definition of the function is the definitive definition
+within the program or whether it will be overridden by a stronger
+definition. To enable inlining and other optimizations, use
+“<tt class="docutils literal"><span class="pre">linkonce_odr</span></tt>” linkage.</dd>
+<dt><tt class="docutils literal"><span class="pre">weak</span></tt></dt>
+<dd>“<tt class="docutils literal"><span class="pre">weak</span></tt>” linkage has the same merging semantics as <tt class="docutils literal"><span class="pre">linkonce</span></tt>
+linkage, except that unreferenced globals with <tt class="docutils literal"><span class="pre">weak</span></tt> linkage may
+not be discarded. This is used for globals that are declared “weak”
+in C source code.</dd>
+<dt><tt class="docutils literal"><span class="pre">common</span></tt></dt>
+<dd>“<tt class="docutils literal"><span class="pre">common</span></tt>” linkage is most similar to “<tt class="docutils literal"><span class="pre">weak</span></tt>” linkage, but they
+are used for tentative definitions in C, such as “<tt class="docutils literal"><span class="pre">int</span> <span class="pre">X;</span></tt>” at
+global scope. Symbols with “<tt class="docutils literal"><span class="pre">common</span></tt>” linkage are merged in the
+same way as <tt class="docutils literal"><span class="pre">weak</span> <span class="pre">symbols</span></tt>, and they may not be deleted if
+unreferenced. <tt class="docutils literal"><span class="pre">common</span></tt> symbols may not have an explicit section,
+must have a zero initializer, and may not be marked
+‘<a class="reference internal" href="#globalvars"><em>constant</em></a>‘. Functions and aliases may not have
+common linkage.</dd>
+</dl>
+<dl class="docutils" id="linkage-appending">
+<dt><tt class="docutils literal"><span class="pre">appending</span></tt></dt>
+<dd><p class="first">“<tt class="docutils literal"><span class="pre">appending</span></tt>” linkage may only be applied to global variables of
+pointer to array type. When two global variables with appending
+linkage are linked together, the two global arrays are appended
+together. This is the LLVM, typesafe, equivalent of having the
+system linker append together “sections” with identical names when
+.o files are linked.</p>
+<p class="last">Unfortunately this doesn’t correspond to any feature in .o files, so it
+can only be used for variables like <tt class="docutils literal"><span class="pre">llvm.global_ctors</span></tt> which llvm
+interprets specially.</p>
+</dd>
+<dt><tt class="docutils literal"><span class="pre">extern_weak</span></tt></dt>
+<dd>The semantics of this linkage follow the ELF object file model: the
+symbol is weak until linked, if not linked, the symbol becomes null
+instead of being an undefined reference.</dd>
+<dt><tt class="docutils literal"><span class="pre">linkonce_odr</span></tt>, <tt class="docutils literal"><span class="pre">weak_odr</span></tt></dt>
+<dd>Some languages allow differing globals to be merged, such as two
+functions with different semantics. Other languages, such as
+<tt class="docutils literal"><span class="pre">C++</span></tt>, ensure that only equivalent globals are ever merged (the
+“one definition rule” — “ODR”). Such languages can use the
+<tt class="docutils literal"><span class="pre">linkonce_odr</span></tt> and <tt class="docutils literal"><span class="pre">weak_odr</span></tt> linkage types to indicate that the
+global will only be merged with equivalent globals. These linkage
+types are otherwise the same as their non-<tt class="docutils literal"><span class="pre">odr</span></tt> versions.</dd>
+<dt><tt class="docutils literal"><span class="pre">external</span></tt></dt>
+<dd>If none of the above identifiers are used, the global is externally
+visible, meaning that it participates in linkage and can be used to
+resolve external symbol references.</dd>
+</dl>
+<p>It is illegal for a function <em>declaration</em> to have any linkage type
+other than <tt class="docutils literal"><span class="pre">external</span></tt> or <tt class="docutils literal"><span class="pre">extern_weak</span></tt>.</p>
+</div>
+<div class="section" id="calling-conventions">
+<span id="callingconv"></span><h3><a class="toc-backref" href="#id820">Calling Conventions</a><a class="headerlink" href="#calling-conventions" title="Permalink to this headline">¶</a></h3>
+<p>LLVM <a class="reference internal" href="#functionstructure"><em>functions</em></a>, <a class="reference internal" href="#i-call"><em>calls</em></a> and
+<a class="reference internal" href="#i-invoke"><em>invokes</em></a> can all have an optional calling convention
+specified for the call. The calling convention of any pair of dynamic
+caller/callee must match, or the behavior of the program is undefined.
+The following calling conventions are supported by LLVM, and more may be
+added in the future:</p>
+<dl class="docutils">
+<dt>“<tt class="docutils literal"><span class="pre">ccc</span></tt>” - The C calling convention</dt>
+<dd>This calling convention (the default if no other calling convention
+is specified) matches the target C calling conventions. This calling
+convention supports varargs function calls and tolerates some
+mismatch in the declared prototype and implemented declaration of
+the function (as does normal C).</dd>
+<dt>“<tt class="docutils literal"><span class="pre">fastcc</span></tt>” - The fast calling convention</dt>
+<dd>This calling convention attempts to make calls as fast as possible
+(e.g. by passing things in registers). This calling convention
+allows the target to use whatever tricks it wants to produce fast
+code for the target, without having to conform to an externally
+specified ABI (Application Binary Interface). <a class="reference external" href="CodeGenerator.html#id80">Tail calls can only
+be optimized when this, the GHC or the HiPE convention is
+used.</a> This calling convention does not
+support varargs and requires the prototype of all callees to exactly
+match the prototype of the function definition.</dd>
+<dt>“<tt class="docutils literal"><span class="pre">coldcc</span></tt>” - The cold calling convention</dt>
+<dd>This calling convention attempts to make code in the caller as
+efficient as possible under the assumption that the call is not
+commonly executed. As such, these calls often preserve all registers
+so that the call does not break any live ranges in the caller side.
+This calling convention does not support varargs and requires the
+prototype of all callees to exactly match the prototype of the
+function definition. Furthermore the inliner doesn’t consider such function
+calls for inlining.</dd>
+<dt>“<tt class="docutils literal"><span class="pre">cc</span> <span class="pre">10</span></tt>” - GHC convention</dt>
+<dd><p class="first">This calling convention has been implemented specifically for use by
+the <a class="reference external" href="http://www.haskell.org/ghc">Glasgow Haskell Compiler (GHC)</a>.
+It passes everything in registers, going to extremes to achieve this
+by disabling callee save registers. This calling convention should
+not be used lightly but only for specific situations such as an
+alternative to the <em>register pinning</em> performance technique often
+used when implementing functional programming languages. At the
+moment only X86 supports this convention and it has the following
+limitations:</p>
+<ul class="simple">
+<li>On <em>X86-32</em> only supports up to 4 bit type parameters. No
+floating point types are supported.</li>
+<li>On <em>X86-64</em> only supports up to 10 bit type parameters and 6
+floating point parameters.</li>
+</ul>
+<p class="last">This calling convention supports <a class="reference external" href="CodeGenerator.html#id80">tail call
+optimization</a> but requires both the
+caller and callee are using it.</p>
+</dd>
+<dt>“<tt class="docutils literal"><span class="pre">cc</span> <span class="pre">11</span></tt>” - The HiPE calling convention</dt>
+<dd>This calling convention has been implemented specifically for use by
+the <a class="reference external" href="http://www.it.uu.se/research/group/hipe/">High-Performance Erlang
+(HiPE)</a> compiler, <em>the</em>
+native code compiler of the <a class="reference external" href="http://www.erlang.org/download.shtml">Ericsson’s Open Source Erlang/OTP
+system</a>. It uses more
+registers for argument passing than the ordinary C calling
+convention and defines no callee-saved registers. The calling
+convention properly supports <a class="reference external" href="CodeGenerator.html#id80">tail call
+optimization</a> but requires that both the
+caller and the callee use it. It uses a <em>register pinning</em>
+mechanism, similar to GHC’s convention, for keeping frequently
+accessed runtime components pinned to specific hardware registers.
+At the moment only X86 supports this convention (both 32 and 64
+bit).</dd>
+<dt>“<tt class="docutils literal"><span class="pre">webkit_jscc</span></tt>” - WebKit’s JavaScript calling convention</dt>
+<dd>This calling convention has been implemented for <a class="reference external" href="https://trac.webkit.org/wiki/FTLJIT">WebKit FTL JIT</a>. It passes arguments on the
+stack right to left (as cdecl does), and returns a value in the
+platform’s customary return register.</dd>
+<dt>“<tt class="docutils literal"><span class="pre">anyregcc</span></tt>” - Dynamic calling convention for code patching</dt>
+<dd>This is a special convention that supports patching an arbitrary code
+sequence in place of a call site. This convention forces the call
+arguments into registers but allows them to be dynamically
+allocated. This can currently only be used with calls to
+llvm.experimental.patchpoint because only this intrinsic records
+the location of its arguments in a side table. See <a class="reference internal" href="StackMaps.html"><em>Stack maps and patch points in LLVM</em></a>.</dd>
+<dt>“<tt class="docutils literal"><span class="pre">preserve_mostcc</span></tt>” - The <cite>PreserveMost</cite> calling convention</dt>
+<dd><p class="first">This calling convention attempts to make the code in the caller as
+unintrusive as possible. This convention behaves identically to the <cite>C</cite>
+calling convention on how arguments and return values are passed, but it
+uses a different set of caller/callee-saved registers. This alleviates the
+burden of saving and recovering a large register set before and after the
+call in the caller. If the arguments are passed in callee-saved registers,
+then they will be preserved by the callee across the call. This doesn’t
+apply for values returned in callee-saved registers.</p>
+<ul class="simple">
+<li>On X86-64 the callee preserves all general purpose registers, except for
+R11. R11 can be used as a scratch register. Floating-point registers
+(XMMs/YMMs) are not preserved and need to be saved by the caller.</li>
+</ul>
+<p>The idea behind this convention is to support calls to runtime functions
+that have a hot path and a cold path. The hot path is usually a small piece
+of code that doesn’t use many registers. The cold path might need to call out to
+another function and therefore only needs to preserve the caller-saved
+registers, which haven’t already been saved by the caller. The
+<cite>PreserveMost</cite> calling convention is very similar to the <cite>cold</cite> calling
+convention in terms of caller/callee-saved registers, but they are used for
+different types of function calls. <cite>coldcc</cite> is for function calls that are
+rarely executed, whereas <cite>preserve_mostcc</cite> function calls are intended to be
+on the hot path and definitely executed a lot. Furthermore <cite>preserve_mostcc</cite>
+doesn’t prevent the inliner from inlining the function call.</p>
+<p class="last">This calling convention will be used by a future version of the ObjectiveC
+runtime and should therefore still be considered experimental at this time.
+Although this convention was created to optimize certain runtime calls to
+the ObjectiveC runtime, it is not limited to this runtime and might be used
+by other runtimes in the future too. The current implementation only
+supports X86-64, but the intention is to support more architectures in the
+future.</p>
+</dd>
+<dt>“<tt class="docutils literal"><span class="pre">preserve_allcc</span></tt>” - The <cite>PreserveAll</cite> calling convention</dt>
+<dd><p class="first">This calling convention attempts to make the code in the caller even less
+intrusive than the <cite>PreserveMost</cite> calling convention. This calling
+convention also behaves identical to the <cite>C</cite> calling convention on how
+arguments and return values are passed, but it uses a different set of
+caller/callee-saved registers. This removes the burden of saving and
+recovering a large register set before and after the call in the caller. If
+the arguments are passed in callee-saved registers, then they will be
+preserved by the callee across the call. This doesn’t apply for values
+returned in callee-saved registers.</p>
+<ul class="simple">
+<li>On X86-64 the callee preserves all general purpose registers, except for
+R11. R11 can be used as a scratch register. Furthermore it also preserves
+all floating-point registers (XMMs/YMMs).</li>
+</ul>
+<p>The idea behind this convention is to support calls to runtime functions
+that don’t need to call out to any other functions.</p>
+<p class="last">This calling convention, like the <cite>PreserveMost</cite> calling convention, will be
+used by a future version of the ObjectiveC runtime and should be considered
+experimental at this time.</p>
+</dd>
+<dt>“<tt class="docutils literal"><span class="pre">cxx_fast_tlscc</span></tt>” - The <cite>CXX_FAST_TLS</cite> calling convention for access functions</dt>
+<dd><p class="first">Clang generates an access function to access C++-style TLS. The access
+function generally has an entry block, an exit block and an initialization
+block that is run at the first time. The entry and exit blocks can access
+a few TLS IR variables, each access will be lowered to a platform-specific
+sequence.</p>
+<p>This calling convention aims to minimize overhead in the caller by
+preserving as many registers as possible (all the registers that are
+perserved on the fast path, composed of the entry and exit blocks).</p>
+<p>This calling convention behaves identical to the <cite>C</cite> calling convention on
+how arguments and return values are passed, but it uses a different set of
+caller/callee-saved registers.</p>
+<p>Given that each platform has its own lowering sequence, hence its own set
+of preserved registers, we can’t use the existing <cite>PreserveMost</cite>.</p>
+<ul class="last simple">
+<li>On X86-64 the callee preserves all general purpose registers, except for
+RDI and RAX.</li>
+</ul>
+</dd>
+<dt>“<tt class="docutils literal"><span class="pre">swiftcc</span></tt>” - This calling convention is used for Swift language.</dt>
+<dd><ul class="first last simple">
+<li>On X86-64 RCX and R8 are available for additional integer returns, and
+XMM2 and XMM3 are available for additional FP/vector returns.</li>
+<li>On iOS platforms, we use AAPCS-VFP calling convention.</li>
+</ul>
+</dd>
+<dt>“<tt class="docutils literal"><span class="pre">cc</span> <span class="pre"><n></span></tt>” - Numbered convention</dt>
+<dd>Any calling convention may be specified by number, allowing
+target-specific calling conventions to be used. Target specific
+calling conventions start at 64.</dd>
+</dl>
+<p>More calling conventions can be added/defined on an as-needed basis, to
+support Pascal conventions or any other well-known target-independent
+convention.</p>
+</div>
+<div class="section" id="visibility-styles">
+<span id="visibilitystyles"></span><h3><a class="toc-backref" href="#id821">Visibility Styles</a><a class="headerlink" href="#visibility-styles" title="Permalink to this headline">¶</a></h3>
+<p>All Global Variables and Functions have one of the following visibility
+styles:</p>
+<dl class="docutils">
+<dt>“<tt class="docutils literal"><span class="pre">default</span></tt>” - Default style</dt>
+<dd>On targets that use the ELF object file format, default visibility
+means that the declaration is visible to other modules and, in
+shared libraries, means that the declared entity may be overridden.
+On Darwin, default visibility means that the declaration is visible
+to other modules. Default visibility corresponds to “external
+linkage” in the language.</dd>
+<dt>“<tt class="docutils literal"><span class="pre">hidden</span></tt>” - Hidden style</dt>
+<dd>Two declarations of an object with hidden visibility refer to the
+same object if they are in the same shared object. Usually, hidden
+visibility indicates that the symbol will not be placed into the
+dynamic symbol table, so no other module (executable or shared
+library) can reference it directly.</dd>
+<dt>“<tt class="docutils literal"><span class="pre">protected</span></tt>” - Protected style</dt>
+<dd>On ELF, protected visibility indicates that the symbol will be
+placed in the dynamic symbol table, but that references within the
+defining module will bind to the local symbol. That is, the symbol
+cannot be overridden by another module.</dd>
+</dl>
+<p>A symbol with <tt class="docutils literal"><span class="pre">internal</span></tt> or <tt class="docutils literal"><span class="pre">private</span></tt> linkage must have <tt class="docutils literal"><span class="pre">default</span></tt>
+visibility.</p>
+</div>
+<div class="section" id="dll-storage-classes">
+<span id="dllstorageclass"></span><h3><a class="toc-backref" href="#id822">DLL Storage Classes</a><a class="headerlink" href="#dll-storage-classes" title="Permalink to this headline">¶</a></h3>
+<p>All Global Variables, Functions and Aliases can have one of the following
+DLL storage class:</p>
+<dl class="docutils">
+<dt><tt class="docutils literal"><span class="pre">dllimport</span></tt></dt>
+<dd>“<tt class="docutils literal"><span class="pre">dllimport</span></tt>” causes the compiler to reference a function or variable via
+a global pointer to a pointer that is set up by the DLL exporting the
+symbol. On Microsoft Windows targets, the pointer name is formed by
+combining <tt class="docutils literal"><span class="pre">__imp_</span></tt> and the function or variable name.</dd>
+<dt><tt class="docutils literal"><span class="pre">dllexport</span></tt></dt>
+<dd>“<tt class="docutils literal"><span class="pre">dllexport</span></tt>” causes the compiler to provide a global pointer to a pointer
+in a DLL, so that it can be referenced with the <tt class="docutils literal"><span class="pre">dllimport</span></tt> attribute. On
+Microsoft Windows targets, the pointer name is formed by combining
+<tt class="docutils literal"><span class="pre">__imp_</span></tt> and the function or variable name. Since this storage class
+exists for defining a dll interface, the compiler, assembler and linker know
+it is externally referenced and must refrain from deleting the symbol.</dd>
+</dl>
+</div>
+<div class="section" id="thread-local-storage-models">
+<span id="tls-model"></span><h3><a class="toc-backref" href="#id823">Thread Local Storage Models</a><a class="headerlink" href="#thread-local-storage-models" title="Permalink to this headline">¶</a></h3>
+<p>A variable may be defined as <tt class="docutils literal"><span class="pre">thread_local</span></tt>, which means that it will
+not be shared by threads (each thread will have a separated copy of the
+variable). Not all targets support thread-local variables. Optionally, a
+TLS model may be specified:</p>
+<dl class="docutils">
+<dt><tt class="docutils literal"><span class="pre">localdynamic</span></tt></dt>
+<dd>For variables that are only used within the current shared library.</dd>
+<dt><tt class="docutils literal"><span class="pre">initialexec</span></tt></dt>
+<dd>For variables in modules that will not be loaded dynamically.</dd>
+<dt><tt class="docutils literal"><span class="pre">localexec</span></tt></dt>
+<dd>For variables defined in the executable and only used within it.</dd>
+</dl>
+<p>If no explicit model is given, the “general dynamic” model is used.</p>
+<p>The models correspond to the ELF TLS models; see <a class="reference external" href="http://people.redhat.com/drepper/tls.pdf">ELF Handling For
+Thread-Local Storage</a> for
+more information on under which circumstances the different models may
+be used. The target may choose a different TLS model if the specified
+model is not supported, or if a better choice of model can be made.</p>
+<p>A model can also be specified in an alias, but then it only governs how
+the alias is accessed. It will not have any effect in the aliasee.</p>
+<p>For platforms without linker support of ELF TLS model, the -femulated-tls
+flag can be used to generate GCC compatible emulated TLS code.</p>
+</div>
+<div class="section" id="runtime-preemption-specifiers">
+<span id="runtime-preemption-model"></span><h3><a class="toc-backref" href="#id824">Runtime Preemption Specifiers</a><a class="headerlink" href="#runtime-preemption-specifiers" title="Permalink to this headline">¶</a></h3>
+<p>Global variables, functions and aliases may have an optional runtime preemption
+specifier. If a preemption specifier isn’t given explicitly, then a
+symbol is assumed to be <tt class="docutils literal"><span class="pre">dso_preemptable</span></tt>.</p>
+<dl class="docutils">
+<dt><tt class="docutils literal"><span class="pre">dso_preemptable</span></tt></dt>
+<dd>Indicates that the function or variable may be replaced by a symbol from
+outside the linkage unit at runtime.</dd>
+<dt><tt class="docutils literal"><span class="pre">dso_local</span></tt></dt>
+<dd>The compiler may assume that a function or variable marked as <tt class="docutils literal"><span class="pre">dso_local</span></tt>
+will resolve to a symbol within the same linkage unit. Direct access will
+be generated even if the definition is not within this compilation unit.</dd>
+</dl>
+</div>
+<div class="section" id="structure-types">
+<span id="namedtypes"></span><h3><a class="toc-backref" href="#id825">Structure Types</a><a class="headerlink" href="#structure-types" title="Permalink to this headline">¶</a></h3>
+<p>LLVM IR allows you to specify both “identified” and “literal” <a class="reference internal" href="#t-struct"><em>structure
+types</em></a>. Literal types are uniqued structurally, but identified types
+are never uniqued. An <a class="reference internal" href="#t-opaque"><em>opaque structural type</em></a> can also be used
+to forward declare a type that is not yet available.</p>
+<p>An example of an identified structure specification is:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%mytype</span> <span class="p">=</span> <span class="k">type</span> <span class="p">{</span> <span class="nv">%mytype</span><span class="p">*,</span> <span class="k">i32</span> <span class="p">}</span>
+</pre></div>
+</div>
+<p>Prior to the LLVM 3.0 release, identified types were structurally uniqued. Only
+literal types are uniqued in recent versions of LLVM.</p>
+</div>
+<div class="section" id="non-integral-pointer-type">
+<span id="nointptrtype"></span><h3><a class="toc-backref" href="#id826">Non-Integral Pointer Type</a><a class="headerlink" href="#non-integral-pointer-type" title="Permalink to this headline">¶</a></h3>
+<p>Note: non-integral pointer types are a work in progress, and they should be
+considered experimental at this time.</p>
+<p>LLVM IR optionally allows the frontend to denote pointers in certain address
+spaces as “non-integral” via the <a class="reference internal" href="#langref-datalayout"><em>datalayout string</em></a>.
+Non-integral pointer types represent pointers that have an <em>unspecified</em> bitwise
+representation; that is, the integral representation may be target dependent or
+unstable (not backed by a fixed integer).</p>
+<p><tt class="docutils literal"><span class="pre">inttoptr</span></tt> instructions converting integers to non-integral pointer types are
+ill-typed, and so are <tt class="docutils literal"><span class="pre">ptrtoint</span></tt> instructions converting values of
+non-integral pointer types to integers.  Vector versions of said instructions
+are ill-typed as well.</p>
+</div>
+<div class="section" id="global-variables">
+<span id="globalvars"></span><h3><a class="toc-backref" href="#id827">Global Variables</a><a class="headerlink" href="#global-variables" title="Permalink to this headline">¶</a></h3>
+<p>Global variables define regions of memory allocated at compilation time
+instead of run-time.</p>
+<p>Global variable definitions must be initialized.</p>
+<p>Global variables in other translation units can also be declared, in which
+case they don’t have an initializer.</p>
+<p>Either global variable definitions or declarations may have an explicit section
+to be placed in and may have an optional explicit alignment specified. If there
+is a mismatch between the explicit or inferred section information for the
+variable declaration and its definition the resulting behavior is undefined.</p>
+<p>A variable may be defined as a global <tt class="docutils literal"><span class="pre">constant</span></tt>, which indicates that
+the contents of the variable will <strong>never</strong> be modified (enabling better
+optimization, allowing the global data to be placed in the read-only
+section of an executable, etc). Note that variables that need runtime
+initialization cannot be marked <tt class="docutils literal"><span class="pre">constant</span></tt> as there is a store to the
+variable.</p>
+<p>LLVM explicitly allows <em>declarations</em> of global variables to be marked
+constant, even if the final definition of the global is not. This
+capability can be used to enable slightly better optimization of the
+program, but requires the language definition to guarantee that
+optimizations based on the ‘constantness’ are valid for the translation
+units that do not include the definition.</p>
+<p>As SSA values, global variables define pointer values that are in scope
+(i.e. they dominate) all basic blocks in the program. Global variables
+always define a pointer to their “content” type because they describe a
+region of memory, and all memory objects in LLVM are accessed through
+pointers.</p>
+<p>Global variables can be marked with <tt class="docutils literal"><span class="pre">unnamed_addr</span></tt> which indicates
+that the address is not significant, only the content. Constants marked
+like this can be merged with other constants if they have the same
+initializer. Note that a constant with significant address <em>can</em> be
+merged with a <tt class="docutils literal"><span class="pre">unnamed_addr</span></tt> constant, the result being a constant
+whose address is significant.</p>
+<p>If the <tt class="docutils literal"><span class="pre">local_unnamed_addr</span></tt> attribute is given, the address is known to
+not be significant within the module.</p>
+<p>A global variable may be declared to reside in a target-specific
+numbered address space. For targets that support them, address spaces
+may affect how optimizations are performed and/or what target
+instructions are used to access the variable. The default address space
+is zero. The address space qualifier must precede any other attributes.</p>
+<p>LLVM allows an explicit section to be specified for globals. If the
+target supports it, it will emit globals to the section specified.
+Additionally, the global can placed in a comdat if the target has the necessary
+support.</p>
+<p>External declarations may have an explicit section specified. Section
+information is retained in LLVM IR for targets that make use of this
+information. Attaching section information to an external declaration is an
+assertion that its definition is located in the specified section. If the
+definition is located in a different section, the behavior is undefined.</p>
+<p>By default, global initializers are optimized by assuming that global
+variables defined within the module are not modified from their
+initial values before the start of the global initializer. This is
+true even for variables potentially accessible from outside the
+module, including those with external linkage or appearing in
+<tt class="docutils literal"><span class="pre">@llvm.used</span></tt> or dllexported variables. This assumption may be suppressed
+by marking the variable with <tt class="docutils literal"><span class="pre">externally_initialized</span></tt>.</p>
+<p>An explicit alignment may be specified for a global, which must be a
+power of 2. If not present, or if the alignment is set to zero, the
+alignment of the global is set by the target to whatever it feels
+convenient. If an explicit alignment is specified, the global is forced
+to have exactly that alignment. Targets and optimizers are not allowed
+to over-align the global if the global has an assigned section. In this
+case, the extra alignment could be observable: for example, code could
+assume that the globals are densely packed in their section and try to
+iterate over them as an array, alignment padding would break this
+iteration. The maximum alignment is <tt class="docutils literal"><span class="pre">1</span> <span class="pre"><<</span> <span class="pre">29</span></tt>.</p>
+<p>Globals can also have a <a class="reference internal" href="#dllstorageclass"><em>DLL storage class</em></a>,
+an optional <a class="reference internal" href="#runtime-preemption-model"><em>runtime preemption specifier</em></a>,
+an optional <a class="reference internal" href="#glattrs"><em>global attributes</em></a> and
+an optional list of attached <a class="reference internal" href="#metadata"><em>metadata</em></a>.</p>
+<p>Variables and aliases can have a
+<a class="reference internal" href="#tls-model"><em>Thread Local Storage Model</em></a>.</p>
+<p>Syntax:</p>
+<div class="highlight-python"><pre>@<GlobalVarName> = [Linkage] [PreemptionSpecifier] [Visibility]
+                   [DLLStorageClass] [ThreadLocal]
+                   [(unnamed_addr|local_unnamed_addr)] [AddrSpace]
+                   [ExternallyInitialized]
+                   <global | constant> <Type> [<InitializerConstant>]
+                   [, section "name"] [, comdat [($name)]]
+                   [, align <Alignment>] (, !name !N)*</pre>
+</div>
+<p>For example, the following defines a global in a numbered address space
+with an initializer, section, and alignment:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="vg">@G</span> <span class="p">=</span> <span class="k">addrspace</span><span class="p">(</span><span class="m">5</span><span class="p">)</span> <span class="k">constant</span> <span class="kt">float</span> <span class="m">1.0</span><span class="p">,</span> <span class="k">section</span> <span class="s">"foo"</span><span class="p">,</span> <span class="k">align</span> <span class="m">4</span>
+</pre></div>
+</div>
+<p>The following example just declares a global variable</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="vg">@G</span> <span class="p">=</span> <span class="k">external</span> <span class="k">global</span> <span class="k">i32</span>
+</pre></div>
+</div>
+<p>The following example defines a thread-local global with the
+<tt class="docutils literal"><span class="pre">initialexec</span></tt> TLS model:</p>
+<div class="highlight-llvm"><pre>@G = thread_local(initialexec) global i32 0, align 4</pre>
+</div>
+</div>
+<div class="section" id="functions">
+<span id="functionstructure"></span><h3><a class="toc-backref" href="#id828">Functions</a><a class="headerlink" href="#functions" title="Permalink to this headline">¶</a></h3>
+<p>LLVM function definitions consist of the “<tt class="docutils literal"><span class="pre">define</span></tt>” keyword, an
+optional <a class="reference internal" href="#linkage"><em>linkage type</em></a>, an optional <a class="reference internal" href="#runtime-preemption-model"><em>runtime preemption
+specifier</em></a>,  an optional <a class="reference internal" href="BitCodeFormat.html#visibility"><em>visibility
+style</em></a>, an optional <a class="reference internal" href="#dllstorageclass"><em>DLL storage class</em></a>,
+an optional <a class="reference internal" href="#callingconv"><em>calling convention</em></a>,
+an optional <tt class="docutils literal"><span class="pre">unnamed_addr</span></tt> attribute, a return type, an optional
+<a class="reference internal" href="#paramattrs"><em>parameter attribute</em></a> for the return type, a function
+name, a (possibly empty) argument list (each with optional <a class="reference internal" href="#paramattrs"><em>parameter
+attributes</em></a>), optional <a class="reference internal" href="#fnattrs"><em>function attributes</em></a>,
+an optional section, an optional alignment,
+an optional <a class="reference internal" href="#langref-comdats"><em>comdat</em></a>,
+an optional <a class="reference internal" href="#gc"><em>garbage collector name</em></a>, an optional <a class="reference internal" href="#prefixdata"><em>prefix</em></a>,
+an optional <a class="reference internal" href="#prologuedata"><em>prologue</em></a>,
+an optional <a class="reference internal" href="#personalityfn"><em>personality</em></a>,
+an optional list of attached <a class="reference internal" href="#metadata"><em>metadata</em></a>,
+an opening curly brace, a list of basic blocks, and a closing curly brace.</p>
+<p>LLVM function declarations consist of the “<tt class="docutils literal"><span class="pre">declare</span></tt>” keyword, an
+optional <a class="reference internal" href="#linkage"><em>linkage type</em></a>, an optional <a class="reference internal" href="BitCodeFormat.html#visibility"><em>visibility style</em></a>, an optional <a class="reference internal" href="#dllstorageclass"><em>DLL storage class</em></a>, an
+optional <a class="reference internal" href="#callingconv"><em>calling convention</em></a>, an optional <tt class="docutils literal"><span class="pre">unnamed_addr</span></tt>
+or <tt class="docutils literal"><span class="pre">local_unnamed_addr</span></tt> attribute, a return type, an optional <a class="reference internal" href="#paramattrs"><em>parameter
+attribute</em></a> for the return type, a function name, a possibly
+empty list of arguments, an optional alignment, an optional <a class="reference internal" href="#gc"><em>garbage
+collector name</em></a>, an optional <a class="reference internal" href="#prefixdata"><em>prefix</em></a>, and an optional
+<a class="reference internal" href="#prologuedata"><em>prologue</em></a>.</p>
+<p>A function definition contains a list of basic blocks, forming the CFG (Control
+Flow Graph) for the function. Each basic block may optionally start with a label
+(giving the basic block a symbol table entry), contains a list of instructions,
+and ends with a <a class="reference internal" href="#terminators"><em>terminator</em></a> instruction (such as a branch or
+function return). If an explicit label is not provided, a block is assigned an
+implicit numbered label, using the next value from the same counter as used for
+unnamed temporaries (<a class="reference internal" href="#identifiers"><em>see above</em></a>). For example, if a function
+entry block does not have an explicit label, it will be assigned label “%0”,
+then the first unnamed temporary in that block will be “%1”, etc.</p>
+<p>The first basic block in a function is special in two ways: it is
+immediately executed on entrance to the function, and it is not allowed
+to have predecessor basic blocks (i.e. there can not be any branches to
+the entry block of a function). Because the block can have no
+predecessors, it also cannot have any <a class="reference internal" href="#i-phi"><em>PHI nodes</em></a>.</p>
+<p>LLVM allows an explicit section to be specified for functions. If the
+target supports it, it will emit functions to the section specified.
+Additionally, the function can be placed in a COMDAT.</p>
+<p>An explicit alignment may be specified for a function. If not present,
+or if the alignment is set to zero, the alignment of the function is set
+by the target to whatever it feels convenient. If an explicit alignment
+is specified, the function is forced to have at least that much
+alignment. All alignments must be a power of 2.</p>
+<p>If the <tt class="docutils literal"><span class="pre">unnamed_addr</span></tt> attribute is given, the address is known to not
+be significant and two identical functions can be merged.</p>
+<p>If the <tt class="docutils literal"><span class="pre">local_unnamed_addr</span></tt> attribute is given, the address is known to
+not be significant within the module.</p>
+<p>Syntax:</p>
+<div class="highlight-python"><pre>define [linkage] [PreemptionSpecifier] [visibility] [DLLStorageClass]
+       [cconv] [ret attrs]
+       <ResultType> @<FunctionName> ([argument list])
+       [(unnamed_addr|local_unnamed_addr)] [fn Attrs] [section "name"]
+       [comdat [($name)]] [align N] [gc] [prefix Constant]
+       [prologue Constant] [personality Constant] (!name !N)* { ... }</pre>
+</div>
+<p>The argument list is a comma separated sequence of arguments where each
+argument is of the following form:</p>
+<p>Syntax:</p>
+<div class="highlight-python"><pre><type> [parameter Attrs] [name]</pre>
+</div>
+</div>
+<div class="section" id="aliases">
+<span id="langref-aliases"></span><h3><a class="toc-backref" href="#id829">Aliases</a><a class="headerlink" href="#aliases" title="Permalink to this headline">¶</a></h3>
+<p>Aliases, unlike function or variables, don’t create any new data. They
+are just a new symbol and metadata for an existing position.</p>
+<p>Aliases have a name and an aliasee that is either a global value or a
+constant expression.</p>
+<p>Aliases may have an optional <a class="reference internal" href="#linkage"><em>linkage type</em></a>, an optional
+<a class="reference internal" href="#runtime-preemption-model"><em>runtime preemption specifier</em></a>, an optional
+<a class="reference internal" href="BitCodeFormat.html#visibility"><em>visibility style</em></a>, an optional <a class="reference internal" href="#dllstorageclass"><em>DLL storage class</em></a> and an optional <a class="reference internal" href="#tls-model"><em>tls model</em></a>.</p>
+<p>Syntax:</p>
+<div class="highlight-python"><pre>@<Name> = [Linkage] [PreemptionSpecifier] [Visibility] [DLLStorageClass] [ThreadLocal] [(unnamed_addr|local_unnamed_addr)] alias <AliaseeTy>, <AliaseeTy>* @<Aliasee></pre>
+</div>
+<p>The linkage must be one of <tt class="docutils literal"><span class="pre">private</span></tt>, <tt class="docutils literal"><span class="pre">internal</span></tt>, <tt class="docutils literal"><span class="pre">linkonce</span></tt>, <tt class="docutils literal"><span class="pre">weak</span></tt>,
+<tt class="docutils literal"><span class="pre">linkonce_odr</span></tt>, <tt class="docutils literal"><span class="pre">weak_odr</span></tt>, <tt class="docutils literal"><span class="pre">external</span></tt>. Note that some system linkers
+might not correctly handle dropping a weak symbol that is aliased.</p>
+<p>Aliases that are not <tt class="docutils literal"><span class="pre">unnamed_addr</span></tt> are guaranteed to have the same address as
+the aliasee expression. <tt class="docutils literal"><span class="pre">unnamed_addr</span></tt> ones are only guaranteed to point
+to the same content.</p>
+<p>If the <tt class="docutils literal"><span class="pre">local_unnamed_addr</span></tt> attribute is given, the address is known to
+not be significant within the module.</p>
+<p>Since aliases are only a second name, some restrictions apply, of which
+some can only be checked when producing an object file:</p>
+<ul class="simple">
+<li>The expression defining the aliasee must be computable at assembly
+time. Since it is just a name, no relocations can be used.</li>
+<li>No alias in the expression can be weak as the possibility of the
+intermediate alias being overridden cannot be represented in an
+object file.</li>
+<li>No global value in the expression can be a declaration, since that
+would require a relocation, which is not possible.</li>
+</ul>
+</div>
+<div class="section" id="ifuncs">
+<span id="langref-ifunc"></span><h3><a class="toc-backref" href="#id830">IFuncs</a><a class="headerlink" href="#ifuncs" title="Permalink to this headline">¶</a></h3>
+<p>IFuncs, like as aliases, don’t create any new data or func. They are just a new
+symbol that dynamic linker resolves at runtime by calling a resolver function.</p>
+<p>IFuncs have a name and a resolver that is a function called by dynamic linker
+that returns address of another function associated with the name.</p>
+<p>IFunc may have an optional <a class="reference internal" href="#linkage"><em>linkage type</em></a> and an optional
+<a class="reference internal" href="BitCodeFormat.html#visibility"><em>visibility style</em></a>.</p>
+<p>Syntax:</p>
+<div class="highlight-python"><pre>@<Name> = [Linkage] [Visibility] ifunc <IFuncTy>, <ResolverTy>* @<Resolver></pre>
+</div>
+</div>
+<div class="section" id="comdats">
+<span id="langref-comdats"></span><h3><a class="toc-backref" href="#id831">Comdats</a><a class="headerlink" href="#comdats" title="Permalink to this headline">¶</a></h3>
+<p>Comdat IR provides access to COFF and ELF object file COMDAT functionality.</p>
+<p>Comdats have a name which represents the COMDAT key. All global objects that
+specify this key will only end up in the final object file if the linker chooses
+that key over some other key. Aliases are placed in the same COMDAT that their
+aliasee computes to, if any.</p>
+<p>Comdats have a selection kind to provide input on how the linker should
+choose between keys in two different object files.</p>
+<p>Syntax:</p>
+<div class="highlight-python"><pre>$<Name> = comdat SelectionKind</pre>
+</div>
+<p>The selection kind must be one of the following:</p>
+<dl class="docutils">
+<dt><tt class="docutils literal"><span class="pre">any</span></tt></dt>
+<dd>The linker may choose any COMDAT key, the choice is arbitrary.</dd>
+<dt><tt class="docutils literal"><span class="pre">exactmatch</span></tt></dt>
+<dd>The linker may choose any COMDAT key but the sections must contain the
+same data.</dd>
+<dt><tt class="docutils literal"><span class="pre">largest</span></tt></dt>
+<dd>The linker will choose the section containing the largest COMDAT key.</dd>
+<dt><tt class="docutils literal"><span class="pre">noduplicates</span></tt></dt>
+<dd>The linker requires that only section with this COMDAT key exist.</dd>
+<dt><tt class="docutils literal"><span class="pre">samesize</span></tt></dt>
+<dd>The linker may choose any COMDAT key but the sections must contain the
+same amount of data.</dd>
+</dl>
+<p>Note that the Mach-O platform doesn’t support COMDATs and ELF only supports
+<tt class="docutils literal"><span class="pre">any</span></tt> as a selection kind.</p>
+<p>Here is an example of a COMDAT group where a function will only be selected if
+the COMDAT key’s section is the largest:</p>
+<div class="highlight-text"><div class="highlight"><pre>$foo = comdat largest
+ at foo = global i32 2, comdat($foo)
+
+define void @bar() comdat($foo) {
+  ret void
+}
+</pre></div>
+</div>
+<p>As a syntactic sugar the <tt class="docutils literal"><span class="pre">$name</span></tt> can be omitted if the name is the same as
+the global name:</p>
+<div class="highlight-text"><div class="highlight"><pre>$foo = comdat any
+ at foo = global i32 2, comdat
+</pre></div>
+</div>
+<p>In a COFF object file, this will create a COMDAT section with selection kind
+<tt class="docutils literal"><span class="pre">IMAGE_COMDAT_SELECT_LARGEST</span></tt> containing the contents of the <tt class="docutils literal"><span class="pre">@foo</span></tt> symbol
+and another COMDAT section with selection kind
+<tt class="docutils literal"><span class="pre">IMAGE_COMDAT_SELECT_ASSOCIATIVE</span></tt> which is associated with the first COMDAT
+section and contains the contents of the <tt class="docutils literal"><span class="pre">@bar</span></tt> symbol.</p>
+<p>There are some restrictions on the properties of the global object.
+It, or an alias to it, must have the same name as the COMDAT group when
+targeting COFF.
+The contents and size of this object may be used during link-time to determine
+which COMDAT groups get selected depending on the selection kind.
+Because the name of the object must match the name of the COMDAT group, the
+linkage of the global object must not be local; local symbols can get renamed
+if a collision occurs in the symbol table.</p>
+<p>The combined use of COMDATS and section attributes may yield surprising results.
+For example:</p>
+<div class="highlight-text"><div class="highlight"><pre>$foo = comdat any
+$bar = comdat any
+ at g1 = global i32 42, section "sec", comdat($foo)
+ at g2 = global i32 42, section "sec", comdat($bar)
+</pre></div>
+</div>
+<p>From the object file perspective, this requires the creation of two sections
+with the same name. This is necessary because both globals belong to different
+COMDAT groups and COMDATs, at the object file level, are represented by
+sections.</p>
+<p>Note that certain IR constructs like global variables and functions may
+create COMDATs in the object file in addition to any which are specified using
+COMDAT IR. This arises when the code generator is configured to emit globals
+in individual sections (e.g. when <cite>-data-sections</cite> or <cite>-function-sections</cite>
+is supplied to <cite>llc</cite>).</p>
+</div>
+<div class="section" id="named-metadata">
+<span id="namedmetadatastructure"></span><h3><a class="toc-backref" href="#id832">Named Metadata</a><a class="headerlink" href="#named-metadata" title="Permalink to this headline">¶</a></h3>
+<p>Named metadata is a collection of metadata. <a class="reference internal" href="#metadata"><em>Metadata
+nodes</em></a> (but not metadata strings) are the only valid
+operands for a named metadata.</p>
+<ol class="arabic simple">
+<li>Named metadata are represented as a string of characters with the
+metadata prefix. The rules for metadata names are the same as for
+identifiers, but quoted names are not allowed. <tt class="docutils literal"><span class="pre">"\xx"</span></tt> type escapes
+are still valid, which allows any character to be part of a name.</li>
+</ol>
+<p>Syntax:</p>
+<div class="highlight-python"><pre>; Some unnamed metadata nodes, which are referenced by the named metadata.
+!0 = !{!"zero"}
+!1 = !{!"one"}
+!2 = !{!"two"}
+; A named metadata.
+!name = !{!0, !1, !2}</pre>
+</div>
+</div>
+<div class="section" id="parameter-attributes">
+<span id="paramattrs"></span><h3><a class="toc-backref" href="#id833">Parameter Attributes</a><a class="headerlink" href="#parameter-attributes" title="Permalink to this headline">¶</a></h3>
+<p>The return type and each parameter of a function type may have a set of
+<em>parameter attributes</em> associated with them. Parameter attributes are
+used to communicate additional information about the result or
+parameters of a function. Parameter attributes are considered to be part
+of the function, not of the function type, so functions with different
+parameter attributes can have the same function type.</p>
+<p>Parameter attributes are simple keywords that follow the type specified.
+If multiple parameter attributes are needed, they are space separated.
+For example:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="k">declare</span> <span class="k">i32</span> <span class="vg">@printf</span><span class="p">(</span><span class="k">i8</span><span class="p">*</span> <span class="k">noalias</span> <span class="k">nocapture</span><span class="p">,</span> <span class="p">...)</span>
+<span class="k">declare</span> <span class="k">i32</span> <span class="vg">@atoi</span><span class="p">(</span><span class="k">i8</span> <span class="k">zeroext</span><span class="p">)</span>
+<span class="k">declare</span> <span class="k">signext</span> <span class="k">i8</span> <span class="vg">@returns_signed_char</span><span class="p">()</span>
+</pre></div>
+</div>
+<p>Note that any attributes for the function result (<tt class="docutils literal"><span class="pre">nounwind</span></tt>,
+<tt class="docutils literal"><span class="pre">readonly</span></tt>) come immediately after the argument list.</p>
+<p>Currently, only the following parameter attributes are defined:</p>
+<dl class="docutils">
+<dt><tt class="docutils literal"><span class="pre">zeroext</span></tt></dt>
+<dd>This indicates to the code generator that the parameter or return
+value should be zero-extended to the extent required by the target’s
+ABI by the caller (for a parameter) or the callee (for a return value).</dd>
+<dt><tt class="docutils literal"><span class="pre">signext</span></tt></dt>
+<dd>This indicates to the code generator that the parameter or return
+value should be sign-extended to the extent required by the target’s
+ABI (which is usually 32-bits) by the caller (for a parameter) or
+the callee (for a return value).</dd>
+<dt><tt class="docutils literal"><span class="pre">inreg</span></tt></dt>
+<dd>This indicates that this parameter or return value should be treated
+in a special target-dependent fashion while emitting code for
+a function call or return (usually, by putting it in a register as
+opposed to memory, though some targets use it to distinguish between
+two different kinds of registers). Use of this attribute is
+target-specific.</dd>
+<dt><tt class="docutils literal"><span class="pre">byval</span></tt></dt>
+<dd><p class="first">This indicates that the pointer parameter should really be passed by
+value to the function. The attribute implies that a hidden copy of
+the pointee is made between the caller and the callee, so the callee
+is unable to modify the value in the caller. This attribute is only
+valid on LLVM pointer arguments. It is generally used to pass
+structs and arrays by value, but is also valid on pointers to
+scalars. The copy is considered to belong to the caller not the
+callee (for example, <tt class="docutils literal"><span class="pre">readonly</span></tt> functions should not write to
+<tt class="docutils literal"><span class="pre">byval</span></tt> parameters). This is not a valid attribute for return
+values.</p>
+<p class="last">The byval attribute also supports specifying an alignment with the
+align attribute. It indicates the alignment of the stack slot to
+form and the known alignment of the pointer specified to the call
+site. If the alignment is not specified, then the code generator
+makes a target-specific assumption.</p>
+</dd>
+</dl>
+<p id="attr-inalloca"><tt class="docutils literal"><span class="pre">inalloca</span></tt></p>
+<blockquote>
+<div><p>The <tt class="docutils literal"><span class="pre">inalloca</span></tt> argument attribute allows the caller to take the
+address of outgoing stack arguments. An <tt class="docutils literal"><span class="pre">inalloca</span></tt> argument must
+be a pointer to stack memory produced by an <tt class="docutils literal"><span class="pre">alloca</span></tt> instruction.
+The alloca, or argument allocation, must also be tagged with the
+inalloca keyword. Only the last argument may have the <tt class="docutils literal"><span class="pre">inalloca</span></tt>
+attribute, and that argument is guaranteed to be passed in memory.</p>
+<p>An argument allocation may be used by a call at most once because
+the call may deallocate it. The <tt class="docutils literal"><span class="pre">inalloca</span></tt> attribute cannot be
+used in conjunction with other attributes that affect argument
+storage, like <tt class="docutils literal"><span class="pre">inreg</span></tt>, <tt class="docutils literal"><span class="pre">nest</span></tt>, <tt class="docutils literal"><span class="pre">sret</span></tt>, or <tt class="docutils literal"><span class="pre">byval</span></tt>. The
+<tt class="docutils literal"><span class="pre">inalloca</span></tt> attribute also disables LLVM’s implicit lowering of
+large aggregate return values, which means that frontend authors
+must lower them with <tt class="docutils literal"><span class="pre">sret</span></tt> pointers.</p>
+<p>When the call site is reached, the argument allocation must have
+been the most recent stack allocation that is still live, or the
+results are undefined. It is possible to allocate additional stack
+space after an argument allocation and before its call site, but it
+must be cleared off with <a class="reference internal" href="#int-stackrestore"><em>llvm.stackrestore</em></a>.</p>
+<p>See <a class="reference internal" href="InAlloca.html"><em>Design and Usage of the InAlloca Attribute</em></a> for more information on how to use this
+attribute.</p>
+</div></blockquote>
+<dl class="docutils">
+<dt><tt class="docutils literal"><span class="pre">sret</span></tt></dt>
+<dd>This indicates that the pointer parameter specifies the address of a
+structure that is the return value of the function in the source
+program. This pointer must be guaranteed by the caller to be valid:
+loads and stores to the structure may be assumed by the callee not
+to trap and to be properly aligned. This is not a valid attribute
+for return values.</dd>
+<dt><tt class="docutils literal"><span class="pre">align</span> <span class="pre"><n></span></tt></dt>
+<dd><p class="first">This indicates that the pointer value may be assumed by the optimizer to
+have the specified alignment.</p>
+<p class="last">Note that this attribute has additional semantics when combined with the
+<tt class="docutils literal"><span class="pre">byval</span></tt> attribute.</p>
+</dd>
+</dl>
+<dl class="docutils" id="noalias">
+<dt><tt class="docutils literal"><span class="pre">noalias</span></tt></dt>
+<dd><p class="first">This indicates that objects accessed via pointer values
+<a class="reference internal" href="#pointeraliasing"><em>based</em></a> on the argument or return value are not also
+accessed, during the execution of the function, via pointer values not
+<em>based</em> on the argument or return value. The attribute on a return value
+also has additional semantics described below. The caller shares the
+responsibility with the callee for ensuring that these requirements are met.
+For further details, please see the discussion of the NoAlias response in
+<a class="reference internal" href="AliasAnalysis.html#must-may-or-no"><em>alias analysis</em></a>.</p>
+<p>Note that this definition of <tt class="docutils literal"><span class="pre">noalias</span></tt> is intentionally similar
+to the definition of <tt class="docutils literal"><span class="pre">restrict</span></tt> in C99 for function arguments.</p>
+<p class="last">For function return values, C99’s <tt class="docutils literal"><span class="pre">restrict</span></tt> is not meaningful,
+while LLVM’s <tt class="docutils literal"><span class="pre">noalias</span></tt> is. Furthermore, the semantics of the <tt class="docutils literal"><span class="pre">noalias</span></tt>
+attribute on return values are stronger than the semantics of the attribute
+when used on function arguments. On function return values, the <tt class="docutils literal"><span class="pre">noalias</span></tt>
+attribute indicates that the function acts like a system memory allocation
+function, returning a pointer to allocated storage disjoint from the
+storage for any other object accessible to the caller.</p>
+</dd>
+<dt><tt class="docutils literal"><span class="pre">nocapture</span></tt></dt>
+<dd>This indicates that the callee does not make any copies of the
+pointer that outlive the callee itself. This is not a valid
+attribute for return values.  Addresses used in volatile operations
+are considered to be captured.</dd>
+</dl>
+<dl class="docutils" id="nest">
+<dt><tt class="docutils literal"><span class="pre">nest</span></tt></dt>
+<dd>This indicates that the pointer parameter can be excised using the
+<a class="reference internal" href="#int-trampoline"><em>trampoline intrinsics</em></a>. This is not a valid
+attribute for return values and can only be applied to one parameter.</dd>
+<dt><tt class="docutils literal"><span class="pre">returned</span></tt></dt>
+<dd>This indicates that the function always returns the argument as its return
+value. This is a hint to the optimizer and code generator used when
+generating the caller, allowing value propagation, tail call optimization,
+and omission of register saves and restores in some cases; it is not
+checked or enforced when generating the callee. The parameter and the
+function return type must be valid operands for the
+<a class="reference internal" href="#i-bitcast"><em>bitcast instruction</em></a>. This is not a valid attribute for
+return values and can only be applied to one parameter.</dd>
+<dt><tt class="docutils literal"><span class="pre">nonnull</span></tt></dt>
+<dd>This indicates that the parameter or return pointer is not null. This
+attribute may only be applied to pointer typed parameters. This is not
+checked or enforced by LLVM, the caller must ensure that the pointer
+passed in is non-null, or the callee must ensure that the returned pointer
+is non-null.</dd>
+<dt><tt class="docutils literal"><span class="pre">dereferenceable(<n>)</span></tt></dt>
+<dd>This indicates that the parameter or return pointer is dereferenceable. This
+attribute may only be applied to pointer typed parameters. A pointer that
+is dereferenceable can be loaded from speculatively without a risk of
+trapping. The number of bytes known to be dereferenceable must be provided
+in parentheses. It is legal for the number of bytes to be less than the
+size of the pointee type. The <tt class="docutils literal"><span class="pre">nonnull</span></tt> attribute does not imply
+dereferenceability (consider a pointer to one element past the end of an
+array), however <tt class="docutils literal"><span class="pre">dereferenceable(<n>)</span></tt> does imply <tt class="docutils literal"><span class="pre">nonnull</span></tt> in
+<tt class="docutils literal"><span class="pre">addrspace(0)</span></tt> (which is the default address space).</dd>
+<dt><tt class="docutils literal"><span class="pre">dereferenceable_or_null(<n>)</span></tt></dt>
+<dd>This indicates that the parameter or return value isn’t both
+non-null and non-dereferenceable (up to <tt class="docutils literal"><span class="pre"><n></span></tt> bytes) at the same
+time. All non-null pointers tagged with
+<tt class="docutils literal"><span class="pre">dereferenceable_or_null(<n>)</span></tt> are <tt class="docutils literal"><span class="pre">dereferenceable(<n>)</span></tt>.
+For address space 0 <tt class="docutils literal"><span class="pre">dereferenceable_or_null(<n>)</span></tt> implies that
+a pointer is exactly one of <tt class="docutils literal"><span class="pre">dereferenceable(<n>)</span></tt> or <tt class="docutils literal"><span class="pre">null</span></tt>,
+and in other address spaces <tt class="docutils literal"><span class="pre">dereferenceable_or_null(<n>)</span></tt>
+implies that a pointer is at least one of <tt class="docutils literal"><span class="pre">dereferenceable(<n>)</span></tt>
+or <tt class="docutils literal"><span class="pre">null</span></tt> (i.e. it may be both <tt class="docutils literal"><span class="pre">null</span></tt> and
+<tt class="docutils literal"><span class="pre">dereferenceable(<n>)</span></tt>). This attribute may only be applied to
+pointer typed parameters.</dd>
+<dt><tt class="docutils literal"><span class="pre">swiftself</span></tt></dt>
+<dd>This indicates that the parameter is the self/context parameter. This is not
+a valid attribute for return values and can only be applied to one
+parameter.</dd>
+<dt><tt class="docutils literal"><span class="pre">swifterror</span></tt></dt>
+<dd><p class="first">This attribute is motivated to model and optimize Swift error handling. It
+can be applied to a parameter with pointer to pointer type or a
+pointer-sized alloca. At the call site, the actual argument that corresponds
+to a <tt class="docutils literal"><span class="pre">swifterror</span></tt> parameter has to come from a <tt class="docutils literal"><span class="pre">swifterror</span></tt> alloca or
+the <tt class="docutils literal"><span class="pre">swifterror</span></tt> parameter of the caller. A <tt class="docutils literal"><span class="pre">swifterror</span></tt> value (either
+the parameter or the alloca) can only be loaded and stored from, or used as
+a <tt class="docutils literal"><span class="pre">swifterror</span></tt> argument. This is not a valid attribute for return values
+and can only be applied to one parameter.</p>
+<p>These constraints allow the calling convention to optimize access to
+<tt class="docutils literal"><span class="pre">swifterror</span></tt> variables by associating them with a specific register at
+call boundaries rather than placing them in memory. Since this does change
+the calling convention, a function which uses the <tt class="docutils literal"><span class="pre">swifterror</span></tt> attribute
+on a parameter is not ABI-compatible with one which does not.</p>
+<p class="last">These constraints also allow LLVM to assume that a <tt class="docutils literal"><span class="pre">swifterror</span></tt> argument
+does not alias any other memory visible within a function and that a
+<tt class="docutils literal"><span class="pre">swifterror</span></tt> alloca passed as an argument does not escape.</p>
+</dd>
+</dl>
+</div>
+<div class="section" id="garbage-collector-strategy-names">
+<span id="gc"></span><h3><a class="toc-backref" href="#id834">Garbage Collector Strategy Names</a><a class="headerlink" href="#garbage-collector-strategy-names" title="Permalink to this headline">¶</a></h3>
+<p>Each function may specify a garbage collector strategy name, which is simply a
+string:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="k">define</span> <span class="kt">void</span> <span class="vg">@f</span><span class="p">()</span> <span class="k">gc</span> <span class="s">"name"</span> <span class="p">{</span> <span class="p">...</span> <span class="p">}</span>
+</pre></div>
+</div>
+<p>The supported values of <em>name</em> includes those <a class="reference internal" href="GarbageCollection.html#builtin-gc-strategies"><em>built in to LLVM</em></a> and any provided by loaded plugins. Specifying a GC
+strategy will cause the compiler to alter its output in order to support the
+named garbage collection algorithm. Note that LLVM itself does not contain a
+garbage collector, this functionality is restricted to generating machine code
+which can interoperate with a collector provided externally.</p>
+</div>
+<div class="section" id="prefix-data">
+<span id="prefixdata"></span><h3><a class="toc-backref" href="#id835">Prefix Data</a><a class="headerlink" href="#prefix-data" title="Permalink to this headline">¶</a></h3>
+<p>Prefix data is data associated with a function which the code
+generator will emit immediately before the function’s entrypoint.
+The purpose of this feature is to allow frontends to associate
+language-specific runtime metadata with specific functions and make it
+available through the function pointer while still allowing the
+function pointer to be called.</p>
+<p>To access the data for a given function, a program may bitcast the
+function pointer to a pointer to the constant’s type and dereference
+index -1. This implies that the IR symbol points just past the end of
+the prefix data. For instance, take the example of a function annotated
+with a single <tt class="docutils literal"><span class="pre">i32</span></tt>,</p>
+<div class="highlight-llvm"><pre>define void @f() prefix i32 123 { ... }</pre>
+</div>
+<p>The prefix data can be referenced as,</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv-Anonymous">%0</span> <span class="p">=</span> <span class="k">bitcast</span> <span class="kt">void</span><span class="p">*</span> <span class="p">()</span> <span class="vg">@f</span> <span class="k">to</span> <span class="k">i32</span><span class="p">*</span>
+<span class="nv">%a</span> <span class="p">=</span> <span class="k">getelementptr</span> <span class="k">inbounds</span> <span class="k">i32</span><span class="p">,</span> <span class="k">i32</span><span class="p">*</span> <span class="nv-Anonymous">%0</span><span class="p">,</span> <span class="k">i32</span> <span class="m">-1</span>
+<span class="nv">%b</span> <span class="p">=</span> <span class="k">load</span> <span class="k">i32</span><span class="p">,</span> <span class="k">i32</span><span class="p">*</span> <span class="nv">%a</span>
+</pre></div>
+</div>
+<p>Prefix data is laid out as if it were an initializer for a global variable
+of the prefix data’s type. The function will be placed such that the
+beginning of the prefix data is aligned. This means that if the size
+of the prefix data is not a multiple of the alignment size, the
+function’s entrypoint will not be aligned. If alignment of the
+function’s entrypoint is desired, padding must be added to the prefix
+data.</p>
+<p>A function may have prefix data but no body. This has similar semantics
+to the <tt class="docutils literal"><span class="pre">available_externally</span></tt> linkage in that the data may be used by the
+optimizers but will not be emitted in the object file.</p>
+</div>
+<div class="section" id="prologue-data">
+<span id="prologuedata"></span><h3><a class="toc-backref" href="#id836">Prologue Data</a><a class="headerlink" href="#prologue-data" title="Permalink to this headline">¶</a></h3>
+<p>The <tt class="docutils literal"><span class="pre">prologue</span></tt> attribute allows arbitrary code (encoded as bytes) to
+be inserted prior to the function body. This can be used for enabling
+function hot-patching and instrumentation.</p>
+<p>To maintain the semantics of ordinary function calls, the prologue data must
+have a particular format. Specifically, it must begin with a sequence of
+bytes which decode to a sequence of machine instructions, valid for the
+module’s target, which transfer control to the point immediately succeeding
+the prologue data, without performing any other visible action. This allows
+the inliner and other passes to reason about the semantics of the function
+definition without needing to reason about the prologue data. Obviously this
+makes the format of the prologue data highly target dependent.</p>
+<p>A trivial example of valid prologue data for the x86 architecture is <tt class="docutils literal"><span class="pre">i8</span> <span class="pre">144</span></tt>,
+which encodes the <tt class="docutils literal"><span class="pre">nop</span></tt> instruction:</p>
+<div class="highlight-text"><div class="highlight"><pre>define void @f() prologue i8 144 { ... }
+</pre></div>
+</div>
+<p>Generally prologue data can be formed by encoding a relative branch instruction
+which skips the metadata, as in this example of valid prologue data for the
+x86_64 architecture, where the first two bytes encode <tt class="docutils literal"><span class="pre">jmp</span> <span class="pre">.+10</span></tt>:</p>
+<div class="highlight-text"><div class="highlight"><pre>%0 = type <{ i8, i8, i8* }>
+
+define void @f() prologue %0 <{ i8 235, i8 8, i8* @md}> { ... }
+</pre></div>
+</div>
+<p>A function may have prologue data but no body. This has similar semantics
+to the <tt class="docutils literal"><span class="pre">available_externally</span></tt> linkage in that the data may be used by the
+optimizers but will not be emitted in the object file.</p>
+</div>
+<div class="section" id="personality-function">
+<span id="personalityfn"></span><h3><a class="toc-backref" href="#id837">Personality Function</a><a class="headerlink" href="#personality-function" title="Permalink to this headline">¶</a></h3>
+<p>The <tt class="docutils literal"><span class="pre">personality</span></tt> attribute permits functions to specify what function
+to use for exception handling.</p>
+</div>
+<div class="section" id="attribute-groups">
+<span id="attrgrp"></span><h3><a class="toc-backref" href="#id838">Attribute Groups</a><a class="headerlink" href="#attribute-groups" title="Permalink to this headline">¶</a></h3>
+<p>Attribute groups are groups of attributes that are referenced by objects within
+the IR. They are important for keeping <tt class="docutils literal"><span class="pre">.ll</span></tt> files readable, because a lot of
+functions will use the same set of attributes. In the degenerative case of a
+<tt class="docutils literal"><span class="pre">.ll</span></tt> file that corresponds to a single <tt class="docutils literal"><span class="pre">.c</span></tt> file, the single attribute
+group will capture the important command line flags used to build that file.</p>
+<p>An attribute group is a module-level object. To use an attribute group, an
+object references the attribute group’s ID (e.g. <tt class="docutils literal"><span class="pre">#37</span></tt>). An object may refer
+to more than one attribute group. In that situation, the attributes from the
+different groups are merged.</p>
+<p>Here is an example of attribute groups for a function that should always be
+inlined, has a stack alignment of 4, and which shouldn’t use SSE instructions:</p>
+<div class="highlight-llvm"><pre>; Target-independent attributes:
+attributes #0 = { alwaysinline alignstack=4 }
+
+; Target-dependent attributes:
+attributes #1 = { "no-sse" }
+
+; Function @f has attributes: alwaysinline, alignstack=4, and "no-sse".
+define void @f() #0 #1 { ... }</pre>
+</div>
+</div>
+<div class="section" id="function-attributes">
+<span id="fnattrs"></span><h3><a class="toc-backref" href="#id839">Function Attributes</a><a class="headerlink" href="#function-attributes" title="Permalink to this headline">¶</a></h3>
+<p>Function attributes are set to communicate additional information about
+a function. Function attributes are considered to be part of the
+function, not of the function type, so functions with different function
+attributes can have the same function type.</p>
+<p>Function attributes are simple keywords that follow the type specified.
+If multiple attributes are needed, they are space separated. For
+example:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="k">define</span> <span class="kt">void</span> <span class="vg">@f</span><span class="p">()</span> <span class="k">noinline</span> <span class="p">{</span> <span class="p">...</span> <span class="p">}</span>
+<span class="k">define</span> <span class="kt">void</span> <span class="vg">@f</span><span class="p">()</span> <span class="k">alwaysinline</span> <span class="p">{</span> <span class="p">...</span> <span class="p">}</span>
+<span class="k">define</span> <span class="kt">void</span> <span class="vg">@f</span><span class="p">()</span> <span class="k">alwaysinline</span> <span class="k">optsize</span> <span class="p">{</span> <span class="p">...</span> <span class="p">}</span>
+<span class="k">define</span> <span class="kt">void</span> <span class="vg">@f</span><span class="p">()</span> <span class="k">optsize</span> <span class="p">{</span> <span class="p">...</span> <span class="p">}</span>
+</pre></div>
+</div>
+<dl class="docutils">
+<dt><tt class="docutils literal"><span class="pre">alignstack(<n>)</span></tt></dt>
+<dd>This attribute indicates that, when emitting the prologue and
+epilogue, the backend should forcibly align the stack pointer.
+Specify the desired alignment, which must be a power of two, in
+parentheses.</dd>
+<dt><tt class="docutils literal"><span class="pre">allocsize(<EltSizeParam>[,</span> <span class="pre"><NumEltsParam>])</span></tt></dt>
+<dd>This attribute indicates that the annotated function will always return at
+least a given number of bytes (or null). Its arguments are zero-indexed
+parameter numbers; if one argument is provided, then it’s assumed that at
+least <tt class="docutils literal"><span class="pre">CallSite.Args[EltSizeParam]</span></tt> bytes will be available at the
+returned pointer. If two are provided, then it’s assumed that
+<tt class="docutils literal"><span class="pre">CallSite.Args[EltSizeParam]</span> <span class="pre">*</span> <span class="pre">CallSite.Args[NumEltsParam]</span></tt> bytes are
+available. The referenced parameters must be integer types. No assumptions
+are made about the contents of the returned block of memory.</dd>
+<dt><tt class="docutils literal"><span class="pre">alwaysinline</span></tt></dt>
+<dd>This attribute indicates that the inliner should attempt to inline
+this function into callers whenever possible, ignoring any active
+inlining size threshold for this caller.</dd>
+<dt><tt class="docutils literal"><span class="pre">builtin</span></tt></dt>
+<dd>This indicates that the callee function at a call site should be
+recognized as a built-in function, even though the function’s declaration
+uses the <tt class="docutils literal"><span class="pre">nobuiltin</span></tt> attribute. This is only valid at call sites for
+direct calls to functions that are declared with the <tt class="docutils literal"><span class="pre">nobuiltin</span></tt>
+attribute.</dd>
+<dt><tt class="docutils literal"><span class="pre">cold</span></tt></dt>
+<dd>This attribute indicates that this function is rarely called. When
+computing edge weights, basic blocks post-dominated by a cold
+function call are also considered to be cold; and, thus, given low
+weight.</dd>
+<dt><tt class="docutils literal"><span class="pre">convergent</span></tt></dt>
+<dd><p class="first">In some parallel execution models, there exist operations that cannot be
+made control-dependent on any additional values.  We call such operations
+<tt class="docutils literal"><span class="pre">convergent</span></tt>, and mark them with this attribute.</p>
+<p>The <tt class="docutils literal"><span class="pre">convergent</span></tt> attribute may appear on functions or call/invoke
+instructions.  When it appears on a function, it indicates that calls to
+this function should not be made control-dependent on additional values.
+For example, the intrinsic <tt class="docutils literal"><span class="pre">llvm.nvvm.barrier0</span></tt> is <tt class="docutils literal"><span class="pre">convergent</span></tt>, so
+calls to this intrinsic cannot be made control-dependent on additional
+values.</p>
+<p>When it appears on a call/invoke, the <tt class="docutils literal"><span class="pre">convergent</span></tt> attribute indicates
+that we should treat the call as though we’re calling a convergent
+function.  This is particularly useful on indirect calls; without this we
+may treat such calls as though the target is non-convergent.</p>
+<p class="last">The optimizer may remove the <tt class="docutils literal"><span class="pre">convergent</span></tt> attribute on functions when it
+can prove that the function does not execute any convergent operations.
+Similarly, the optimizer may remove <tt class="docutils literal"><span class="pre">convergent</span></tt> on calls/invokes when it
+can prove that the call/invoke cannot call a convergent function.</p>
+</dd>
+<dt><tt class="docutils literal"><span class="pre">inaccessiblememonly</span></tt></dt>
+<dd>This attribute indicates that the function may only access memory that
+is not accessible by the module being compiled. This is a weaker form
+of <tt class="docutils literal"><span class="pre">readnone</span></tt>.</dd>
+<dt><tt class="docutils literal"><span class="pre">inaccessiblemem_or_argmemonly</span></tt></dt>
+<dd>This attribute indicates that the function may only access memory that is
+either not accessible by the module being compiled, or is pointed to
+by its pointer arguments. This is a weaker form of  <tt class="docutils literal"><span class="pre">argmemonly</span></tt></dd>
+<dt><tt class="docutils literal"><span class="pre">inlinehint</span></tt></dt>
+<dd>This attribute indicates that the source code contained a hint that
+inlining this function is desirable (such as the “inline” keyword in
+C/C++). It is just a hint; it imposes no requirements on the
+inliner.</dd>
+<dt><tt class="docutils literal"><span class="pre">jumptable</span></tt></dt>
+<dd>This attribute indicates that the function should be added to a
+jump-instruction table at code-generation time, and that all address-taken
+references to this function should be replaced with a reference to the
+appropriate jump-instruction-table function pointer. Note that this creates
+a new pointer for the original function, which means that code that depends
+on function-pointer identity can break. So, any function annotated with
+<tt class="docutils literal"><span class="pre">jumptable</span></tt> must also be <tt class="docutils literal"><span class="pre">unnamed_addr</span></tt>.</dd>
+<dt><tt class="docutils literal"><span class="pre">minsize</span></tt></dt>
+<dd>This attribute suggests that optimization passes and code generator
+passes make choices that keep the code size of this function as small
+as possible and perform optimizations that may sacrifice runtime
+performance in order to minimize the size of the generated code.</dd>
+<dt><tt class="docutils literal"><span class="pre">naked</span></tt></dt>
+<dd>This attribute disables prologue / epilogue emission for the
+function. This can have very system-specific consequences.</dd>
+<dt><tt class="docutils literal"><span class="pre">no-jump-tables</span></tt></dt>
+<dd>When this attribute is set to true, the jump tables and lookup tables that
+can be generated from a switch case lowering are disabled.</dd>
+<dt><tt class="docutils literal"><span class="pre">nobuiltin</span></tt></dt>
+<dd>This indicates that the callee function at a call site is not recognized as
+a built-in function. LLVM will retain the original call and not replace it
+with equivalent code based on the semantics of the built-in function, unless
+the call site uses the <tt class="docutils literal"><span class="pre">builtin</span></tt> attribute. This is valid at call sites
+and on function declarations and definitions.</dd>
+<dt><tt class="docutils literal"><span class="pre">noduplicate</span></tt></dt>
+<dd><p class="first">This attribute indicates that calls to the function cannot be
+duplicated. A call to a <tt class="docutils literal"><span class="pre">noduplicate</span></tt> function may be moved
+within its parent function, but may not be duplicated within
+its parent function.</p>
+<p class="last">A function containing a <tt class="docutils literal"><span class="pre">noduplicate</span></tt> call may still
+be an inlining candidate, provided that the call is not
+duplicated by inlining. That implies that the function has
+internal linkage and only has one call site, so the original
+call is dead after inlining.</p>
+</dd>
+<dt><tt class="docutils literal"><span class="pre">noimplicitfloat</span></tt></dt>
+<dd>This attributes disables implicit floating point instructions.</dd>
+<dt><tt class="docutils literal"><span class="pre">noinline</span></tt></dt>
+<dd>This attribute indicates that the inliner should never inline this
+function in any situation. This attribute may not be used together
+with the <tt class="docutils literal"><span class="pre">alwaysinline</span></tt> attribute.</dd>
+<dt><tt class="docutils literal"><span class="pre">nonlazybind</span></tt></dt>
+<dd>This attribute suppresses lazy symbol binding for the function. This
+may make calls to the function faster, at the cost of extra program
+startup time if the function is not called during program startup.</dd>
+<dt><tt class="docutils literal"><span class="pre">noredzone</span></tt></dt>
+<dd>This attribute indicates that the code generator should not use a
+red zone, even if the target-specific ABI normally permits it.</dd>
+<dt><tt class="docutils literal"><span class="pre">noreturn</span></tt></dt>
+<dd>This function attribute indicates that the function never returns
+normally. This produces undefined behavior at runtime if the
+function ever does dynamically return.</dd>
+<dt><tt class="docutils literal"><span class="pre">norecurse</span></tt></dt>
+<dd>This function attribute indicates that the function does not call itself
+either directly or indirectly down any possible call path. This produces
+undefined behavior at runtime if the function ever does recurse.</dd>
+<dt><tt class="docutils literal"><span class="pre">nounwind</span></tt></dt>
+<dd>This function attribute indicates that the function never raises an
+exception. If the function does raise an exception, its runtime
+behavior is undefined. However, functions marked nounwind may still
+trap or generate asynchronous exceptions. Exception handling schemes
+that are recognized by LLVM to handle asynchronous exceptions, such
+as SEH, will still provide their implementation defined semantics.</dd>
+<dt><tt class="docutils literal"><span class="pre">optnone</span></tt></dt>
+<dd><p class="first">This function attribute indicates that most optimization passes will skip
+this function, with the exception of interprocedural optimization passes.
+Code generation defaults to the “fast” instruction selector.
+This attribute cannot be used together with the <tt class="docutils literal"><span class="pre">alwaysinline</span></tt>
+attribute; this attribute is also incompatible
+with the <tt class="docutils literal"><span class="pre">minsize</span></tt> attribute and the <tt class="docutils literal"><span class="pre">optsize</span></tt> attribute.</p>
+<p class="last">This attribute requires the <tt class="docutils literal"><span class="pre">noinline</span></tt> attribute to be specified on
+the function as well, so the function is never inlined into any caller.
+Only functions with the <tt class="docutils literal"><span class="pre">alwaysinline</span></tt> attribute are valid
+candidates for inlining into the body of this function.</p>
+</dd>
+<dt><tt class="docutils literal"><span class="pre">optsize</span></tt></dt>
+<dd>This attribute suggests that optimization passes and code generator
+passes make choices that keep the code size of this function low,
+and otherwise do optimizations specifically to reduce code size as
+long as they do not significantly impact runtime performance.</dd>
+<dt><tt class="docutils literal"><span class="pre">"patchable-function"</span></tt></dt>
+<dd><p class="first">This attribute tells the code generator that the code
+generated for this function needs to follow certain conventions that
+make it possible for a runtime function to patch over it later.
+The exact effect of this attribute depends on its string value,
+for which there currently is one legal possibility:</p>
+<blockquote>
+<div><ul>
+<li><p class="first"><tt class="docutils literal"><span class="pre">"prologue-short-redirect"</span></tt> - This style of patchable
+function is intended to support patching a function prologue to
+redirect control away from the function in a thread safe
+manner.  It guarantees that the first instruction of the
+function will be large enough to accommodate a short jump
+instruction, and will be sufficiently aligned to allow being
+fully changed via an atomic compare-and-swap instruction.
+While the first requirement can be satisfied by inserting large
+enough NOP, LLVM can and will try to re-purpose an existing
+instruction (i.e. one that would have to be emitted anyway) as
+the patchable instruction larger than a short jump.</p>
+<p><tt class="docutils literal"><span class="pre">"prologue-short-redirect"</span></tt> is currently only supported on
+x86-64.</p>
+</li>
+</ul>
+</div></blockquote>
+<p class="last">This attribute by itself does not imply restrictions on
+inter-procedural optimizations.  All of the semantic effects the
+patching may have to be separately conveyed via the linkage type.</p>
+</dd>
+<dt><tt class="docutils literal"><span class="pre">"probe-stack"</span></tt></dt>
+<dd><p class="first">This attribute indicates that the function will trigger a guard region
+in the end of the stack. It ensures that accesses to the stack must be
+no further apart than the size of the guard region to a previous
+access of the stack. It takes one required string value, the name of
+the stack probing function that will be called.</p>
+<p class="last">If a function that has a <tt class="docutils literal"><span class="pre">"probe-stack"</span></tt> attribute is inlined into
+a function with another <tt class="docutils literal"><span class="pre">"probe-stack"</span></tt> attribute, the resulting
+function has the <tt class="docutils literal"><span class="pre">"probe-stack"</span></tt> attribute of the caller. If a
+function that has a <tt class="docutils literal"><span class="pre">"probe-stack"</span></tt> attribute is inlined into a
+function that has no <tt class="docutils literal"><span class="pre">"probe-stack"</span></tt> attribute at all, the resulting
+function has the <tt class="docutils literal"><span class="pre">"probe-stack"</span></tt> attribute of the callee.</p>
+</dd>
+<dt><tt class="docutils literal"><span class="pre">readnone</span></tt></dt>
+<dd><p class="first">On a function, this attribute indicates that the function computes its
+result (or decides to unwind an exception) based strictly on its arguments,
+without dereferencing any pointer arguments or otherwise accessing
+any mutable state (e.g. memory, control registers, etc) visible to
+caller functions. It does not write through any pointer arguments
+(including <tt class="docutils literal"><span class="pre">byval</span></tt> arguments) and never changes any state visible
+to callers. This means while it cannot unwind exceptions by calling
+the <tt class="docutils literal"><span class="pre">C++</span></tt> exception throwing methods (since they write to memory), there may
+be non-<tt class="docutils literal"><span class="pre">C++</span></tt> mechanisms that throw exceptions without writing to LLVM
+visible memory.</p>
+<p class="last">On an argument, this attribute indicates that the function does not
+dereference that pointer argument, even though it may read or write the
+memory that the pointer points to if accessed through other pointers.</p>
+</dd>
+<dt><tt class="docutils literal"><span class="pre">readonly</span></tt></dt>
+<dd><p class="first">On a function, this attribute indicates that the function does not write
+through any pointer arguments (including <tt class="docutils literal"><span class="pre">byval</span></tt> arguments) or otherwise
+modify any state (e.g. memory, control registers, etc) visible to
+caller functions. It may dereference pointer arguments and read
+state that may be set in the caller. A readonly function always
+returns the same value (or unwinds an exception identically) when
+called with the same set of arguments and global state.  This means while it
+cannot unwind exceptions by calling the <tt class="docutils literal"><span class="pre">C++</span></tt> exception throwing methods
+(since they write to memory), there may be non-<tt class="docutils literal"><span class="pre">C++</span></tt> mechanisms that throw
+exceptions without writing to LLVM visible memory.</p>
+<p class="last">On an argument, this attribute indicates that the function does not write
+through this pointer argument, even though it may write to the memory that
+the pointer points to.</p>
+</dd>
+<dt><tt class="docutils literal"><span class="pre">"stack-probe-size"</span></tt></dt>
+<dd><p class="first">This attribute controls the behavior of stack probes: either
+the <tt class="docutils literal"><span class="pre">"probe-stack"</span></tt> attribute, or ABI-required stack probes, if any.
+It defines the size of the guard region. It ensures that if the function
+may use more stack space than the size of the guard region, stack probing
+sequence will be emitted. It takes one required integer value, which
+is 4096 by default.</p>
+<p class="last">If a function that has a <tt class="docutils literal"><span class="pre">"stack-probe-size"</span></tt> attribute is inlined into
+a function with another <tt class="docutils literal"><span class="pre">"stack-probe-size"</span></tt> attribute, the resulting
+function has the <tt class="docutils literal"><span class="pre">"stack-probe-size"</span></tt> attribute that has the lower
+numeric value. If a function that has a <tt class="docutils literal"><span class="pre">"stack-probe-size"</span></tt> attribute is
+inlined into a function that has no <tt class="docutils literal"><span class="pre">"stack-probe-size"</span></tt> attribute
+at all, the resulting function has the <tt class="docutils literal"><span class="pre">"stack-probe-size"</span></tt> attribute
+of the callee.</p>
+</dd>
+<dt><tt class="docutils literal"><span class="pre">writeonly</span></tt></dt>
+<dd><p class="first">On a function, this attribute indicates that the function may write to but
+does not read from memory.</p>
+<p class="last">On an argument, this attribute indicates that the function may write to but
+does not read through this pointer argument (even though it may read from
+the memory that the pointer points to).</p>
+</dd>
+<dt><tt class="docutils literal"><span class="pre">argmemonly</span></tt></dt>
+<dd>This attribute indicates that the only memory accesses inside function are
+loads and stores from objects pointed to by its pointer-typed arguments,
+with arbitrary offsets. Or in other words, all memory operations in the
+function can refer to memory only using pointers based on its function
+arguments.
+Note that <tt class="docutils literal"><span class="pre">argmemonly</span></tt> can be used together with <tt class="docutils literal"><span class="pre">readonly</span></tt> attribute
+in order to specify that function reads only from its arguments.</dd>
+<dt><tt class="docutils literal"><span class="pre">returns_twice</span></tt></dt>
+<dd>This attribute indicates that this function can return twice. The C
+<tt class="docutils literal"><span class="pre">setjmp</span></tt> is an example of such a function. The compiler disables
+some optimizations (like tail calls) in the caller of these
+functions.</dd>
+<dt><tt class="docutils literal"><span class="pre">safestack</span></tt></dt>
+<dd><p class="first">This attribute indicates that
+<a class="reference external" href="http://clang.llvm.org/docs/SafeStack.html">SafeStack</a>
+protection is enabled for this function.</p>
+<p class="last">If a function that has a <tt class="docutils literal"><span class="pre">safestack</span></tt> attribute is inlined into a
+function that doesn’t have a <tt class="docutils literal"><span class="pre">safestack</span></tt> attribute or which has an
+<tt class="docutils literal"><span class="pre">ssp</span></tt>, <tt class="docutils literal"><span class="pre">sspstrong</span></tt> or <tt class="docutils literal"><span class="pre">sspreq</span></tt> attribute, then the resulting
+function will have a <tt class="docutils literal"><span class="pre">safestack</span></tt> attribute.</p>
+</dd>
+<dt><tt class="docutils literal"><span class="pre">sanitize_address</span></tt></dt>
+<dd>This attribute indicates that AddressSanitizer checks
+(dynamic address safety analysis) are enabled for this function.</dd>
+<dt><tt class="docutils literal"><span class="pre">sanitize_memory</span></tt></dt>
+<dd>This attribute indicates that MemorySanitizer checks (dynamic detection
+of accesses to uninitialized memory) are enabled for this function.</dd>
+<dt><tt class="docutils literal"><span class="pre">sanitize_thread</span></tt></dt>
+<dd>This attribute indicates that ThreadSanitizer checks
+(dynamic thread safety analysis) are enabled for this function.</dd>
+<dt><tt class="docutils literal"><span class="pre">sanitize_hwaddress</span></tt></dt>
+<dd>This attribute indicates that HWAddressSanitizer checks
+(dynamic address safety analysis based on tagged pointers) are enabled for
+this function.</dd>
+<dt><tt class="docutils literal"><span class="pre">speculatable</span></tt></dt>
+<dd>This function attribute indicates that the function does not have any
+effects besides calculating its result and does not have undefined behavior.
+Note that <tt class="docutils literal"><span class="pre">speculatable</span></tt> is not enough to conclude that along any
+particular execution path the number of calls to this function will not be
+externally observable. This attribute is only valid on functions
+and declarations, not on individual call sites. If a function is
+incorrectly marked as speculatable and really does exhibit
+undefined behavior, the undefined behavior may be observed even
+if the call site is dead code.</dd>
+<dt><tt class="docutils literal"><span class="pre">ssp</span></tt></dt>
+<dd><p class="first">This attribute indicates that the function should emit a stack
+smashing protector. It is in the form of a “canary” — a random value
+placed on the stack before the local variables that’s checked upon
+return from the function to see if it has been overwritten. A
+heuristic is used to determine if a function needs stack protectors
+or not. The heuristic used will enable protectors for functions with:</p>
+<ul class="simple">
+<li>Character arrays larger than <tt class="docutils literal"><span class="pre">ssp-buffer-size</span></tt> (default 8).</li>
+<li>Aggregates containing character arrays larger than <tt class="docutils literal"><span class="pre">ssp-buffer-size</span></tt>.</li>
+<li>Calls to alloca() with variable sizes or constant sizes greater than
+<tt class="docutils literal"><span class="pre">ssp-buffer-size</span></tt>.</li>
+</ul>
+<p>Variables that are identified as requiring a protector will be arranged
+on the stack such that they are adjacent to the stack protector guard.</p>
+<p class="last">If a function that has an <tt class="docutils literal"><span class="pre">ssp</span></tt> attribute is inlined into a
+function that doesn’t have an <tt class="docutils literal"><span class="pre">ssp</span></tt> attribute, then the resulting
+function will have an <tt class="docutils literal"><span class="pre">ssp</span></tt> attribute.</p>
+</dd>
+<dt><tt class="docutils literal"><span class="pre">sspreq</span></tt></dt>
+<dd><p class="first">This attribute indicates that the function should <em>always</em> emit a
+stack smashing protector. This overrides the <tt class="docutils literal"><span class="pre">ssp</span></tt> function
+attribute.</p>
+<p>Variables that are identified as requiring a protector will be arranged
+on the stack such that they are adjacent to the stack protector guard.
+The specific layout rules are:</p>
+<ol class="arabic simple">
+<li>Large arrays and structures containing large arrays
+(<tt class="docutils literal"><span class="pre">>=</span> <span class="pre">ssp-buffer-size</span></tt>) are closest to the stack protector.</li>
+<li>Small arrays and structures containing small arrays
+(<tt class="docutils literal"><span class="pre"><</span> <span class="pre">ssp-buffer-size</span></tt>) are 2nd closest to the protector.</li>
+<li>Variables that have had their address taken are 3rd closest to the
+protector.</li>
+</ol>
+<p class="last">If a function that has an <tt class="docutils literal"><span class="pre">sspreq</span></tt> attribute is inlined into a
+function that doesn’t have an <tt class="docutils literal"><span class="pre">sspreq</span></tt> attribute or which has an
+<tt class="docutils literal"><span class="pre">ssp</span></tt> or <tt class="docutils literal"><span class="pre">sspstrong</span></tt> attribute, then the resulting function will have
+an <tt class="docutils literal"><span class="pre">sspreq</span></tt> attribute.</p>
+</dd>
+<dt><tt class="docutils literal"><span class="pre">sspstrong</span></tt></dt>
+<dd><p class="first">This attribute indicates that the function should emit a stack smashing
+protector. This attribute causes a strong heuristic to be used when
+determining if a function needs stack protectors. The strong heuristic
+will enable protectors for functions with:</p>
+<ul class="simple">
+<li>Arrays of any size and type</li>
+<li>Aggregates containing an array of any size and type.</li>
+<li>Calls to alloca().</li>
+<li>Local variables that have had their address taken.</li>
+</ul>
+<p>Variables that are identified as requiring a protector will be arranged
+on the stack such that they are adjacent to the stack protector guard.
+The specific layout rules are:</p>
+<ol class="arabic simple">
+<li>Large arrays and structures containing large arrays
+(<tt class="docutils literal"><span class="pre">>=</span> <span class="pre">ssp-buffer-size</span></tt>) are closest to the stack protector.</li>
+<li>Small arrays and structures containing small arrays
+(<tt class="docutils literal"><span class="pre"><</span> <span class="pre">ssp-buffer-size</span></tt>) are 2nd closest to the protector.</li>
+<li>Variables that have had their address taken are 3rd closest to the
+protector.</li>
+</ol>
+<p>This overrides the <tt class="docutils literal"><span class="pre">ssp</span></tt> function attribute.</p>
+<p class="last">If a function that has an <tt class="docutils literal"><span class="pre">sspstrong</span></tt> attribute is inlined into a
+function that doesn’t have an <tt class="docutils literal"><span class="pre">sspstrong</span></tt> attribute, then the
+resulting function will have an <tt class="docutils literal"><span class="pre">sspstrong</span></tt> attribute.</p>
+</dd>
+<dt><tt class="docutils literal"><span class="pre">strictfp</span></tt></dt>
+<dd>This attribute indicates that the function was called from a scope that
+requires strict floating point semantics.  LLVM will not attempt any
+optimizations that require assumptions about the floating point rounding
+mode or that might alter the state of floating point status flags that
+might otherwise be set or cleared by calling this function.</dd>
+<dt><tt class="docutils literal"><span class="pre">"thunk"</span></tt></dt>
+<dd>This attribute indicates that the function will delegate to some other
+function with a tail call. The prototype of a thunk should not be used for
+optimization purposes. The caller is expected to cast the thunk prototype to
+match the thunk target prototype.</dd>
+<dt><tt class="docutils literal"><span class="pre">uwtable</span></tt></dt>
+<dd>This attribute indicates that the ABI being targeted requires that
+an unwind table entry be produced for this function even if we can
+show that no exceptions passes by it. This is normally the case for
+the ELF x86-64 abi, but it can be disabled for some compilation
+units.</dd>
+</dl>
+</div>
+<div class="section" id="global-attributes">
+<span id="glattrs"></span><h3><a class="toc-backref" href="#id840">Global Attributes</a><a class="headerlink" href="#global-attributes" title="Permalink to this headline">¶</a></h3>
+<p>Attributes may be set to communicate additional information about a global variable.
+Unlike <a class="reference internal" href="#fnattrs"><em>function attributes</em></a>, attributes on a global variable
+are grouped into a single <a class="reference internal" href="#attrgrp"><em>attribute group</em></a>.</p>
+</div>
+<div class="section" id="operand-bundles">
+<span id="opbundles"></span><h3><a class="toc-backref" href="#id841">Operand Bundles</a><a class="headerlink" href="#operand-bundles" title="Permalink to this headline">¶</a></h3>
+<p>Operand bundles are tagged sets of SSA values that can be associated
+with certain LLVM instructions (currently only <tt class="docutils literal"><span class="pre">call</span></tt> s and
+<tt class="docutils literal"><span class="pre">invoke</span></tt> s).  In a way they are like metadata, but dropping them is
+incorrect and will change program semantics.</p>
+<p>Syntax:</p>
+<div class="highlight-python"><pre>operand bundle set ::= '[' operand bundle (, operand bundle )* ']'
+operand bundle ::= tag '(' [ bundle operand ] (, bundle operand )* ')'
+bundle operand ::= SSA value
+tag ::= string constant</pre>
+</div>
+<p>Operand bundles are <strong>not</strong> part of a function’s signature, and a
+given function may be called from multiple places with different kinds
+of operand bundles.  This reflects the fact that the operand bundles
+are conceptually a part of the <tt class="docutils literal"><span class="pre">call</span></tt> (or <tt class="docutils literal"><span class="pre">invoke</span></tt>), not the
+callee being dispatched to.</p>
+<p>Operand bundles are a generic mechanism intended to support
+runtime-introspection-like functionality for managed languages.  While
+the exact semantics of an operand bundle depend on the bundle tag,
+there are certain limitations to how much the presence of an operand
+bundle can influence the semantics of a program.  These restrictions
+are described as the semantics of an “unknown” operand bundle.  As
+long as the behavior of an operand bundle is describable within these
+restrictions, LLVM does not need to have special knowledge of the
+operand bundle to not miscompile programs containing it.</p>
+<ul class="simple">
+<li>The bundle operands for an unknown operand bundle escape in unknown
+ways before control is transferred to the callee or invokee.</li>
+<li>Calls and invokes with operand bundles have unknown read / write
+effect on the heap on entry and exit (even if the call target is
+<tt class="docutils literal"><span class="pre">readnone</span></tt> or <tt class="docutils literal"><span class="pre">readonly</span></tt>), unless they’re overridden with
+callsite specific attributes.</li>
+<li>An operand bundle at a call site cannot change the implementation
+of the called function.  Inter-procedural optimizations work as
+usual as long as they take into account the first two properties.</li>
+</ul>
+<p>More specific types of operand bundles are described below.</p>
+<div class="section" id="deoptimization-operand-bundles">
+<span id="deopt-opbundles"></span><h4><a class="toc-backref" href="#id842">Deoptimization Operand Bundles</a><a class="headerlink" href="#deoptimization-operand-bundles" title="Permalink to this headline">¶</a></h4>
+<p>Deoptimization operand bundles are characterized by the <tt class="docutils literal"><span class="pre">"deopt"</span></tt>
+operand bundle tag.  These operand bundles represent an alternate
+“safe” continuation for the call site they’re attached to, and can be
+used by a suitable runtime to deoptimize the compiled frame at the
+specified call site.  There can be at most one <tt class="docutils literal"><span class="pre">"deopt"</span></tt> operand
+bundle attached to a call site.  Exact details of deoptimization is
+out of scope for the language reference, but it usually involves
+rewriting a compiled frame into a set of interpreted frames.</p>
+<p>From the compiler’s perspective, deoptimization operand bundles make
+the call sites they’re attached to at least <tt class="docutils literal"><span class="pre">readonly</span></tt>.  They read
+through all of their pointer typed operands (even if they’re not
+otherwise escaped) and the entire visible heap.  Deoptimization
+operand bundles do not capture their operands except during
+deoptimization, in which case control will not be returned to the
+compiled frame.</p>
+<p>The inliner knows how to inline through calls that have deoptimization
+operand bundles.  Just like inlining through a normal call site
+involves composing the normal and exceptional continuations, inlining
+through a call site with a deoptimization operand bundle needs to
+appropriately compose the “safe” deoptimization continuation.  The
+inliner does this by prepending the parent’s deoptimization
+continuation to every deoptimization continuation in the inlined body.
+E.g. inlining <tt class="docutils literal"><span class="pre">@f</span></tt> into <tt class="docutils literal"><span class="pre">@g</span></tt> in the following example</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="k">define</span> <span class="kt">void</span> <span class="vg">@f</span><span class="p">()</span> <span class="p">{</span>
+  <span class="k">call</span> <span class="kt">void</span> <span class="vg">@x</span><span class="p">()</span>  <span class="c">;; no deopt state</span>
+  <span class="k">call</span> <span class="kt">void</span> <span class="vg">@y</span><span class="p">()</span> <span class="p">[</span> <span class="s">"deopt"</span><span class="p">(</span><span class="k">i32</span> <span class="m">10</span><span class="p">)</span> <span class="p">]</span>
+  <span class="k">call</span> <span class="kt">void</span> <span class="vg">@y</span><span class="p">()</span> <span class="p">[</span> <span class="s">"deopt"</span><span class="p">(</span><span class="k">i32</span> <span class="m">10</span><span class="p">),</span> <span class="s">"unknown"</span><span class="p">(</span><span class="k">i8</span><span class="p">*</span> <span class="k">null</span><span class="p">)</span> <span class="p">]</span>
+  <span class="k">ret</span> <span class="kt">void</span>
+<span class="p">}</span>
+
+<span class="k">define</span> <span class="kt">void</span> <span class="vg">@g</span><span class="p">()</span> <span class="p">{</span>
+  <span class="k">call</span> <span class="kt">void</span> <span class="vg">@f</span><span class="p">()</span> <span class="p">[</span> <span class="s">"deopt"</span><span class="p">(</span><span class="k">i32</span> <span class="m">20</span><span class="p">)</span> <span class="p">]</span>
+  <span class="k">ret</span> <span class="kt">void</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>will result in</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="k">define</span> <span class="kt">void</span> <span class="vg">@g</span><span class="p">()</span> <span class="p">{</span>
+  <span class="k">call</span> <span class="kt">void</span> <span class="vg">@x</span><span class="p">()</span>  <span class="c">;; still no deopt state</span>
+  <span class="k">call</span> <span class="kt">void</span> <span class="vg">@y</span><span class="p">()</span> <span class="p">[</span> <span class="s">"deopt"</span><span class="p">(</span><span class="k">i32</span> <span class="m">20</span><span class="p">,</span> <span class="k">i32</span> <span class="m">10</span><span class="p">)</span> <span class="p">]</span>
+  <span class="k">call</span> <span class="kt">void</span> <span class="vg">@y</span><span class="p">()</span> <span class="p">[</span> <span class="s">"deopt"</span><span class="p">(</span><span class="k">i32</span> <span class="m">20</span><span class="p">,</span> <span class="k">i32</span> <span class="m">10</span><span class="p">),</span> <span class="s">"unknown"</span><span class="p">(</span><span class="k">i8</span><span class="p">*</span> <span class="k">null</span><span class="p">)</span> <span class="p">]</span>
+  <span class="k">ret</span> <span class="kt">void</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>It is the frontend’s responsibility to structure or encode the
+deoptimization state in a way that syntactically prepending the
+caller’s deoptimization state to the callee’s deoptimization state is
+semantically equivalent to composing the caller’s deoptimization
+continuation after the callee’s deoptimization continuation.</p>
+</div>
+<div class="section" id="funclet-operand-bundles">
+<span id="ob-funclet"></span><h4><a class="toc-backref" href="#id843">Funclet Operand Bundles</a><a class="headerlink" href="#funclet-operand-bundles" title="Permalink to this headline">¶</a></h4>
+<p>Funclet operand bundles are characterized by the <tt class="docutils literal"><span class="pre">"funclet"</span></tt>
+operand bundle tag.  These operand bundles indicate that a call site
+is within a particular funclet.  There can be at most one
+<tt class="docutils literal"><span class="pre">"funclet"</span></tt> operand bundle attached to a call site and it must have
+exactly one bundle operand.</p>
+<p>If any funclet EH pads have been “entered” but not “exited” (per the
+<a class="reference external" href="ExceptionHandling.html#wineh-constraints">description in the EH doc</a>),
+it is undefined behavior to execute a <tt class="docutils literal"><span class="pre">call</span></tt> or <tt class="docutils literal"><span class="pre">invoke</span></tt> which:</p>
+<ul class="simple">
+<li>does not have a <tt class="docutils literal"><span class="pre">"funclet"</span></tt> bundle and is not a <tt class="docutils literal"><span class="pre">call</span></tt> to a nounwind
+intrinsic, or</li>
+<li>has a <tt class="docutils literal"><span class="pre">"funclet"</span></tt> bundle whose operand is not the most-recently-entered
+not-yet-exited funclet EH pad.</li>
+</ul>
+<p>Similarly, if no funclet EH pads have been entered-but-not-yet-exited,
+executing a <tt class="docutils literal"><span class="pre">call</span></tt> or <tt class="docutils literal"><span class="pre">invoke</span></tt> with a <tt class="docutils literal"><span class="pre">"funclet"</span></tt> bundle is undefined behavior.</p>
+</div>
+<div class="section" id="gc-transition-operand-bundles">
+<h4><a class="toc-backref" href="#id844">GC Transition Operand Bundles</a><a class="headerlink" href="#gc-transition-operand-bundles" title="Permalink to this headline">¶</a></h4>
+<p>GC transition operand bundles are characterized by the
+<tt class="docutils literal"><span class="pre">"gc-transition"</span></tt> operand bundle tag. These operand bundles mark a
+call as a transition between a function with one GC strategy to a
+function with a different GC strategy. If coordinating the transition
+between GC strategies requires additional code generation at the call
+site, these bundles may contain any values that are needed by the
+generated code.  For more details, see <a class="reference internal" href="Statepoints.html#gc-transition-args"><em>GC Transitions</em></a>.</p>
+</div>
+</div>
+<div class="section" id="module-level-inline-assembly">
+<span id="moduleasm"></span><h3><a class="toc-backref" href="#id845">Module-Level Inline Assembly</a><a class="headerlink" href="#module-level-inline-assembly" title="Permalink to this headline">¶</a></h3>
+<p>Modules may contain “module-level inline asm” blocks, which corresponds
+to the GCC “file scope inline asm” blocks. These blocks are internally
+concatenated by LLVM and treated as a single unit, but may be separated
+in the <tt class="docutils literal"><span class="pre">.ll</span></tt> file if desired. The syntax is very simple:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="k">module</span> <span class="k">asm</span> <span class="s">"inline asm code goes here"</span>
+<span class="k">module</span> <span class="k">asm</span> <span class="s">"more can go here"</span>
+</pre></div>
+</div>
+<p>The strings can contain any character by escaping non-printable
+characters. The escape sequence used is simply “\xx” where “xx” is the
+two digit hex code for the number.</p>
+<p>Note that the assembly string <em>must</em> be parseable by LLVM’s integrated assembler
+(unless it is disabled), even when emitting a <tt class="docutils literal"><span class="pre">.s</span></tt> file.</p>
+</div>
+<div class="section" id="data-layout">
+<span id="langref-datalayout"></span><h3><a class="toc-backref" href="#id846">Data Layout</a><a class="headerlink" href="#data-layout" title="Permalink to this headline">¶</a></h3>
+<p>A module may specify a target specific data layout string that specifies
+how data is to be laid out in memory. The syntax for the data layout is
+simply:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="k">target</span> <span class="k">datalayout</span> <span class="p">=</span> <span class="s">"layout specification"</span>
+</pre></div>
+</div>
+<p>The <em>layout specification</em> consists of a list of specifications
+separated by the minus sign character (‘-‘). Each specification starts
+with a letter and may include other information after the letter to
+define some aspect of the data layout. The specifications accepted are
+as follows:</p>
+<dl class="docutils">
+<dt><tt class="docutils literal"><span class="pre">E</span></tt></dt>
+<dd>Specifies that the target lays out data in big-endian form. That is,
+the bits with the most significance have the lowest address
+location.</dd>
+<dt><tt class="docutils literal"><span class="pre">e</span></tt></dt>
+<dd>Specifies that the target lays out data in little-endian form. That
+is, the bits with the least significance have the lowest address
+location.</dd>
+<dt><tt class="docutils literal"><span class="pre">S<size></span></tt></dt>
+<dd>Specifies the natural alignment of the stack in bits. Alignment
+promotion of stack variables is limited to the natural stack
+alignment to avoid dynamic stack realignment. The stack alignment
+must be a multiple of 8-bits. If omitted, the natural stack
+alignment defaults to “unspecified”, which does not prevent any
+alignment promotions.</dd>
+<dt><tt class="docutils literal"><span class="pre">A<address</span> <span class="pre">space></span></tt></dt>
+<dd>Specifies the address space of  objects created by ‘<tt class="docutils literal"><span class="pre">alloca</span></tt>‘.
+Defaults to the default address space of 0.</dd>
+<dt><tt class="docutils literal"><span class="pre">p[n]:<size>:<abi>:<pref></span></tt></dt>
+<dd>This specifies the <em>size</em> of a pointer and its <tt class="docutils literal"><span class="pre"><abi></span></tt> and
+<tt class="docutils literal"><span class="pre"><pref></span></tt>erred alignments for address space <tt class="docutils literal"><span class="pre">n</span></tt>. All sizes are in
+bits. The address space, <tt class="docutils literal"><span class="pre">n</span></tt>, is optional, and if not specified,
+denotes the default address space 0. The value of <tt class="docutils literal"><span class="pre">n</span></tt> must be
+in the range [1,2^23).</dd>
+<dt><tt class="docutils literal"><span class="pre">i<size>:<abi>:<pref></span></tt></dt>
+<dd>This specifies the alignment for an integer type of a given bit
+<tt class="docutils literal"><span class="pre"><size></span></tt>. The value of <tt class="docutils literal"><span class="pre"><size></span></tt> must be in the range [1,2^23).</dd>
+<dt><tt class="docutils literal"><span class="pre">v<size>:<abi>:<pref></span></tt></dt>
+<dd>This specifies the alignment for a vector type of a given bit
+<tt class="docutils literal"><span class="pre"><size></span></tt>.</dd>
+<dt><tt class="docutils literal"><span class="pre">f<size>:<abi>:<pref></span></tt></dt>
+<dd>This specifies the alignment for a floating point type of a given bit
+<tt class="docutils literal"><span class="pre"><size></span></tt>. Only values of <tt class="docutils literal"><span class="pre"><size></span></tt> that are supported by the target
+will work. 32 (float) and 64 (double) are supported on all targets; 80
+or 128 (different flavors of long double) are also supported on some
+targets.</dd>
+<dt><tt class="docutils literal"><span class="pre">a:<abi>:<pref></span></tt></dt>
+<dd>This specifies the alignment for an object of aggregate type.</dd>
+<dt><tt class="docutils literal"><span class="pre">m:<mangling></span></tt></dt>
+<dd><p class="first">If present, specifies that llvm names are mangled in the output. The
+options are</p>
+<ul class="last simple">
+<li><tt class="docutils literal"><span class="pre">e</span></tt>: ELF mangling: Private symbols get a <tt class="docutils literal"><span class="pre">.L</span></tt> prefix.</li>
+<li><tt class="docutils literal"><span class="pre">m</span></tt>: Mips mangling: Private symbols get a <tt class="docutils literal"><span class="pre">$</span></tt> prefix.</li>
+<li><tt class="docutils literal"><span class="pre">o</span></tt>: Mach-O mangling: Private symbols get <tt class="docutils literal"><span class="pre">L</span></tt> prefix. Other
+symbols get a <tt class="docutils literal"><span class="pre">_</span></tt> prefix.</li>
+<li><tt class="docutils literal"><span class="pre">w</span></tt>: Windows COFF prefix:  Similar to Mach-O, but stdcall and fastcall
+functions also get a suffix based on the frame size.</li>
+<li><tt class="docutils literal"><span class="pre">x</span></tt>: Windows x86 COFF prefix:  Similar to Windows COFF, but use a <tt class="docutils literal"><span class="pre">_</span></tt>
+prefix for <tt class="docutils literal"><span class="pre">__cdecl</span></tt> functions.</li>
+</ul>
+</dd>
+<dt><tt class="docutils literal"><span class="pre">n<size1>:<size2>:<size3>...</span></tt></dt>
+<dd>This specifies a set of native integer widths for the target CPU in
+bits. For example, it might contain <tt class="docutils literal"><span class="pre">n32</span></tt> for 32-bit PowerPC,
+<tt class="docutils literal"><span class="pre">n32:64</span></tt> for PowerPC 64, or <tt class="docutils literal"><span class="pre">n8:16:32:64</span></tt> for X86-64. Elements of
+this set are considered to support most general arithmetic operations
+efficiently.</dd>
+<dt><tt class="docutils literal"><span class="pre">ni:<address</span> <span class="pre">space0>:<address</span> <span class="pre">space1>:<address</span> <span class="pre">space2>...</span></tt></dt>
+<dd>This specifies pointer types with the specified address spaces
+as <a class="reference internal" href="#nointptrtype"><em>Non-Integral Pointer Type</em></a> s.  The <tt class="docutils literal"><span class="pre">0</span></tt>
+address space cannot be specified as non-integral.</dd>
+</dl>
+<p>On every specification that takes a <tt class="docutils literal"><span class="pre"><abi>:<pref></span></tt>, specifying the
+<tt class="docutils literal"><span class="pre"><pref></span></tt> alignment is optional. If omitted, the preceding <tt class="docutils literal"><span class="pre">:</span></tt>
+should be omitted too and <tt class="docutils literal"><span class="pre"><pref></span></tt> will be equal to <tt class="docutils literal"><span class="pre"><abi></span></tt>.</p>
+<p>When constructing the data layout for a given target, LLVM starts with a
+default set of specifications which are then (possibly) overridden by
+the specifications in the <tt class="docutils literal"><span class="pre">datalayout</span></tt> keyword. The default
+specifications are given in this list:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">E</span></tt> - big endian</li>
+<li><tt class="docutils literal"><span class="pre">p:64:64:64</span></tt> - 64-bit pointers with 64-bit alignment.</li>
+<li><tt class="docutils literal"><span class="pre">p[n]:64:64:64</span></tt> - Other address spaces are assumed to be the
+same as the default address space.</li>
+<li><tt class="docutils literal"><span class="pre">S0</span></tt> - natural stack alignment is unspecified</li>
+<li><tt class="docutils literal"><span class="pre">i1:8:8</span></tt> - i1 is 8-bit (byte) aligned</li>
+<li><tt class="docutils literal"><span class="pre">i8:8:8</span></tt> - i8 is 8-bit (byte) aligned</li>
+<li><tt class="docutils literal"><span class="pre">i16:16:16</span></tt> - i16 is 16-bit aligned</li>
+<li><tt class="docutils literal"><span class="pre">i32:32:32</span></tt> - i32 is 32-bit aligned</li>
+<li><tt class="docutils literal"><span class="pre">i64:32:64</span></tt> - i64 has ABI alignment of 32-bits but preferred
+alignment of 64-bits</li>
+<li><tt class="docutils literal"><span class="pre">f16:16:16</span></tt> - half is 16-bit aligned</li>
+<li><tt class="docutils literal"><span class="pre">f32:32:32</span></tt> - float is 32-bit aligned</li>
+<li><tt class="docutils literal"><span class="pre">f64:64:64</span></tt> - double is 64-bit aligned</li>
+<li><tt class="docutils literal"><span class="pre">f128:128:128</span></tt> - quad is 128-bit aligned</li>
+<li><tt class="docutils literal"><span class="pre">v64:64:64</span></tt> - 64-bit vector is 64-bit aligned</li>
+<li><tt class="docutils literal"><span class="pre">v128:128:128</span></tt> - 128-bit vector is 128-bit aligned</li>
+<li><tt class="docutils literal"><span class="pre">a:0:64</span></tt> - aggregates are 64-bit aligned</li>
+</ul>
+<p>When LLVM is determining the alignment for a given type, it uses the
+following rules:</p>
+<ol class="arabic simple">
+<li>If the type sought is an exact match for one of the specifications,
+that specification is used.</li>
+<li>If no match is found, and the type sought is an integer type, then
+the smallest integer type that is larger than the bitwidth of the
+sought type is used. If none of the specifications are larger than
+the bitwidth then the largest integer type is used. For example,
+given the default specifications above, the i7 type will use the
+alignment of i8 (next largest) while both i65 and i256 will use the
+alignment of i64 (largest specified).</li>
+<li>If no match is found, and the type sought is a vector type, then the
+largest vector type that is smaller than the sought vector type will
+be used as a fall back. This happens because <128 x double> can be
+implemented in terms of 64 <2 x double>, for example.</li>
+</ol>
+<p>The function of the data layout string may not be what you expect.
+Notably, this is not a specification from the frontend of what alignment
+the code generator should use.</p>
+<p>Instead, if specified, the target data layout is required to match what
+the ultimate <em>code generator</em> expects. This string is used by the
+mid-level optimizers to improve code, and this only works if it matches
+what the ultimate code generator uses. There is no way to generate IR
+that does not embed this target-specific detail into the IR. If you
+don’t specify the string, the default specifications will be used to
+generate a Data Layout and the optimization phases will operate
+accordingly and introduce target specificity into the IR with respect to
+these default specifications.</p>
+</div>
+<div class="section" id="target-triple">
+<span id="langref-triple"></span><h3><a class="toc-backref" href="#id847">Target Triple</a><a class="headerlink" href="#target-triple" title="Permalink to this headline">¶</a></h3>
+<p>A module may specify a target triple string that describes the target
+host. The syntax for the target triple is simply:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="k">target</span> <span class="k">triple</span> <span class="p">=</span> <span class="s">"x86_64-apple-macosx10.7.0"</span>
+</pre></div>
+</div>
+<p>The <em>target triple</em> string consists of a series of identifiers delimited
+by the minus sign character (‘-‘). The canonical forms are:</p>
+<div class="highlight-python"><div class="highlight"><pre><span class="n">ARCHITECTURE</span><span class="o">-</span><span class="n">VENDOR</span><span class="o">-</span><span class="n">OPERATING_SYSTEM</span>
+<span class="n">ARCHITECTURE</span><span class="o">-</span><span class="n">VENDOR</span><span class="o">-</span><span class="n">OPERATING_SYSTEM</span><span class="o">-</span><span class="n">ENVIRONMENT</span>
+</pre></div>
+</div>
+<p>This information is passed along to the backend so that it generates
+code for the proper architecture. It’s possible to override this on the
+command line with the <tt class="docutils literal"><span class="pre">-mtriple</span></tt> command line option.</p>
+</div>
+<div class="section" id="pointer-aliasing-rules">
+<span id="pointeraliasing"></span><h3><a class="toc-backref" href="#id848">Pointer Aliasing Rules</a><a class="headerlink" href="#pointer-aliasing-rules" title="Permalink to this headline">¶</a></h3>
+<p>Any memory access must be done through a pointer value associated with
+an address range of the memory access, otherwise the behavior is
+undefined. Pointer values are associated with address ranges according
+to the following rules:</p>
+<ul class="simple">
+<li>A pointer value is associated with the addresses associated with any
+value it is <em>based</em> on.</li>
+<li>An address of a global variable is associated with the address range
+of the variable’s storage.</li>
+<li>The result value of an allocation instruction is associated with the
+address range of the allocated storage.</li>
+<li>A null pointer in the default address-space is associated with no
+address.</li>
+<li>An integer constant other than zero or a pointer value returned from
+a function not defined within LLVM may be associated with address
+ranges allocated through mechanisms other than those provided by
+LLVM. Such ranges shall not overlap with any ranges of addresses
+allocated by mechanisms provided by LLVM.</li>
+</ul>
+<p>A pointer value is <em>based</em> on another pointer value according to the
+following rules:</p>
+<ul class="simple">
+<li>A pointer value formed from a scalar <tt class="docutils literal"><span class="pre">getelementptr</span></tt> operation is <em>based</em> on
+the pointer-typed operand of the <tt class="docutils literal"><span class="pre">getelementptr</span></tt>.</li>
+<li>The pointer in lane <em>l</em> of the result of a vector <tt class="docutils literal"><span class="pre">getelementptr</span></tt> operation
+is <em>based</em> on the pointer in lane <em>l</em> of the vector-of-pointers-typed operand
+of the <tt class="docutils literal"><span class="pre">getelementptr</span></tt>.</li>
+<li>The result value of a <tt class="docutils literal"><span class="pre">bitcast</span></tt> is <em>based</em> on the operand of the
+<tt class="docutils literal"><span class="pre">bitcast</span></tt>.</li>
+<li>A pointer value formed by an <tt class="docutils literal"><span class="pre">inttoptr</span></tt> is <em>based</em> on all pointer
+values that contribute (directly or indirectly) to the computation of
+the pointer’s value.</li>
+<li>The “<em>based</em> on” relationship is transitive.</li>
+</ul>
+<p>Note that this definition of <em>“based”</em> is intentionally similar to the
+definition of <em>“based”</em> in C99, though it is slightly weaker.</p>
+<p>LLVM IR does not associate types with memory. The result type of a
+<tt class="docutils literal"><span class="pre">load</span></tt> merely indicates the size and alignment of the memory from
+which to load, as well as the interpretation of the value. The first
+operand type of a <tt class="docutils literal"><span class="pre">store</span></tt> similarly only indicates the size and
+alignment of the store.</p>
+<p>Consequently, type-based alias analysis, aka TBAA, aka
+<tt class="docutils literal"><span class="pre">-fstrict-aliasing</span></tt>, is not applicable to general unadorned LLVM IR.
+<a class="reference internal" href="#metadata"><em>Metadata</em></a> may be used to encode additional information
+which specialized optimization passes may use to implement type-based
+alias analysis.</p>
+</div>
+<div class="section" id="volatile-memory-accesses">
+<span id="volatile"></span><h3><a class="toc-backref" href="#id849">Volatile Memory Accesses</a><a class="headerlink" href="#volatile-memory-accesses" title="Permalink to this headline">¶</a></h3>
+<p>Certain memory accesses, such as <a class="reference internal" href="#i-load"><em>load</em></a>‘s,
+<a class="reference internal" href="#i-store"><em>store</em></a>‘s, and <a class="reference internal" href="#int-memcpy"><em>llvm.memcpy</em></a>‘s may be
+marked <tt class="docutils literal"><span class="pre">volatile</span></tt>. The optimizers must not change the number of
+volatile operations or change their order of execution relative to other
+volatile operations. The optimizers <em>may</em> change the order of volatile
+operations relative to non-volatile operations. This is not Java’s
+“volatile” and has no cross-thread synchronization behavior.</p>
+<p>IR-level volatile loads and stores cannot safely be optimized into
+llvm.memcpy or llvm.memmove intrinsics even when those intrinsics are
+flagged volatile. Likewise, the backend should never split or merge
+target-legal volatile load/store instructions.</p>
+<div class="admonition-rationale admonition">
+<p class="first admonition-title">Rationale</p>
+<p class="last">Platforms may rely on volatile loads and stores of natively supported
+data width to be executed as single instruction. For example, in C
+this holds for an l-value of volatile primitive type with native
+hardware support, but not necessarily for aggregate types. The
+frontend upholds these expectations, which are intentionally
+unspecified in the IR. The rules above ensure that IR transformations
+do not violate the frontend’s contract with the language.</p>
+</div>
+</div>
+<div class="section" id="memory-model-for-concurrent-operations">
+<span id="memmodel"></span><h3><a class="toc-backref" href="#id850">Memory Model for Concurrent Operations</a><a class="headerlink" href="#memory-model-for-concurrent-operations" title="Permalink to this headline">¶</a></h3>
+<p>The LLVM IR does not define any way to start parallel threads of
+execution or to register signal handlers. Nonetheless, there are
+platform-specific ways to create them, and we define LLVM IR’s behavior
+in their presence. This model is inspired by the C++0x memory model.</p>
+<p>For a more informal introduction to this model, see the <a class="reference internal" href="Atomics.html"><em>LLVM Atomic Instructions and Concurrency Guide</em></a>.</p>
+<p>We define a <em>happens-before</em> partial order as the least partial order
+that</p>
+<ul class="simple">
+<li>Is a superset of single-thread program order, and</li>
+<li>When a <em>synchronizes-with</em> <tt class="docutils literal"><span class="pre">b</span></tt>, includes an edge from <tt class="docutils literal"><span class="pre">a</span></tt> to
+<tt class="docutils literal"><span class="pre">b</span></tt>. <em>Synchronizes-with</em> pairs are introduced by platform-specific
+techniques, like pthread locks, thread creation, thread joining,
+etc., and by atomic instructions. (See also <a class="reference internal" href="#ordering"><em>Atomic Memory Ordering
+Constraints</em></a>).</li>
+</ul>
+<p>Note that program order does not introduce <em>happens-before</em> edges
+between a thread and signals executing inside that thread.</p>
+<p>Every (defined) read operation (load instructions, memcpy, atomic
+loads/read-modify-writes, etc.) R reads a series of bytes written by
+(defined) write operations (store instructions, atomic
+stores/read-modify-writes, memcpy, etc.). For the purposes of this
+section, initialized globals are considered to have a write of the
+initializer which is atomic and happens before any other read or write
+of the memory in question. For each byte of a read R, R<sub>byte</sub>
+may see any write to the same byte, except:</p>
+<ul class="simple">
+<li>If write<sub>1</sub>  happens before write<sub>2</sub>, and
+write<sub>2</sub> happens before R<sub>byte</sub>, then
+R<sub>byte</sub> does not see write<sub>1</sub>.</li>
+<li>If R<sub>byte</sub> happens before write<sub>3</sub>, then
+R<sub>byte</sub> does not see write<sub>3</sub>.</li>
+</ul>
+<p>Given that definition, R<sub>byte</sub> is defined as follows:</p>
+<ul class="simple">
+<li>If R is volatile, the result is target-dependent. (Volatile is
+supposed to give guarantees which can support <tt class="docutils literal"><span class="pre">sig_atomic_t</span></tt> in
+C/C++, and may be used for accesses to addresses that do not behave
+like normal memory. It does not generally provide cross-thread
+synchronization.)</li>
+<li>Otherwise, if there is no write to the same byte that happens before
+R<sub>byte</sub>, R<sub>byte</sub> returns <tt class="docutils literal"><span class="pre">undef</span></tt> for that byte.</li>
+<li>Otherwise, if R<sub>byte</sub> may see exactly one write,
+R<sub>byte</sub> returns the value written by that write.</li>
+<li>Otherwise, if R is atomic, and all the writes R<sub>byte</sub> may
+see are atomic, it chooses one of the values written. See the <a class="reference internal" href="#ordering"><em>Atomic
+Memory Ordering Constraints</em></a> section for additional
+constraints on how the choice is made.</li>
+<li>Otherwise R<sub>byte</sub> returns <tt class="docutils literal"><span class="pre">undef</span></tt>.</li>
+</ul>
+<p>R returns the value composed of the series of bytes it read. This
+implies that some bytes within the value may be <tt class="docutils literal"><span class="pre">undef</span></tt> <strong>without</strong>
+the entire value being <tt class="docutils literal"><span class="pre">undef</span></tt>. Note that this only defines the
+semantics of the operation; it doesn’t mean that targets will emit more
+than one instruction to read the series of bytes.</p>
+<p>Note that in cases where none of the atomic intrinsics are used, this
+model places only one restriction on IR transformations on top of what
+is required for single-threaded execution: introducing a store to a byte
+which might not otherwise be stored is not allowed in general.
+(Specifically, in the case where another thread might write to and read
+from an address, introducing a store can change a load that may see
+exactly one write into a load that may see multiple writes.)</p>
+</div>
+<div class="section" id="atomic-memory-ordering-constraints">
+<span id="ordering"></span><h3><a class="toc-backref" href="#id851">Atomic Memory Ordering Constraints</a><a class="headerlink" href="#atomic-memory-ordering-constraints" title="Permalink to this headline">¶</a></h3>
+<p>Atomic instructions (<a class="reference internal" href="#i-cmpxchg"><em>cmpxchg</em></a>,
+<a class="reference internal" href="#i-atomicrmw"><em>atomicrmw</em></a>, <a class="reference internal" href="#i-fence"><em>fence</em></a>,
+<a class="reference internal" href="#i-load"><em>atomic load</em></a>, and <a class="reference internal" href="#i-store"><em>atomic store</em></a>) take
+ordering parameters that determine which other atomic instructions on
+the same address they <em>synchronize with</em>. These semantics are borrowed
+from Java and C++0x, but are somewhat more colloquial. If these
+descriptions aren’t precise enough, check those specs (see spec
+references in the <a class="reference internal" href="Atomics.html"><em>atomics guide</em></a>).
+<a class="reference internal" href="#i-fence"><em>fence</em></a> instructions treat these orderings somewhat
+differently since they don’t take an address. See that instruction’s
+documentation for details.</p>
+<p>For a simpler introduction to the ordering constraints, see the
+<a class="reference internal" href="Atomics.html"><em>LLVM Atomic Instructions and Concurrency Guide</em></a>.</p>
+<dl class="docutils">
+<dt><tt class="docutils literal"><span class="pre">unordered</span></tt></dt>
+<dd>The set of values that can be read is governed by the happens-before
+partial order. A value cannot be read unless some operation wrote
+it. This is intended to provide a guarantee strong enough to model
+Java’s non-volatile shared variables. This ordering cannot be
+specified for read-modify-write operations; it is not strong enough
+to make them atomic in any interesting way.</dd>
+<dt><tt class="docutils literal"><span class="pre">monotonic</span></tt></dt>
+<dd>In addition to the guarantees of <tt class="docutils literal"><span class="pre">unordered</span></tt>, there is a single
+total order for modifications by <tt class="docutils literal"><span class="pre">monotonic</span></tt> operations on each
+address. All modification orders must be compatible with the
+happens-before order. There is no guarantee that the modification
+orders can be combined to a global total order for the whole program
+(and this often will not be possible). The read in an atomic
+read-modify-write operation (<a class="reference internal" href="#i-cmpxchg"><em>cmpxchg</em></a> and
+<a class="reference internal" href="#i-atomicrmw"><em>atomicrmw</em></a>) reads the value in the modification
+order immediately before the value it writes. If one atomic read
+happens before another atomic read of the same address, the later
+read must see the same value or a later value in the address’s
+modification order. This disallows reordering of <tt class="docutils literal"><span class="pre">monotonic</span></tt> (or
+stronger) operations on the same address. If an address is written
+<tt class="docutils literal"><span class="pre">monotonic</span></tt>-ally by one thread, and other threads <tt class="docutils literal"><span class="pre">monotonic</span></tt>-ally
+read that address repeatedly, the other threads must eventually see
+the write. This corresponds to the C++0x/C1x
+<tt class="docutils literal"><span class="pre">memory_order_relaxed</span></tt>.</dd>
+<dt><tt class="docutils literal"><span class="pre">acquire</span></tt></dt>
+<dd>In addition to the guarantees of <tt class="docutils literal"><span class="pre">monotonic</span></tt>, a
+<em>synchronizes-with</em> edge may be formed with a <tt class="docutils literal"><span class="pre">release</span></tt> operation.
+This is intended to model C++’s <tt class="docutils literal"><span class="pre">memory_order_acquire</span></tt>.</dd>
+<dt><tt class="docutils literal"><span class="pre">release</span></tt></dt>
+<dd>In addition to the guarantees of <tt class="docutils literal"><span class="pre">monotonic</span></tt>, if this operation
+writes a value which is subsequently read by an <tt class="docutils literal"><span class="pre">acquire</span></tt>
+operation, it <em>synchronizes-with</em> that operation. (This isn’t a
+complete description; see the C++0x definition of a release
+sequence.) This corresponds to the C++0x/C1x
+<tt class="docutils literal"><span class="pre">memory_order_release</span></tt>.</dd>
+<dt><tt class="docutils literal"><span class="pre">acq_rel</span></tt> (acquire+release)</dt>
+<dd>Acts as both an <tt class="docutils literal"><span class="pre">acquire</span></tt> and <tt class="docutils literal"><span class="pre">release</span></tt> operation on its
+address. This corresponds to the C++0x/C1x <tt class="docutils literal"><span class="pre">memory_order_acq_rel</span></tt>.</dd>
+<dt><tt class="docutils literal"><span class="pre">seq_cst</span></tt> (sequentially consistent)</dt>
+<dd>In addition to the guarantees of <tt class="docutils literal"><span class="pre">acq_rel</span></tt> (<tt class="docutils literal"><span class="pre">acquire</span></tt> for an
+operation that only reads, <tt class="docutils literal"><span class="pre">release</span></tt> for an operation that only
+writes), there is a global total order on all
+sequentially-consistent operations on all addresses, which is
+consistent with the <em>happens-before</em> partial order and with the
+modification orders of all the affected addresses. Each
+sequentially-consistent read sees the last preceding write to the
+same address in this global order. This corresponds to the C++0x/C1x
+<tt class="docutils literal"><span class="pre">memory_order_seq_cst</span></tt> and Java volatile.</dd>
+</dl>
+<p id="syncscope">If an atomic operation is marked <tt class="docutils literal"><span class="pre">syncscope("singlethread")</span></tt>, it only
+<em>synchronizes with</em> and only participates in the seq_cst total orderings of
+other operations running in the same thread (for example, in signal handlers).</p>
+<p>If an atomic operation is marked <tt class="docutils literal"><span class="pre">syncscope("<target-scope>")</span></tt>, where
+<tt class="docutils literal"><span class="pre"><target-scope></span></tt> is a target specific synchronization scope, then it is target
+dependent if it <em>synchronizes with</em> and participates in the seq_cst total
+orderings of other operations.</p>
+<p>Otherwise, an atomic operation that is not marked <tt class="docutils literal"><span class="pre">syncscope("singlethread")</span></tt>
+or <tt class="docutils literal"><span class="pre">syncscope("<target-scope>")</span></tt> <em>synchronizes with</em> and participates in the
+seq_cst total orderings of other operations that are not marked
+<tt class="docutils literal"><span class="pre">syncscope("singlethread")</span></tt> or <tt class="docutils literal"><span class="pre">syncscope("<target-scope>")</span></tt>.</p>
+</div>
+<div class="section" id="fast-math-flags">
+<span id="fastmath"></span><h3><a class="toc-backref" href="#id852">Fast-Math Flags</a><a class="headerlink" href="#fast-math-flags" title="Permalink to this headline">¶</a></h3>
+<p>LLVM IR floating-point operations (<a class="reference internal" href="#i-fadd"><em>fadd</em></a>,
+<a class="reference internal" href="#i-fsub"><em>fsub</em></a>, <a class="reference internal" href="#i-fmul"><em>fmul</em></a>, <a class="reference internal" href="#i-fdiv"><em>fdiv</em></a>,
+<a class="reference internal" href="#i-frem"><em>frem</em></a>, <a class="reference internal" href="#i-fcmp"><em>fcmp</em></a>) and <a class="reference internal" href="#i-call"><em>call</em></a>
+may use the following flags to enable otherwise unsafe
+floating-point transformations.</p>
+<dl class="docutils">
+<dt><tt class="docutils literal"><span class="pre">nnan</span></tt></dt>
+<dd>No NaNs - Allow optimizations to assume the arguments and result are not
+NaN. Such optimizations are required to retain defined behavior over
+NaNs, but the value of the result is undefined.</dd>
+<dt><tt class="docutils literal"><span class="pre">ninf</span></tt></dt>
+<dd>No Infs - Allow optimizations to assume the arguments and result are not
++/-Inf. Such optimizations are required to retain defined behavior over
++/-Inf, but the value of the result is undefined.</dd>
+<dt><tt class="docutils literal"><span class="pre">nsz</span></tt></dt>
+<dd>No Signed Zeros - Allow optimizations to treat the sign of a zero
+argument or result as insignificant.</dd>
+<dt><tt class="docutils literal"><span class="pre">arcp</span></tt></dt>
+<dd>Allow Reciprocal - Allow optimizations to use the reciprocal of an
+argument rather than perform division.</dd>
+<dt><tt class="docutils literal"><span class="pre">contract</span></tt></dt>
+<dd>Allow floating-point contraction (e.g. fusing a multiply followed by an
+addition into a fused multiply-and-add).</dd>
+<dt><tt class="docutils literal"><span class="pre">afn</span></tt></dt>
+<dd>Approximate functions - Allow substitution of approximate calculations for
+functions (sin, log, sqrt, etc). See floating-point intrinsic definitions
+for places where this can apply to LLVM’s intrinsic math functions.</dd>
+<dt><tt class="docutils literal"><span class="pre">reassoc</span></tt></dt>
+<dd>Allow reassociation transformations for floating-point instructions.
+This may dramatically change results in floating point.</dd>
+<dt><tt class="docutils literal"><span class="pre">fast</span></tt></dt>
+<dd>This flag implies all of the others.</dd>
+</dl>
+</div>
+<div class="section" id="use-list-order-directives">
+<span id="uselistorder"></span><h3><a class="toc-backref" href="#id853">Use-list Order Directives</a><a class="headerlink" href="#use-list-order-directives" title="Permalink to this headline">¶</a></h3>
+<p>Use-list directives encode the in-memory order of each use-list, allowing the
+order to be recreated. <tt class="docutils literal"><span class="pre"><order-indexes></span></tt> is a comma-separated list of
+indexes that are assigned to the referenced value’s uses. The referenced
+value’s use-list is immediately sorted by these indexes.</p>
+<p>Use-list directives may appear at function scope or global scope. They are not
+instructions, and have no effect on the semantics of the IR. When they’re at
+function scope, they must appear after the terminator of the final basic block.</p>
+<p>If basic blocks have their address taken via <tt class="docutils literal"><span class="pre">blockaddress()</span></tt> expressions,
+<tt class="docutils literal"><span class="pre">uselistorder_bb</span></tt> can be used to reorder their use-lists from outside their
+function’s scope.</p>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Syntax:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<div class="highlight-python"><pre>uselistorder <ty> <value>, { <order-indexes> }
+uselistorder_bb @function, %block { <order-indexes> }</pre>
+</div>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Examples:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<div class="highlight-python"><pre>define void @foo(i32 %arg1, i32 %arg2) {
+entry:
+  ; ... instructions ...
+bb:
+  ; ... instructions ...
+
+  ; At function scope.
+  uselistorder i32 %arg1, { 1, 0, 2 }
+  uselistorder label %bb, { 1, 0 }
+}
+
+; At global scope.
+uselistorder i32* @global, { 1, 2, 0 }
+uselistorder i32 7, { 1, 0 }
+uselistorder i32 (i32) @bar, { 1, 0 }
+uselistorder_bb @foo, %bb, { 5, 1, 3, 2, 0, 4 }</pre>
+</div>
+</div>
+<div class="section" id="source-filename">
+<span id="id3"></span><h3><a class="toc-backref" href="#id854">Source Filename</a><a class="headerlink" href="#source-filename" title="Permalink to this headline">¶</a></h3>
+<p>The <em>source filename</em> string is set to the original module identifier,
+which will be the name of the compiled source file when compiling from
+source through the clang front end, for example. It is then preserved through
+the IR and bitcode.</p>
+<p>This is currently necessary to generate a consistent unique global
+identifier for local functions used in profile data, which prepends the
+source file name to the local function name.</p>
+<p>The syntax for the source file name is simply:</p>
+<div class="highlight-text"><div class="highlight"><pre>source_filename = "/path/to/source.c"
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="type-system">
+<span id="typesystem"></span><h2><a class="toc-backref" href="#id855">Type System</a><a class="headerlink" href="#type-system" title="Permalink to this headline">¶</a></h2>
+<p>The LLVM type system is one of the most important features of the
+intermediate representation. Being typed enables a number of
+optimizations to be performed on the intermediate representation
+directly, without having to do extra analyses on the side before the
+transformation. A strong type system makes it easier to read the
+generated code and enables novel analyses and transformations that are
+not feasible to perform on normal three address code representations.</p>
+<div class="section" id="void-type">
+<span id="t-void"></span><h3><a class="toc-backref" href="#id856">Void Type</a><a class="headerlink" href="#void-type" title="Permalink to this headline">¶</a></h3>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Overview:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<p>The void type does not represent any value and has no size.</p>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Syntax:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<div class="highlight-python"><div class="highlight"><pre><span class="n">void</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="function-type">
+<span id="t-function"></span><h3><a class="toc-backref" href="#id857">Function Type</a><a class="headerlink" href="#function-type" title="Permalink to this headline">¶</a></h3>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Overview:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<p>The function type can be thought of as a function signature. It consists of a
+return type and a list of formal parameter types. The return type of a function
+type is a void type or first class type — except for <a class="reference internal" href="#t-label"><em>label</em></a>
+and <a class="reference internal" href="#t-metadata"><em>metadata</em></a> types.</p>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Syntax:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<div class="highlight-python"><pre><returntype> (<parameter list>)</pre>
+</div>
+<p>...where ‘<tt class="docutils literal"><span class="pre"><parameter</span> <span class="pre">list></span></tt>‘ is a comma-separated list of type
+specifiers. Optionally, the parameter list may include a type <tt class="docutils literal"><span class="pre">...</span></tt>, which
+indicates that the function takes a variable number of arguments. Variable
+argument functions can access their arguments with the <a class="reference internal" href="#int-varargs"><em>variable argument
+handling intrinsic</em></a> functions. ‘<tt class="docutils literal"><span class="pre"><returntype></span></tt>‘ is any type
+except <a class="reference internal" href="#t-label"><em>label</em></a> and <a class="reference internal" href="#t-metadata"><em>metadata</em></a>.</p>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Examples:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<table border="1" class="docutils">
+<colgroup>
+<col width="17%" />
+<col width="83%" />
+</colgroup>
+<tbody valign="top">
+<tr class="row-odd"><td><tt class="docutils literal"><span class="pre">i32</span> <span class="pre">(i32)</span></tt></td>
+<td>function taking an <tt class="docutils literal"><span class="pre">i32</span></tt>, returning an <tt class="docutils literal"><span class="pre">i32</span></tt></td>
+</tr>
+<tr class="row-even"><td><tt class="docutils literal"><span class="pre">float</span> <span class="pre">(i16,</span> <span class="pre">i32</span> <span class="pre">*)</span> <span class="pre">*</span></tt></td>
+<td><a class="reference internal" href="#t-pointer"><em>Pointer</em></a> to a function that takes an <tt class="docutils literal"><span class="pre">i16</span></tt> and a <a class="reference internal" href="#t-pointer"><em>pointer</em></a> to <tt class="docutils literal"><span class="pre">i32</span></tt>, returning <tt class="docutils literal"><span class="pre">float</span></tt>.</td>
+</tr>
+<tr class="row-odd"><td><tt class="docutils literal"><span class="pre">i32</span> <span class="pre">(i8*,</span> <span class="pre">...)</span></tt></td>
+<td>A vararg function that takes at least one <a class="reference internal" href="#t-pointer"><em>pointer</em></a> to <tt class="docutils literal"><span class="pre">i8</span></tt> (char in C), which returns an integer. This is the signature for <tt class="docutils literal"><span class="pre">printf</span></tt> in LLVM.</td>
+</tr>
+<tr class="row-even"><td><tt class="docutils literal"><span class="pre">{i32,</span> <span class="pre">i32}</span> <span class="pre">(i32)</span></tt></td>
+<td>A function taking an <tt class="docutils literal"><span class="pre">i32</span></tt>, returning a <a class="reference internal" href="#t-struct"><em>structure</em></a> containing two <tt class="docutils literal"><span class="pre">i32</span></tt> values</td>
+</tr>
+</tbody>
+</table>
+</div>
+<div class="section" id="first-class-types">
+<span id="t-firstclass"></span><h3><a class="toc-backref" href="#id858">First Class Types</a><a class="headerlink" href="#first-class-types" title="Permalink to this headline">¶</a></h3>
+<p>The <a class="reference internal" href="#t-firstclass"><em>first class</em></a> types are perhaps the most important.
+Values of these types are the only ones which can be produced by
+instructions.</p>
+<div class="section" id="single-value-types">
+<span id="t-single-value"></span><h4><a class="toc-backref" href="#id859">Single Value Types</a><a class="headerlink" href="#single-value-types" title="Permalink to this headline">¶</a></h4>
+<p>These are the types that are valid in registers from CodeGen’s perspective.</p>
+<div class="section" id="integer-type">
+<span id="t-integer"></span><h5><a class="toc-backref" href="#id860">Integer Type</a><a class="headerlink" href="#integer-type" title="Permalink to this headline">¶</a></h5>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Overview:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<p>The integer type is a very simple type that simply specifies an
+arbitrary bit width for the integer type desired. Any bit width from 1
+bit to 2<sup>23</sup>-1 (about 8 million) can be specified.</p>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Syntax:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<div class="highlight-python"><div class="highlight"><pre><span class="n">iN</span>
+</pre></div>
+</div>
+<p>The number of bits the integer will occupy is specified by the <tt class="docutils literal"><span class="pre">N</span></tt>
+value.</p>
+<div class="section" id="examples">
+<h6>Examples:<a class="headerlink" href="#examples" title="Permalink to this headline">¶</a></h6>
+<table border="1" class="docutils">
+<colgroup>
+<col width="25%" />
+<col width="75%" />
+</colgroup>
+<tbody valign="top">
+<tr class="row-odd"><td><tt class="docutils literal"><span class="pre">i1</span></tt></td>
+<td>a single-bit integer.</td>
+</tr>
+<tr class="row-even"><td><tt class="docutils literal"><span class="pre">i32</span></tt></td>
+<td>a 32-bit integer.</td>
+</tr>
+<tr class="row-odd"><td><tt class="docutils literal"><span class="pre">i1942652</span></tt></td>
+<td>a really big integer of over 1 million bits.</td>
+</tr>
+</tbody>
+</table>
+</div>
+</div>
+<div class="section" id="floating-point-types">
+<span id="t-floating"></span><h5><a class="toc-backref" href="#id861">Floating Point Types</a><a class="headerlink" href="#floating-point-types" title="Permalink to this headline">¶</a></h5>
+<table border="1" class="docutils">
+<colgroup>
+<col width="50%" />
+<col width="50%" />
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">Type</th>
+<th class="head">Description</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td><tt class="docutils literal"><span class="pre">half</span></tt></td>
+<td>16-bit floating point value</td>
+</tr>
+<tr class="row-odd"><td><tt class="docutils literal"><span class="pre">float</span></tt></td>
+<td>32-bit floating point value</td>
+</tr>
+<tr class="row-even"><td><tt class="docutils literal"><span class="pre">double</span></tt></td>
+<td>64-bit floating point value</td>
+</tr>
+<tr class="row-odd"><td><tt class="docutils literal"><span class="pre">fp128</span></tt></td>
+<td>128-bit floating point value (112-bit mantissa)</td>
+</tr>
+<tr class="row-even"><td><tt class="docutils literal"><span class="pre">x86_fp80</span></tt></td>
+<td>80-bit floating point value (X87)</td>
+</tr>
+<tr class="row-odd"><td><tt class="docutils literal"><span class="pre">ppc_fp128</span></tt></td>
+<td>128-bit floating point value (two 64-bits)</td>
+</tr>
+</tbody>
+</table>
+</div>
+<div class="section" id="x86-mmx-type">
+<h5><a class="toc-backref" href="#id862">X86_mmx Type</a><a class="headerlink" href="#x86-mmx-type" title="Permalink to this headline">¶</a></h5>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Overview:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<p>The x86_mmx type represents a value held in an MMX register on an x86
+machine. The operations allowed on it are quite limited: parameters and
+return values, load and store, and bitcast. User-specified MMX
+instructions are represented as intrinsic or asm calls with arguments
+and/or results of this type. There are no arrays, vectors or constants
+of this type.</p>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Syntax:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<div class="highlight-python"><div class="highlight"><pre><span class="n">x86_mmx</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="pointer-type">
+<span id="t-pointer"></span><h5><a class="toc-backref" href="#id863">Pointer Type</a><a class="headerlink" href="#pointer-type" title="Permalink to this headline">¶</a></h5>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Overview:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<p>The pointer type is used to specify memory locations. Pointers are
+commonly used to reference objects in memory.</p>
+<p>Pointer types may have an optional address space attribute defining the
+numbered address space where the pointed-to object resides. The default
+address space is number zero. The semantics of non-zero address spaces
+are target-specific.</p>
+<p>Note that LLVM does not permit pointers to void (<tt class="docutils literal"><span class="pre">void*</span></tt>) nor does it
+permit pointers to labels (<tt class="docutils literal"><span class="pre">label*</span></tt>). Use <tt class="docutils literal"><span class="pre">i8*</span></tt> instead.</p>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Syntax:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<div class="highlight-python"><pre><type> *</pre>
+</div>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Examples:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<table border="1" class="docutils">
+<colgroup>
+<col width="19%" />
+<col width="81%" />
+</colgroup>
+<tbody valign="top">
+<tr class="row-odd"><td><tt class="docutils literal"><span class="pre">[4</span> <span class="pre">x</span> <span class="pre">i32]*</span></tt></td>
+<td>A <a class="reference internal" href="#t-pointer"><em>pointer</em></a> to <a class="reference internal" href="#t-array"><em>array</em></a> of four <tt class="docutils literal"><span class="pre">i32</span></tt> values.</td>
+</tr>
+<tr class="row-even"><td><tt class="docutils literal"><span class="pre">i32</span> <span class="pre">(i32*)</span> <span class="pre">*</span></tt></td>
+<td>A <a class="reference internal" href="#t-pointer"><em>pointer</em></a> to a <a class="reference internal" href="#t-function"><em>function</em></a> that takes an <tt class="docutils literal"><span class="pre">i32*</span></tt>, returning an <tt class="docutils literal"><span class="pre">i32</span></tt>.</td>
+</tr>
+<tr class="row-odd"><td><tt class="docutils literal"><span class="pre">i32</span> <span class="pre">addrspace(5)*</span></tt></td>
+<td>A <a class="reference internal" href="#t-pointer"><em>pointer</em></a> to an <tt class="docutils literal"><span class="pre">i32</span></tt> value that resides in address space #5.</td>
+</tr>
+</tbody>
+</table>
+</div>
+<div class="section" id="vector-type">
+<span id="t-vector"></span><h5><a class="toc-backref" href="#id864">Vector Type</a><a class="headerlink" href="#vector-type" title="Permalink to this headline">¶</a></h5>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Overview:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<p>A vector type is a simple derived type that represents a vector of
+elements. Vector types are used when multiple primitive data are
+operated in parallel using a single instruction (SIMD). A vector type
+requires a size (number of elements) and an underlying primitive data
+type. Vector types are considered <a class="reference internal" href="#t-firstclass"><em>first class</em></a>.</p>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Syntax:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<div class="highlight-python"><pre>< <# elements> x <elementtype> ></pre>
+</div>
+<p>The number of elements is a constant integer value larger than 0;
+elementtype may be any integer, floating point or pointer type. Vectors
+of size zero are not allowed.</p>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Examples:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<table border="1" class="docutils">
+<colgroup>
+<col width="28%" />
+<col width="72%" />
+</colgroup>
+<tbody valign="top">
+<tr class="row-odd"><td><tt class="docutils literal"><span class="pre"><4</span> <span class="pre">x</span> <span class="pre">i32></span></tt></td>
+<td>Vector of 4 32-bit integer values.</td>
+</tr>
+<tr class="row-even"><td><tt class="docutils literal"><span class="pre"><8</span> <span class="pre">x</span> <span class="pre">float></span></tt></td>
+<td>Vector of 8 32-bit floating-point values.</td>
+</tr>
+<tr class="row-odd"><td><tt class="docutils literal"><span class="pre"><2</span> <span class="pre">x</span> <span class="pre">i64></span></tt></td>
+<td>Vector of 2 64-bit integer values.</td>
+</tr>
+<tr class="row-even"><td><tt class="docutils literal"><span class="pre"><4</span> <span class="pre">x</span> <span class="pre">i64*></span></tt></td>
+<td>Vector of 4 pointers to 64-bit integer values.</td>
+</tr>
+</tbody>
+</table>
+</div>
+</div>
+<div class="section" id="label-type">
+<span id="t-label"></span><h4><a class="toc-backref" href="#id865">Label Type</a><a class="headerlink" href="#label-type" title="Permalink to this headline">¶</a></h4>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Overview:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<p>The label type represents code labels.</p>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Syntax:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<div class="highlight-python"><div class="highlight"><pre><span class="n">label</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="token-type">
+<span id="t-token"></span><h4><a class="toc-backref" href="#id866">Token Type</a><a class="headerlink" href="#token-type" title="Permalink to this headline">¶</a></h4>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Overview:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<p>The token type is used when a value is associated with an instruction
+but all uses of the value must not attempt to introspect or obscure it.
+As such, it is not appropriate to have a <a class="reference internal" href="#i-phi"><em>phi</em></a> or
+<a class="reference internal" href="#i-select"><em>select</em></a> of type token.</p>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Syntax:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<div class="highlight-python"><div class="highlight"><pre><span class="n">token</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="metadata-type">
+<span id="t-metadata"></span><h4><a class="toc-backref" href="#id867">Metadata Type</a><a class="headerlink" href="#metadata-type" title="Permalink to this headline">¶</a></h4>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Overview:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<p>The metadata type represents embedded metadata. No derived types may be
+created from metadata except for <a class="reference internal" href="#t-function"><em>function</em></a> arguments.</p>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Syntax:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<div class="highlight-python"><div class="highlight"><pre><span class="n">metadata</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="aggregate-types">
+<span id="t-aggregate"></span><h4><a class="toc-backref" href="#id868">Aggregate Types</a><a class="headerlink" href="#aggregate-types" title="Permalink to this headline">¶</a></h4>
+<p>Aggregate Types are a subset of derived types that can contain multiple
+member types. <a class="reference internal" href="#t-array"><em>Arrays</em></a> and <a class="reference internal" href="#t-struct"><em>structs</em></a> are
+aggregate types. <a class="reference internal" href="#t-vector"><em>Vectors</em></a> are not considered to be
+aggregate types.</p>
+<div class="section" id="array-type">
+<span id="t-array"></span><h5><a class="toc-backref" href="#id869">Array Type</a><a class="headerlink" href="#array-type" title="Permalink to this headline">¶</a></h5>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Overview:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<p>The array type is a very simple derived type that arranges elements
+sequentially in memory. The array type requires a size (number of
+elements) and an underlying data type.</p>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Syntax:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<div class="highlight-python"><pre>[<# elements> x <elementtype>]</pre>
+</div>
+<p>The number of elements is a constant integer value; <tt class="docutils literal"><span class="pre">elementtype</span></tt> may
+be any type with a size.</p>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Examples:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<table border="1" class="docutils">
+<colgroup>
+<col width="32%" />
+<col width="68%" />
+</colgroup>
+<tbody valign="top">
+<tr class="row-odd"><td><tt class="docutils literal"><span class="pre">[40</span> <span class="pre">x</span> <span class="pre">i32]</span></tt></td>
+<td>Array of 40 32-bit integer values.</td>
+</tr>
+<tr class="row-even"><td><tt class="docutils literal"><span class="pre">[41</span> <span class="pre">x</span> <span class="pre">i32]</span></tt></td>
+<td>Array of 41 32-bit integer values.</td>
+</tr>
+<tr class="row-odd"><td><tt class="docutils literal"><span class="pre">[4</span> <span class="pre">x</span> <span class="pre">i8]</span></tt></td>
+<td>Array of 4 8-bit integer values.</td>
+</tr>
+</tbody>
+</table>
+<p>Here are some examples of multidimensional arrays:</p>
+<table border="1" class="docutils">
+<colgroup>
+<col width="33%" />
+<col width="67%" />
+</colgroup>
+<tbody valign="top">
+<tr class="row-odd"><td><tt class="docutils literal"><span class="pre">[3</span> <span class="pre">x</span> <span class="pre">[4</span> <span class="pre">x</span> <span class="pre">i32]]</span></tt></td>
+<td>3x4 array of 32-bit integer values.</td>
+</tr>
+<tr class="row-even"><td><tt class="docutils literal"><span class="pre">[12</span> <span class="pre">x</span> <span class="pre">[10</span> <span class="pre">x</span> <span class="pre">float]]</span></tt></td>
+<td>12x10 array of single precision floating point values.</td>
+</tr>
+<tr class="row-odd"><td><tt class="docutils literal"><span class="pre">[2</span> <span class="pre">x</span> <span class="pre">[3</span> <span class="pre">x</span> <span class="pre">[4</span> <span class="pre">x</span> <span class="pre">i16]]]</span></tt></td>
+<td>2x3x4 array of 16-bit integer values.</td>
+</tr>
+</tbody>
+</table>
+<p>There is no restriction on indexing beyond the end of the array implied
+by a static type (though there are restrictions on indexing beyond the
+bounds of an allocated object in some cases). This means that
+single-dimension ‘variable sized array’ addressing can be implemented in
+LLVM with a zero length array type. An implementation of ‘pascal style
+arrays’ in LLVM could use the type “<tt class="docutils literal"><span class="pre">{</span> <span class="pre">i32,</span> <span class="pre">[0</span> <span class="pre">x</span> <span class="pre">float]}</span></tt>”, for
+example.</p>
+</div>
+<div class="section" id="structure-type">
+<span id="t-struct"></span><h5><a class="toc-backref" href="#id870">Structure Type</a><a class="headerlink" href="#structure-type" title="Permalink to this headline">¶</a></h5>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Overview:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<p>The structure type is used to represent a collection of data members
+together in memory. The elements of a structure may be any type that has
+a size.</p>
+<p>Structures in memory are accessed using ‘<tt class="docutils literal"><span class="pre">load</span></tt>‘ and ‘<tt class="docutils literal"><span class="pre">store</span></tt>‘ by
+getting a pointer to a field with the ‘<tt class="docutils literal"><span class="pre">getelementptr</span></tt>‘ instruction.
+Structures in registers are accessed using the ‘<tt class="docutils literal"><span class="pre">extractvalue</span></tt>‘ and
+‘<tt class="docutils literal"><span class="pre">insertvalue</span></tt>‘ instructions.</p>
+<p>Structures may optionally be “packed” structures, which indicate that
+the alignment of the struct is one byte, and that there is no padding
+between the elements. In non-packed structs, padding between field types
+is inserted as defined by the DataLayout string in the module, which is
+required to match what the underlying code generator expects.</p>
+<p>Structures can either be “literal” or “identified”. A literal structure
+is defined inline with other types (e.g. <tt class="docutils literal"><span class="pre">{i32,</span> <span class="pre">i32}*</span></tt>) whereas
+identified types are always defined at the top level with a name.
+Literal types are uniqued by their contents and can never be recursive
+or opaque since there is no way to write one. Identified types can be
+recursive, can be opaqued, and are never uniqued.</p>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Syntax:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<div class="highlight-python"><pre>%T1 = type { <type list> }     ; Identified normal struct type
+%T2 = type <{ <type list> }>   ; Identified packed struct type</pre>
+</div>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Examples:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<table border="1" class="docutils">
+<colgroup>
+<col width="14%" />
+<col width="86%" />
+</colgroup>
+<tbody valign="top">
+<tr class="row-odd"><td><tt class="docutils literal"><span class="pre">{</span> <span class="pre">i32,</span> <span class="pre">i32,</span> <span class="pre">i32</span> <span class="pre">}</span></tt></td>
+<td>A triple of three <tt class="docutils literal"><span class="pre">i32</span></tt> values</td>
+</tr>
+<tr class="row-even"><td><tt class="docutils literal"><span class="pre">{</span> <span class="pre">float,</span> <span class="pre">i32</span> <span class="pre">(i32)</span> <span class="pre">*</span> <span class="pre">}</span></tt></td>
+<td>A pair, where the first element is a <tt class="docutils literal"><span class="pre">float</span></tt> and the second element is a <a class="reference internal" href="#t-pointer"><em>pointer</em></a> to a <a class="reference internal" href="#t-function"><em>function</em></a> that takes an <tt class="docutils literal"><span class="pre">i32</span></tt>, returning an <tt class="docutils literal"><span class="pre">i32</span></tt>.</td>
+</tr>
+<tr class="row-odd"><td><tt class="docutils literal"><span class="pre"><{</span> <span class="pre">i8,</span> <span class="pre">i32</span> <span class="pre">}></span></tt></td>
+<td>A packed struct known to be 5 bytes in size.</td>
+</tr>
+</tbody>
+</table>
+</div>
+<div class="section" id="opaque-structure-types">
+<span id="t-opaque"></span><h5><a class="toc-backref" href="#id871">Opaque Structure Types</a><a class="headerlink" href="#opaque-structure-types" title="Permalink to this headline">¶</a></h5>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Overview:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<p>Opaque structure types are used to represent named structure types that
+do not have a body specified. This corresponds (for example) to the C
+notion of a forward declared structure.</p>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Syntax:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<div class="highlight-python"><pre>%X = type opaque
+%52 = type opaque</pre>
+</div>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Examples:</th><td class="field-body"></td>
+</tr>
+</tbody>
+</table>
+<table border="1" class="docutils">
+<colgroup>
+<col width="42%" />
+<col width="58%" />
+</colgroup>
+<tbody valign="top">
+<tr class="row-odd"><td><tt class="docutils literal"><span class="pre">opaque</span></tt></td>
+<td>An opaque type.</td>
+</tr>
+</tbody>
+</table>
+</div>
+</div>
+</div>
+</div>
+<div class="section" id="constants">
+<span id="id4"></span><h2><a class="toc-backref" href="#id872">Constants</a><a class="headerlink" href="#constants" title="Permalink to this headline">¶</a></h2>
+<p>LLVM has several different basic types of constants. This section
+describes them all and their syntax.</p>
+<div class="section" id="simple-constants">
+<h3><a class="toc-backref" href="#id873">Simple Constants</a><a class="headerlink" href="#simple-constants" title="Permalink to this headline">¶</a></h3>
+<dl class="docutils">
+<dt><strong>Boolean constants</strong></dt>
+<dd>The two strings ‘<tt class="docutils literal"><span class="pre">true</span></tt>‘ and ‘<tt class="docutils literal"><span class="pre">false</span></tt>‘ are both valid constants
+of the <tt class="docutils literal"><span class="pre">i1</span></tt> type.</dd>
+<dt><strong>Integer constants</strong></dt>
+<dd>Standard integers (such as ‘4’) are constants of the
+<a class="reference internal" href="#t-integer"><em>integer</em></a> type. Negative numbers may be used with
+integer types.</dd>
+<dt><strong>Floating point constants</strong></dt>
+<dd>Floating point constants use standard decimal notation (e.g.
+123.421), exponential notation (e.g. 1.23421e+2), or a more precise
+hexadecimal notation (see below). The assembler requires the exact
+decimal value of a floating-point constant. For example, the
+assembler accepts 1.25 but rejects 1.3 because 1.3 is a repeating
+decimal in binary. Floating point constants must have a <a class="reference internal" href="#t-floating"><em>floating
+point</em></a> type.</dd>
+<dt><strong>Null pointer constants</strong></dt>
+<dd>The identifier ‘<tt class="docutils literal"><span class="pre">null</span></tt>‘ is recognized as a null pointer constant
+and must be of <a class="reference internal" href="#t-pointer"><em>pointer type</em></a>.</dd>
+<dt><strong>Token constants</strong></dt>
+<dd>The identifier ‘<tt class="docutils literal"><span class="pre">none</span></tt>‘ is recognized as an empty token constant
+and must be of <a class="reference internal" href="#t-token"><em>token type</em></a>.</dd>
+</dl>
+<p>The one non-intuitive notation for constants is the hexadecimal form of
+floating point constants. For example, the form
+‘<tt class="docutils literal"><span class="pre">double</span>    <span class="pre">0x432ff973cafa8000</span></tt>‘ is equivalent to (but harder to read
+than) ‘<tt class="docutils literal"><span class="pre">double</span> <span class="pre">4.5e+15</span></tt>‘. The only time hexadecimal floating point
+constants are required (and the only time that they are generated by the
+disassembler) is when a floating point constant must be emitted but it
+cannot be represented as a decimal floating point number in a reasonable
+number of digits. For example, NaN’s, infinities, and other special
+values are represented in their IEEE hexadecimal format so that assembly
+and disassembly do not cause any bits to change in the constants.</p>
+<p>When using the hexadecimal form, constants of types half, float, and
+double are represented using the 16-digit form shown above (which
+matches the IEEE754 representation for double); half and float values
+must, however, be exactly representable as IEEE 754 half and single
+precision, respectively. Hexadecimal format is always used for long
+double, and there are three forms of long double. The 80-bit format used
+by x86 is represented as <tt class="docutils literal"><span class="pre">0xK</span></tt> followed by 20 hexadecimal digits. The
+128-bit format used by PowerPC (two adjacent doubles) is represented by
+<tt class="docutils literal"><span class="pre">0xM</span></tt> followed by 32 hexadecimal digits. The IEEE 128-bit format is
+represented by <tt class="docutils literal"><span class="pre">0xL</span></tt> followed by 32 hexadecimal digits. Long doubles
+will only work if they match the long double format on your target.
+The IEEE 16-bit format (half precision) is represented by <tt class="docutils literal"><span class="pre">0xH</span></tt>
+followed by 4 hexadecimal digits. All hexadecimal formats are big-endian
+(sign bit at the left).</p>
+<p>There are no constants of type x86_mmx.</p>
+</div>
+<div class="section" id="complex-constants">
+<span id="complexconstants"></span><h3><a class="toc-backref" href="#id874">Complex Constants</a><a class="headerlink" href="#complex-constants" title="Permalink to this headline">¶</a></h3>
+<p>Complex constants are a (potentially recursive) combination of simple
+constants and smaller complex constants.</p>
+<dl class="docutils">
+<dt><strong>Structure constants</strong></dt>
+<dd>Structure constants are represented with notation similar to
+structure type definitions (a comma separated list of elements,
+surrounded by braces (<tt class="docutils literal"><span class="pre">{}</span></tt>)). For example:
+“<tt class="docutils literal"><span class="pre">{</span> <span class="pre">i32</span> <span class="pre">4,</span> <span class="pre">float</span> <span class="pre">17.0,</span> <span class="pre">i32*</span> <span class="pre">@G</span> <span class="pre">}</span></tt>”, where “<tt class="docutils literal"><span class="pre">@G</span></tt>” is declared as
+“<tt class="docutils literal"><span class="pre">@G</span> <span class="pre">=</span> <span class="pre">external</span> <span class="pre">global</span> <span class="pre">i32</span></tt>”. Structure constants must have
+<a class="reference internal" href="#t-struct"><em>structure type</em></a>, and the number and types of elements
+must match those specified by the type.</dd>
+<dt><strong>Array constants</strong></dt>
+<dd>Array constants are represented with notation similar to array type
+definitions (a comma separated list of elements, surrounded by
+square brackets (<tt class="docutils literal"><span class="pre">[]</span></tt>)). For example:
+“<tt class="docutils literal"><span class="pre">[</span> <span class="pre">i32</span> <span class="pre">42,</span> <span class="pre">i32</span> <span class="pre">11,</span> <span class="pre">i32</span> <span class="pre">74</span> <span class="pre">]</span></tt>”. Array constants must have
+<a class="reference internal" href="#t-array"><em>array type</em></a>, and the number and types of elements must
+match those specified by the type. As a special case, character array
+constants may also be represented as a double-quoted string using the <tt class="docutils literal"><span class="pre">c</span></tt>
+prefix. For example: “<tt class="docutils literal"><span class="pre">c"Hello</span> <span class="pre">World\0A\00"</span></tt>”.</dd>
+<dt><strong>Vector constants</strong></dt>
+<dd>Vector constants are represented with notation similar to vector
+type definitions (a comma separated list of elements, surrounded by
+less-than/greater-than’s (<tt class="docutils literal"><span class="pre"><></span></tt>)). For example:
+“<tt class="docutils literal"><span class="pre"><</span> <span class="pre">i32</span> <span class="pre">42,</span> <span class="pre">i32</span> <span class="pre">11,</span> <span class="pre">i32</span> <span class="pre">74,</span> <span class="pre">i32</span> <span class="pre">100</span> <span class="pre">></span></tt>”. Vector constants
+must have <a class="reference internal" href="#t-vector"><em>vector type</em></a>, and the number and types of
+elements must match those specified by the type.</dd>
+<dt><strong>Zero initialization</strong></dt>
+<dd>The string ‘<tt class="docutils literal"><span class="pre">zeroinitializer</span></tt>‘ can be used to zero initialize a
+value to zero of <em>any</em> type, including scalar and
+<a class="reference internal" href="#t-aggregate"><em>aggregate</em></a> types. This is often used to avoid
+having to print large zero initializers (e.g. for large arrays) and
+is always exactly equivalent to using explicit zero initializers.</dd>
+<dt><strong>Metadata node</strong></dt>
+<dd>A metadata node is a constant tuple without types. For example:
+“<tt class="docutils literal"><span class="pre">!{!0,</span> <span class="pre">!{!2,</span> <span class="pre">!0},</span> <span class="pre">!"test"}</span></tt>”. Metadata can reference constant values,
+for example: “<tt class="docutils literal"><span class="pre">!{!0,</span> <span class="pre">i32</span> <span class="pre">0,</span> <span class="pre">i8*</span> <span class="pre">@global,</span> <span class="pre">i64</span> <span class="pre">(i64)*</span> <span class="pre">@function,</span> <span class="pre">!"str"}</span></tt>”.
+Unlike other typed constants that are meant to be interpreted as part of
+the instruction stream, metadata is a place to attach additional
+information such as debug info.</dd>
+</dl>
+</div>
+<div class="section" id="global-variable-and-function-addresses">
+<h3><a class="toc-backref" href="#id875">Global Variable and Function Addresses</a><a class="headerlink" href="#global-variable-and-function-addresses" title="Permalink to this headline">¶</a></h3>
+<p>The addresses of <a class="reference internal" href="#globalvars"><em>global variables</em></a> and
+<a class="reference internal" href="#functionstructure"><em>functions</em></a> are always implicitly valid
+(link-time) constants. These constants are explicitly referenced when
+the <a class="reference internal" href="#identifiers"><em>identifier for the global</em></a> is used and always have
+<a class="reference internal" href="#t-pointer"><em>pointer</em></a> type. For example, the following is a legal LLVM
+file:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="vg">@X</span> <span class="p">=</span> <span class="k">global</span> <span class="k">i32</span> <span class="m">17</span>
+<span class="vg">@Y</span> <span class="p">=</span> <span class="k">global</span> <span class="k">i32</span> <span class="m">42</span>
+<span class="vg">@Z</span> <span class="p">=</span> <span class="k">global</span> <span class="p">[</span><span class="m">2</span> <span class="k">x</span> <span class="k">i32</span><span class="p">*]</span> <span class="p">[</span> <span class="k">i32</span><span class="p">*</span> <span class="vg">@X</span><span class="p">,</span> <span class="k">i32</span><span class="p">*</span> <span class="vg">@Y</span> <span class="p">]</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="undefined-values">
+<span id="undefvalues"></span><h3><a class="toc-backref" href="#id876">Undefined Values</a><a class="headerlink" href="#undefined-values" title="Permalink to this headline">¶</a></h3>
+<p>The string ‘<tt class="docutils literal"><span class="pre">undef</span></tt>‘ can be used anywhere a constant is expected, and
+indicates that the user of the value may receive an unspecified
+bit-pattern. Undefined values may be of any type (other than ‘<tt class="docutils literal"><span class="pre">label</span></tt>‘
+or ‘<tt class="docutils literal"><span class="pre">void</span></tt>‘) and be used anywhere a constant is permitted.</p>
+<p>Undefined values are useful because they indicate to the compiler that
+the program is well defined no matter what value is used. This gives the
+compiler more freedom to optimize. Here are some examples of
+(potentially surprising) transformations that are valid (in pseudo IR):</p>
+<div class="highlight-llvm"><div class="highlight"><pre>  <span class="nv">%A</span> <span class="p">=</span> <span class="k">add</span> <span class="nv">%X</span><span class="p">,</span> <span class="k">undef</span>
+  <span class="nv">%B</span> <span class="p">=</span> <span class="k">sub</span> <span class="nv">%X</span><span class="p">,</span> <span class="k">undef</span>
+  <span class="nv">%C</span> <span class="p">=</span> <span class="k">xor</span> <span class="nv">%X</span><span class="p">,</span> <span class="k">undef</span>
+<span class="nl">Safe:</span>
+  <span class="nv">%A</span> <span class="p">=</span> <span class="k">undef</span>
+  <span class="nv">%B</span> <span class="p">=</span> <span class="k">undef</span>
+  <span class="nv">%C</span> <span class="p">=</span> <span class="k">undef</span>
+</pre></div>
+</div>
+<p>This is safe because all of the output bits are affected by the undef
+bits. Any output bit can have a zero or one depending on the input bits.</p>
+<div class="highlight-llvm"><div class="highlight"><pre>  <span class="nv">%A</span> <span class="p">=</span> <span class="k">or</span> <span class="nv">%X</span><span class="p">,</span> <span class="k">undef</span>
+  <span class="nv">%B</span> <span class="p">=</span> <span class="k">and</span> <span class="nv">%X</span><span class="p">,</span> <span class="k">undef</span>
+<span class="nl">Safe:</span>
+  <span class="nv">%A</span> <span class="p">=</span> <span class="m">-1</span>
+  <span class="nv">%B</span> <span class="p">=</span> <span class="m">0</span>
+<span class="nl">Safe:</span>
+  <span class="nv">%A</span> <span class="p">=</span> <span class="nv">%X</span>  <span class="c">;; By choosing undef as 0</span>
+  <span class="nv">%B</span> <span class="p">=</span> <span class="nv">%X</span>  <span class="c">;; By choosing undef as -1</span>
+<span class="nl">Unsafe:</span>
+  <span class="nv">%A</span> <span class="p">=</span> <span class="k">undef</span>
+  <span class="nv">%B</span> <span class="p">=</span> <span class="k">undef</span>
+</pre></div>
+</div>
+<p>These logical operations have bits that are not always affected by the
+input. For example, if <tt class="docutils literal"><span class="pre">%X</span></tt> has a zero bit, then the output of the
+‘<tt class="docutils literal"><span class="pre">and</span></tt>‘ operation will always be a zero for that bit, no matter what
+the corresponding bit from the ‘<tt class="docutils literal"><span class="pre">undef</span></tt>‘ is. As such, it is unsafe to
+optimize or assume that the result of the ‘<tt class="docutils literal"><span class="pre">and</span></tt>‘ is ‘<tt class="docutils literal"><span class="pre">undef</span></tt>‘.
+However, it is safe to assume that all bits of the ‘<tt class="docutils literal"><span class="pre">undef</span></tt>‘ could be
+0, and optimize the ‘<tt class="docutils literal"><span class="pre">and</span></tt>‘ to 0. Likewise, it is safe to assume that
+all the bits of the ‘<tt class="docutils literal"><span class="pre">undef</span></tt>‘ operand to the ‘<tt class="docutils literal"><span class="pre">or</span></tt>‘ could be set,
+allowing the ‘<tt class="docutils literal"><span class="pre">or</span></tt>‘ to be folded to -1.</p>
+<div class="highlight-llvm"><div class="highlight"><pre>  <span class="nv">%A</span> <span class="p">=</span> <span class="k">select</span> <span class="k">undef</span><span class="p">,</span> <span class="nv">%X</span><span class="p">,</span> <span class="nv">%Y</span>
+  <span class="nv">%B</span> <span class="p">=</span> <span class="k">select</span> <span class="k">undef</span><span class="p">,</span> <span class="m">42</span><span class="p">,</span> <span class="nv">%Y</span>
+  <span class="nv">%C</span> <span class="p">=</span> <span class="k">select</span> <span class="nv">%X</span><span class="p">,</span> <span class="nv">%Y</span><span class="p">,</span> <span class="k">undef</span>
+<span class="nl">Safe:</span>
+  <span class="nv">%A</span> <span class="p">=</span> <span class="nv">%X</span>     <span class="p">(</span><span class="k">or</span> <span class="nv">%Y</span><span class="p">)</span>
+  <span class="nv">%B</span> <span class="p">=</span> <span class="m">42</span>     <span class="p">(</span><span class="k">or</span> <span class="nv">%Y</span><span class="p">)</span>
+  <span class="nv">%C</span> <span class="p">=</span> <span class="nv">%Y</span>
+<span class="nl">Unsafe:</span>
+  <span class="nv">%A</span> <span class="p">=</span> <span class="k">undef</span>
+  <span class="nv">%B</span> <span class="p">=</span> <span class="k">undef</span>
+  <span class="nv">%C</span> <span class="p">=</span> <span class="k">undef</span>
+</pre></div>
+</div>
+<p>This set of examples shows that undefined ‘<tt class="docutils literal"><span class="pre">select</span></tt>‘ (and conditional
+branch) conditions can go <em>either way</em>, but they have to come from one
+of the two operands. In the <tt class="docutils literal"><span class="pre">%A</span></tt> example, if <tt class="docutils literal"><span class="pre">%X</span></tt> and <tt class="docutils literal"><span class="pre">%Y</span></tt> were
+both known to have a clear low bit, then <tt class="docutils literal"><span class="pre">%A</span></tt> would have to have a
+cleared low bit. However, in the <tt class="docutils literal"><span class="pre">%C</span></tt> example, the optimizer is
+allowed to assume that the ‘<tt class="docutils literal"><span class="pre">undef</span></tt>‘ operand could be the same as
+<tt class="docutils literal"><span class="pre">%Y</span></tt>, allowing the whole ‘<tt class="docutils literal"><span class="pre">select</span></tt>‘ to be eliminated.</p>
+<div class="highlight-text"><div class="highlight"><pre>  %A = xor undef, undef
+
+  %B = undef
+  %C = xor %B, %B
+
+  %D = undef
+  %E = icmp slt %D, 4
+  %F = icmp gte %D, 4
+
+Safe:
+  %A = undef
+  %B = undef
+  %C = undef
+  %D = undef
+  %E = undef
+  %F = undef
+</pre></div>
+</div>
+<p>This example points out that two ‘<tt class="docutils literal"><span class="pre">undef</span></tt>‘ operands are not
+necessarily the same. This can be surprising to people (and also matches
+C semantics) where they assume that “<tt class="docutils literal"><span class="pre">X^X</span></tt>” is always zero, even if
+<tt class="docutils literal"><span class="pre">X</span></tt> is undefined. This isn’t true for a number of reasons, but the
+short answer is that an ‘<tt class="docutils literal"><span class="pre">undef</span></tt>‘ “variable” can arbitrarily change
+its value over its “live range”. This is true because the variable
+doesn’t actually <em>have a live range</em>. Instead, the value is logically
+read from arbitrary registers that happen to be around when needed, so
+the value is not necessarily consistent over time. In fact, <tt class="docutils literal"><span class="pre">%A</span></tt> and
+<tt class="docutils literal"><span class="pre">%C</span></tt> need to have the same semantics or the core LLVM “replace all
+uses with” concept would not hold.</p>
+<div class="highlight-llvm"><div class="highlight"><pre>  <span class="nv">%A</span> <span class="p">=</span> <span class="k">fdiv</span> <span class="k">undef</span><span class="p">,</span> <span class="nv">%X</span>
+  <span class="nv">%B</span> <span class="p">=</span> <span class="k">fdiv</span> <span class="nv">%X</span><span class="p">,</span> <span class="k">undef</span>
+<span class="nl">Safe:</span>
+  <span class="nv">%A</span> <span class="p">=</span> <span class="k">undef</span>
+<span class="nl">b:</span> <span class="k">unreachable</span>
+</pre></div>
+</div>
+<p>These examples show the crucial difference between an <em>undefined value</em>
+and <em>undefined behavior</em>. An undefined value (like ‘<tt class="docutils literal"><span class="pre">undef</span></tt>‘) is
+allowed to have an arbitrary bit-pattern. This means that the <tt class="docutils literal"><span class="pre">%A</span></tt>
+operation can be constant folded to ‘<tt class="docutils literal"><span class="pre">undef</span></tt>‘, because the ‘<tt class="docutils literal"><span class="pre">undef</span></tt>‘
+could be an SNaN, and <tt class="docutils literal"><span class="pre">fdiv</span></tt> is not (currently) defined on SNaN’s.
+However, in the second example, we can make a more aggressive
+assumption: because the <tt class="docutils literal"><span class="pre">undef</span></tt> is allowed to be an arbitrary value,
+we are allowed to assume that it could be zero. Since a divide by zero
+has <em>undefined behavior</em>, we are allowed to assume that the operation
+does not execute at all. This allows us to delete the divide and all
+code after it. Because the undefined operation “can’t happen”, the
+optimizer can assume that it occurs in dead code.</p>
+<div class="highlight-text"><div class="highlight"><pre>a:  store undef -> %X
+b:  store %X -> undef
+Safe:
+a: <deleted>
+b: unreachable
+</pre></div>
+</div>
+<p>These examples reiterate the <tt class="docutils literal"><span class="pre">fdiv</span></tt> example: a store <em>of</em> an undefined
+value can be assumed to not have any effect; we can assume that the
+value is overwritten with bits that happen to match what was already
+there. However, a store <em>to</em> an undefined location could clobber
+arbitrary memory, therefore, it has undefined behavior.</p>
+</div>
+<div class="section" id="poison-values">
+<span id="poisonvalues"></span><h3><a class="toc-backref" href="#id877">Poison Values</a><a class="headerlink" href="#poison-values" title="Permalink to this headline">¶</a></h3>
+<p>Poison values are similar to <a class="reference internal" href="#undefvalues"><em>undef values</em></a>, however
+they also represent the fact that an instruction or constant expression
+that cannot evoke side effects has nevertheless detected a condition
+that results in undefined behavior.</p>
+<p>There is currently no way of representing a poison value in the IR; they
+only exist when produced by operations such as <a class="reference internal" href="#i-add"><em>add</em></a> with
+the <tt class="docutils literal"><span class="pre">nsw</span></tt> flag.</p>
+<p>Poison value behavior is defined in terms of value <em>dependence</em>:</p>
+<ul class="simple">
+<li>Values other than <a class="reference internal" href="#i-phi"><em>phi</em></a> nodes depend on their operands.</li>
+<li><a class="reference internal" href="#i-phi"><em>Phi</em></a> nodes depend on the operand corresponding to
+their dynamic predecessor basic block.</li>
+<li>Function arguments depend on the corresponding actual argument values
+in the dynamic callers of their functions.</li>
+<li><a class="reference internal" href="#i-call"><em>Call</em></a> instructions depend on the <a class="reference internal" href="#i-ret"><em>ret</em></a>
+instructions that dynamically transfer control back to them.</li>
+<li><a class="reference internal" href="#i-invoke"><em>Invoke</em></a> instructions depend on the
+<a class="reference internal" href="#i-ret"><em>ret</em></a>, <a class="reference internal" href="#i-resume"><em>resume</em></a>, or exception-throwing
+call instructions that dynamically transfer control back to them.</li>
+<li>Non-volatile loads and stores depend on the most recent stores to all
+of the referenced memory addresses, following the order in the IR
+(including loads and stores implied by intrinsics such as
+<a class="reference internal" href="#int-memcpy"><em>@llvm.memcpy</em></a>.)</li>
+<li>An instruction with externally visible side effects depends on the
+most recent preceding instruction with externally visible side
+effects, following the order in the IR. (This includes <a class="reference internal" href="#volatile"><em>volatile
+operations</em></a>.)</li>
+<li>An instruction <em>control-depends</em> on a <a class="reference internal" href="#terminators"><em>terminator
+instruction</em></a> if the terminator instruction has
+multiple successors and the instruction is always executed when
+control transfers to one of the successors, and may not be executed
+when control is transferred to another.</li>
+<li>Additionally, an instruction also <em>control-depends</em> on a terminator
+instruction if the set of instructions it otherwise depends on would
+be different if the terminator had transferred control to a different
+successor.</li>
+<li>Dependence is transitive.</li>
+</ul>
+<p>Poison values have the same behavior as <a class="reference internal" href="#undefvalues"><em>undef values</em></a>,
+with the additional effect that any instruction that has a <em>dependence</em>
+on a poison value has undefined behavior.</p>
+<p>Here are some examples:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nl">entry:</span>
+  <span class="nv">%poison</span> <span class="p">=</span> <span class="k">sub</span> <span class="k">nuw</span> <span class="k">i32</span> <span class="m">0</span><span class="p">,</span> <span class="m">1</span>           <span class="c">; Results in a poison value.</span>
+  <span class="nv">%still_poison</span> <span class="p">=</span> <span class="k">and</span> <span class="k">i32</span> <span class="nv">%poison</span><span class="p">,</span> <span class="m">0</span>   <span class="c">; 0, but also poison.</span>
+  <span class="nv">%poison_yet_again</span> <span class="p">=</span> <span class="k">getelementptr</span> <span class="k">i32</span><span class="p">,</span> <span class="k">i32</span><span class="p">*</span> <span class="vg">@h</span><span class="p">,</span> <span class="k">i32</span> <span class="nv">%still_poison</span>
+  <span class="k">store</span> <span class="k">i32</span> <span class="m">0</span><span class="p">,</span> <span class="k">i32</span><span class="p">*</span> <span class="nv">%poison_yet_again</span>  <span class="c">; memory at @h[0] is poisoned</span>
+
+  <span class="k">store</span> <span class="k">i32</span> <span class="nv">%poison</span><span class="p">,</span> <span class="k">i32</span><span class="p">*</span> <span class="vg">@g</span>           <span class="c">; Poison value stored to memory.</span>
+  <span class="nv">%poison2</span> <span class="p">=</span> <span class="k">load</span> <span class="k">i32</span><span class="p">,</span> <span class="k">i32</span><span class="p">*</span> <span class="vg">@g</span>         <span class="c">; Poison value loaded back from memory.</span>
+
+  <span class="k">store</span> <span class="k">volatile</span> <span class="k">i32</span> <span class="nv">%poison</span><span class="p">,</span> <span class="k">i32</span><span class="p">*</span> <span class="vg">@g</span>  <span class="c">; External observation; undefined behavior.</span>
+
+  <span class="nv">%narrowaddr</span> <span class="p">=</span> <span class="k">bitcast</span> <span class="k">i32</span><span class="p">*</span> <span class="vg">@g</span> <span class="k">to</span> <span class="k">i16</span><span class="p">*</span>
+  <span class="nv">%wideaddr</span> <span class="p">=</span> <span class="k">bitcast</span> <span class="k">i32</span><span class="p">*</span> <span class="vg">@g</span> <span class="k">to</span> <span class="k">i64</span><span class="p">*</span>
+  <span class="nv">%poison3</span> <span class="p">=</span> <span class="k">load</span> <span class="k">i16</span><span class="p">,</span> <span class="k">i16</span><span class="p">*</span> <span class="nv">%narrowaddr</span> <span class="c">; Returns a poison value.</span>
+  <span class="nv">%poison4</span> <span class="p">=</span> <span class="k">load</span> <span class="k">i64</span><span class="p">,</span> <span class="k">i64</span><span class="p">*</span> <span class="nv">%wideaddr</span>  <span class="c">; Returns a poison value.</span>
+
+  <span class="nv">%cmp</span> <span class="p">=</span> <span class="k">icmp</span> <span class="k">slt</span> <span class="k">i32</span> <span class="nv">%poison</span><span class="p">,</span> <span class="m">0</span>       <span class="c">; Returns a poison value.</span>
+  <span class="k">br</span> <span class="k">i1</span> <span class="nv">%cmp</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%true</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%end</span>  <span class="c">; Branch to either destination.</span>
+
+<span class="nl">true:</span>
+  <span class="k">store</span> <span class="k">volatile</span> <span class="k">i32</span> <span class="m">0</span><span class="p">,</span> <span class="k">i32</span><span class="p">*</span> <span class="vg">@g</span>        <span class="c">; This is control-dependent on %cmp, so</span>
+                                       <span class="c">; it has undefined behavior.</span>
+  <span class="k">br</span> <span class="kt">label</span> <span class="nv">%end</span>
+
+<span class="nl">end:</span>
+  <span class="nv">%p</span> <span class="p">=</span> <span class="k">phi</span> <span class="k">i32</span> <span class="p">[</span> <span class="m">0</span><span class="p">,</span> <span class="nv">%entry</span> <span class="p">],</span> <span class="p">[</span> <span class="m">1</span><span class="p">,</span> <span class="nv">%true</span> <span class="p">]</span>
+                                       <span class="c">; Both edges into this PHI are</span>
+                                       <span class="c">; control-dependent on %cmp, so this</span>
+                                       <span class="c">; always results in a poison value.</span>
+
+  <span class="k">store</span> <span class="k">volatile</span> <span class="k">i32</span> <span class="m">0</span><span class="p">,</span> <span class="k">i32</span><span class="p">*</span> <span class="vg">@g</span>        <span class="c">; This would depend on the store in %true</span>
+                                       <span class="c">; if %cmp is true, or the store in %entry</span>
+                                       <span class="c">; otherwise, so this is undefined behavior.</span>
+
+  <span class="k">br</span> <span class="k">i1</span> <span class="nv">%cmp</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%second_true</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%second_end</span>
+                                       <span class="c">; The same branch again, but this time the</span>
+                                       <span class="c">; true block doesn't have side effects.</span>
+
+<span class="nl">second_true:</span>
+  <span class="c">; No side effects!</span>
+  <span class="k">ret</span> <span class="kt">void</span>
+
+<span class="nl">second_end:</span>
+  <span class="k">store</span> <span class="k">volatile</span> <span class="k">i32</span> <span class="m">0</span><span class="p">,</span> <span class="k">i32</span><span class="p">*</span> <span class="vg">@g</span>        <span class="c">; This time, the instruction always depends</span>
+                                       <span class="c">; on the store in %end. Also, it is</span>
+                                       <span class="c">; control-equivalent to %end, so this is</span>
+                                       <span class="c">; well-defined (ignoring earlier undefined</span>
+                                       <span class="c">; behavior in this example).</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="addresses-of-basic-blocks">
+<span id="blockaddress"></span><h3><a class="toc-backref" href="#id878">Addresses of Basic Blocks</a><a class="headerlink" href="#addresses-of-basic-blocks" title="Permalink to this headline">¶</a></h3>
+<p><tt class="docutils literal"><span class="pre">blockaddress(@function,</span> <span class="pre">%block)</span></tt></p>
+<p>The ‘<tt class="docutils literal"><span class="pre">blockaddress</span></tt>‘ constant computes the address of the specified
+basic block in the specified function, and always has an <tt class="docutils literal"><span class="pre">i8*</span></tt> type.
+Taking the address of the entry block is illegal.</p>
+<p>This value only has defined behavior when used as an operand to the
+‘<a class="reference internal" href="#i-indirectbr"><em>indirectbr</em></a>‘ instruction, or for comparisons
+against null. Pointer equality tests between labels addresses results in
+undefined behavior — though, again, comparison against null is ok, and
+no label is equal to the null pointer. This may be passed around as an
+opaque pointer sized value as long as the bits are not inspected. This
+allows <tt class="docutils literal"><span class="pre">ptrtoint</span></tt> and arithmetic to be performed on these values so
+long as the original value is reconstituted before the <tt class="docutils literal"><span class="pre">indirectbr</span></tt>
+instruction.</p>
+<p>Finally, some targets may provide defined semantics when using the value
+as the operand to an inline assembly, but that is target specific.</p>
+</div>
+<div class="section" id="constant-expressions">
+<span id="constantexprs"></span><h3><a class="toc-backref" href="#id879">Constant Expressions</a><a class="headerlink" href="#constant-expressions" title="Permalink to this headline">¶</a></h3>
+<p>Constant expressions are used to allow expressions involving other
+constants to be used as constants. Constant expressions may be of any
+<a class="reference internal" href="#t-firstclass"><em>first class</em></a> type and may involve any LLVM operation
+that does not have side effects (e.g. load and call are not supported).
+The following is the syntax for constant expressions:</p>
+<dl class="docutils">
+<dt><tt class="docutils literal"><span class="pre">trunc</span> <span class="pre">(CST</span> <span class="pre">to</span> <span class="pre">TYPE)</span></tt></dt>
+<dd>Perform the <a class="reference internal" href="#i-trunc"><em>trunc operation</em></a> on constants.</dd>
+<dt><tt class="docutils literal"><span class="pre">zext</span> <span class="pre">(CST</span> <span class="pre">to</span> <span class="pre">TYPE)</span></tt></dt>
+<dd>Perform the <a class="reference internal" href="#i-zext"><em>zext operation</em></a> on constants.</dd>
+<dt><tt class="docutils literal"><span class="pre">sext</span> <span class="pre">(CST</span> <span class="pre">to</span> <span class="pre">TYPE)</span></tt></dt>
+<dd>Perform the <a class="reference internal" href="#i-sext"><em>sext operation</em></a> on constants.</dd>
+<dt><tt class="docutils literal"><span class="pre">fptrunc</span> <span class="pre">(CST</span> <span class="pre">to</span> <span class="pre">TYPE)</span></tt></dt>
+<dd>Truncate a floating point constant to another floating point type.
+The size of CST must be larger than the size of TYPE. Both types
+must be floating point.</dd>
+<dt><tt class="docutils literal"><span class="pre">fpext</span> <span class="pre">(CST</span> <span class="pre">to</span> <span class="pre">TYPE)</span></tt></dt>
+<dd>Floating point extend a constant to another type. The size of CST
+must be smaller or equal to the size of TYPE. Both types must be
+floating point.</dd>
+<dt><tt class="docutils literal"><span class="pre">fptoui</span> <span class="pre">(CST</span> <span class="pre">to</span> <span class="pre">TYPE)</span></tt></dt>
+<dd>Convert a floating point constant to the corresponding unsigned
+integer constant. TYPE must be a scalar or vector integer type. CST
+must be of scalar or vector floating point type. Both CST and TYPE
+must be scalars, or vectors of the same number of elements. If the
+value won’t fit in the integer type, the results are undefined.</dd>
+<dt><tt class="docutils literal"><span class="pre">fptosi</span> <span class="pre">(CST</span> <span class="pre">to</span> <span class="pre">TYPE)</span></tt></dt>
+<dd>Convert a floating point constant to the corresponding signed
+integer constant. TYPE must be a scalar or vector integer type. CST
+must be of scalar or vector floating point type. Both CST and TYPE
+must be scalars, or vectors of the same number of elements. If the
+value won’t fit in the integer type, the results are undefined.</dd>
+<dt><tt class="docutils literal"><span class="pre">uitofp</span> <span class="pre">(CST</span> <span class="pre">to</span> <span class="pre">TYPE)</span></tt></dt>
+<dd>Convert an unsigned integer constant to the corresponding floating
+point constant. TYPE must be a scalar or vector floating point type.
+CST must be of scalar or vector integer type. Both CST and TYPE must
+be scalars, or vectors of the same number of elements. If the value
+won’t fit in the floating point type, the results are undefined.</dd>
+<dt><tt class="docutils literal"><span class="pre">sitofp</span> <span class="pre">(CST</span> <span class="pre">to</span> <span class="pre">TYPE)</span></tt></dt>
+<dd>Convert a signed integer constant to the corresponding floating
+point constant. TYPE must be a scalar or vector floating point type.
+CST must be of scalar or vector integer type. Both CST and TYPE must
+be scalars, or vectors of the same number of elements. If the value
+won’t fit in the floating point type, the results are undefined.</dd>
+<dt><tt class="docutils literal"><span class="pre">ptrtoint</span> <span class="pre">(CST</span> <span class="pre">to</span> <span class="pre">TYPE)</span></tt></dt>
+<dd>Perform the <a class="reference internal" href="#i-ptrtoint"><em>ptrtoint operation</em></a> on constants.</dd>
+<dt><tt class="docutils literal"><span class="pre">inttoptr</span> <span class="pre">(CST</span> <span class="pre">to</span> <span class="pre">TYPE)</span></tt></dt>
+<dd>Perform the <a class="reference internal" href="#i-inttoptr"><em>inttoptr operation</em></a> on constants.
+This one is <em>really</em> dangerous!</dd>
+<dt><tt class="docutils literal"><span class="pre">bitcast</span> <span class="pre">(CST</span> <span class="pre">to</span> <span class="pre">TYPE)</span></tt></dt>
+<dd>Convert a constant, CST, to another TYPE.
+The constraints of the operands are the same as those for the
+<a class="reference internal" href="#i-bitcast"><em>bitcast instruction</em></a>.</dd>
+<dt><tt class="docutils literal"><span class="pre">addrspacecast</span> <span class="pre">(CST</span> <span class="pre">to</span> <span class="pre">TYPE)</span></tt></dt>
+<dd>Convert a constant pointer or constant vector of pointer, CST, to another
+TYPE in a different address space. The constraints of the operands are the
+same as those for the <a class="reference internal" href="#i-addrspacecast"><em>addrspacecast instruction</em></a>.</dd>
+<dt><tt class="docutils literal"><span class="pre">getelementptr</span> <span class="pre">(TY,</span> <span class="pre">CSTPTR,</span> <span class="pre">IDX0,</span> <span class="pre">IDX1,</span> <span class="pre">...)</span></tt>, <tt class="docutils literal"><span class="pre">getelementptr</span> <span class="pre">inbounds</span> <span class="pre">(TY,</span> <span class="pre">CSTPTR,</span> <span class="pre">IDX0,</span> <span class="pre">IDX1,</span> <span class="pre">...)</span></tt></dt>
+<dd>Perform the <a class="reference internal" href="#i-getelementptr"><em>getelementptr operation</em></a> on
+constants. As with the <a class="reference internal" href="#i-getelementptr"><em>getelementptr</em></a>
+instruction, the index list may have one or more indexes, which are
+required to make sense for the type of “pointer to TY”.</dd>
+<dt><tt class="docutils literal"><span class="pre">select</span> <span class="pre">(COND,</span> <span class="pre">VAL1,</span> <span class="pre">VAL2)</span></tt></dt>
+<dd>Perform the <a class="reference internal" href="#i-select"><em>select operation</em></a> on constants.</dd>
+<dt><tt class="docutils literal"><span class="pre">icmp</span> <span class="pre">COND</span> <span class="pre">(VAL1,</span> <span class="pre">VAL2)</span></tt></dt>
+<dd>Perform the <a class="reference internal" href="#i-icmp"><em>icmp operation</em></a> on constants.</dd>
+<dt><tt class="docutils literal"><span class="pre">fcmp</span> <span class="pre">COND</span> <span class="pre">(VAL1,</span> <span class="pre">VAL2)</span></tt></dt>
+<dd>Perform the <a class="reference internal" href="#i-fcmp"><em>fcmp operation</em></a> on constants.</dd>
+<dt><tt class="docutils literal"><span class="pre">extractelement</span> <span class="pre">(VAL,</span> <span class="pre">IDX)</span></tt></dt>
+<dd>Perform the <a class="reference internal" href="#i-extractelement"><em>extractelement operation</em></a> on
+constants.</dd>
+<dt><tt class="docutils literal"><span class="pre">insertelement</span> <span class="pre">(VAL,</span> <span class="pre">ELT,</span> <span class="pre">IDX)</span></tt></dt>
+<dd>Perform the <a class="reference internal" href="#i-insertelement"><em>insertelement operation</em></a> on
+constants.</dd>
+<dt><tt class="docutils literal"><span class="pre">shufflevector</span> <span class="pre">(VEC1,</span> <span class="pre">VEC2,</span> <span class="pre">IDXMASK)</span></tt></dt>
+<dd>Perform the <a class="reference internal" href="#i-shufflevector"><em>shufflevector operation</em></a> on
+constants.</dd>
+<dt><tt class="docutils literal"><span class="pre">extractvalue</span> <span class="pre">(VAL,</span> <span class="pre">IDX0,</span> <span class="pre">IDX1,</span> <span class="pre">...)</span></tt></dt>
+<dd>Perform the <a class="reference internal" href="#i-extractvalue"><em>extractvalue operation</em></a> on
+constants. The index list is interpreted in a similar manner as
+indices in a ‘<a class="reference internal" href="#i-getelementptr"><em>getelementptr</em></a>‘ operation. At
+least one index value must be specified.</dd>
+<dt><tt class="docutils literal"><span class="pre">insertvalue</span> <span class="pre">(VAL,</span> <span class="pre">ELT,</span> <span class="pre">IDX0,</span> <span class="pre">IDX1,</span> <span class="pre">...)</span></tt></dt>
+<dd>Perform the <a class="reference internal" href="#i-insertvalue"><em>insertvalue operation</em></a> on constants.
+The index list is interpreted in a similar manner as indices in a
+‘<a class="reference internal" href="#i-getelementptr"><em>getelementptr</em></a>‘ operation. At least one index
+value must be specified.</dd>
+<dt><tt class="docutils literal"><span class="pre">OPCODE</span> <span class="pre">(LHS,</span> <span class="pre">RHS)</span></tt></dt>
+<dd>Perform the specified operation of the LHS and RHS constants. OPCODE
+may be any of the <a class="reference internal" href="#binaryops"><em>binary</em></a> or <a class="reference internal" href="#bitwiseops"><em>bitwise
+binary</em></a> operations. The constraints on operands are
+the same as those for the corresponding instruction (e.g. no bitwise
+operations on floating point values are allowed).</dd>
+</dl>
+</div>
+</div>
+<div class="section" id="other-values">
+<h2><a class="toc-backref" href="#id880">Other Values</a><a class="headerlink" href="#other-values" title="Permalink to this headline">¶</a></h2>
+<div class="section" id="inline-assembler-expressions">
+<span id="inlineasmexprs"></span><h3><a class="toc-backref" href="#id881">Inline Assembler Expressions</a><a class="headerlink" href="#inline-assembler-expressions" title="Permalink to this headline">¶</a></h3>
+<p>LLVM supports inline assembler expressions (as opposed to <a class="reference internal" href="#moduleasm"><em>Module-Level
+Inline Assembly</em></a>) through the use of a special value. This value
+represents the inline assembler as a template string (containing the
+instructions to emit), a list of operand constraints (stored as a string), a
+flag that indicates whether or not the inline asm expression has side effects,
+and a flag indicating whether the function containing the asm needs to align its
+stack conservatively.</p>
+<p>The template string supports argument substitution of the operands using “<tt class="docutils literal"><span class="pre">$</span></tt>”
+followed by a number, to indicate substitution of the given register/memory
+location, as specified by the constraint string. “<tt class="docutils literal"><span class="pre">${NUM:MODIFIER}</span></tt>” may also
+be used, where <tt class="docutils literal"><span class="pre">MODIFIER</span></tt> is a target-specific annotation for how to print the
+operand (See <a class="reference internal" href="#inline-asm-modifiers"><em>Asm template argument modifiers</em></a>).</p>
+<p>A literal “<tt class="docutils literal"><span class="pre">$</span></tt>” may be included by using “<tt class="docutils literal"><span class="pre">$$</span></tt>” in the template. To include
+other special characters into the output, the usual “<tt class="docutils literal"><span class="pre">\XX</span></tt>” escapes may be
+used, just as in other strings. Note that after template substitution, the
+resulting assembly string is parsed by LLVM’s integrated assembler unless it is
+disabled – even when emitting a <tt class="docutils literal"><span class="pre">.s</span></tt> file – and thus must contain assembly
+syntax known to LLVM.</p>
+<p>LLVM also supports a few more substitions useful for writing inline assembly:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">${:uid}</span></tt>: Expands to a decimal integer unique to this inline assembly blob.
+This substitution is useful when declaring a local label. Many standard
+compiler optimizations, such as inlining, may duplicate an inline asm blob.
+Adding a blob-unique identifier ensures that the two labels will not conflict
+during assembly. This is used to implement <a class="reference external" href="https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html">GCC’s %= special format
+string</a>.</li>
+<li><tt class="docutils literal"><span class="pre">${:comment}</span></tt>: Expands to the comment character of the current target’s
+assembly dialect. This is usually <tt class="docutils literal"><span class="pre">#</span></tt>, but many targets use other strings,
+such as <tt class="docutils literal"><span class="pre">;</span></tt>, <tt class="docutils literal"><span class="pre">//</span></tt>, or <tt class="docutils literal"><span class="pre">!</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">${:private}</span></tt>: Expands to the assembler private label prefix. Labels with
+this prefix will not appear in the symbol table of the assembled object.
+Typically the prefix is <tt class="docutils literal"><span class="pre">L</span></tt>, but targets may use other strings. <tt class="docutils literal"><span class="pre">.L</span></tt> is
+relatively popular.</li>
+</ul>
+<p>LLVM’s support for inline asm is modeled closely on the requirements of Clang’s
+GCC-compatible inline-asm support. Thus, the feature-set and the constraint and
+modifier codes listed here are similar or identical to those in GCC’s inline asm
+support. However, to be clear, the syntax of the template and constraint strings
+described here is <em>not</em> the same as the syntax accepted by GCC and Clang, and,
+while most constraint letters are passed through as-is by Clang, some get
+translated to other codes when converting from the C source to the LLVM
+assembly.</p>
+<p>An example inline assembler expression is:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="k">i32</span> <span class="p">(</span><span class="k">i32</span><span class="p">)</span> <span class="k">asm</span> <span class="s">"bswap $0"</span><span class="p">,</span> <span class="s">"=r,r"</span>
+</pre></div>
+</div>
+<p>Inline assembler expressions may <strong>only</strong> be used as the callee operand
+of a <a class="reference internal" href="#i-call"><em>call</em></a> or an <a class="reference internal" href="#i-invoke"><em>invoke</em></a> instruction.
+Thus, typically we have:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%X</span> <span class="p">=</span> <span class="k">call</span> <span class="k">i32</span> <span class="k">asm</span> <span class="s">"bswap $0"</span><span class="p">,</span> <span class="s">"=r,r"</span><span class="p">(</span><span class="k">i32</span> <span class="nv">%Y</span><span class="p">)</span>
+</pre></div>
+</div>
+<p>Inline asms with side effects not visible in the constraint list must be
+marked as having side effects. This is done through the use of the
+‘<tt class="docutils literal"><span class="pre">sideeffect</span></tt>‘ keyword, like so:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="k">call</span> <span class="kt">void</span> <span class="k">asm</span> <span class="k">sideeffect</span> <span class="s">"eieio"</span><span class="p">,</span> <span class="s">""</span><span class="p">()</span>
+</pre></div>
+</div>
+<p>In some cases inline asms will contain code that will not work unless
+the stack is aligned in some way, such as calls or SSE instructions on
+x86, yet will not contain code that does that alignment within the asm.
+The compiler should make conservative assumptions about what the asm
+might contain and should generate its usual stack alignment code in the
+prologue if the ‘<tt class="docutils literal"><span class="pre">alignstack</span></tt>‘ keyword is present:</p>
+<div class="highlight-llvm"><pre>call void asm alignstack "eieio", ""()</pre>
+</div>
+<p>Inline asms also support using non-standard assembly dialects. The
+assumed dialect is ATT. When the ‘<tt class="docutils literal"><span class="pre">inteldialect</span></tt>‘ keyword is present,
+the inline asm is using the Intel dialect. Currently, ATT and Intel are
+the only supported dialects. An example is:</p>
+<div class="highlight-llvm"><pre>call void asm inteldialect "eieio", ""()</pre>
+</div>
+<p>If multiple keywords appear the ‘<tt class="docutils literal"><span class="pre">sideeffect</span></tt>‘ keyword must come
+first, the ‘<tt class="docutils literal"><span class="pre">alignstack</span></tt>‘ keyword second and the ‘<tt class="docutils literal"><span class="pre">inteldialect</span></tt>‘
+keyword last.</p>
+<div class="section" id="inline-asm-constraint-string">
+<h4><a class="toc-backref" href="#id882">Inline Asm Constraint String</a><a class="headerlink" href="#inline-asm-constraint-string" title="Permalink to this headline">¶</a></h4>
+<p>The constraint list is a comma-separated string, each element containing one or
+more constraint codes.</p>
+<p>For each element in the constraint list an appropriate register or memory
+operand will be chosen, and it will be made available to assembly template
+string expansion as <tt class="docutils literal"><span class="pre">$0</span></tt> for the first constraint in the list, <tt class="docutils literal"><span class="pre">$1</span></tt> for the
+second, etc.</p>
+<p>There are three different types of constraints, which are distinguished by a
+prefix symbol in front of the constraint code: Output, Input, and Clobber. The
+constraints must always be given in that order: outputs first, then inputs, then
+clobbers. They cannot be intermingled.</p>
+<p>There are also three different categories of constraint codes:</p>
+<ul class="simple">
+<li>Register constraint. This is either a register class, or a fixed physical
+register. This kind of constraint will allocate a register, and if necessary,
+bitcast the argument or result to the appropriate type.</li>
+<li>Memory constraint. This kind of constraint is for use with an instruction
+taking a memory operand. Different constraints allow for different addressing
+modes used by the target.</li>
+<li>Immediate value constraint. This kind of constraint is for an integer or other
+immediate value which can be rendered directly into an instruction. The
+various target-specific constraints allow the selection of a value in the
+proper range for the instruction you wish to use it with.</li>
+</ul>
+<div class="section" id="output-constraints">
+<h5><a class="toc-backref" href="#id883">Output constraints</a><a class="headerlink" href="#output-constraints" title="Permalink to this headline">¶</a></h5>
+<p>Output constraints are specified by an “<tt class="docutils literal"><span class="pre">=</span></tt>” prefix (e.g. “<tt class="docutils literal"><span class="pre">=r</span></tt>”). This
+indicates that the assembly will write to this operand, and the operand will
+then be made available as a return value of the <tt class="docutils literal"><span class="pre">asm</span></tt> expression. Output
+constraints do not consume an argument from the call instruction. (Except, see
+below about indirect outputs).</p>
+<p>Normally, it is expected that no output locations are written to by the assembly
+expression until <em>all</em> of the inputs have been read. As such, LLVM may assign
+the same register to an output and an input. If this is not safe (e.g. if the
+assembly contains two instructions, where the first writes to one output, and
+the second reads an input and writes to a second output), then the “<tt class="docutils literal"><span class="pre">&</span></tt>”
+modifier must be used (e.g. “<tt class="docutils literal"><span class="pre">=&r</span></tt>”) to specify that the output is an
+“early-clobber” output. Marking an output as “early-clobber” ensures that LLVM
+will not use the same register for any inputs (other than an input tied to this
+output).</p>
+</div>
+<div class="section" id="input-constraints">
+<h5><a class="toc-backref" href="#id884">Input constraints</a><a class="headerlink" href="#input-constraints" title="Permalink to this headline">¶</a></h5>
+<p>Input constraints do not have a prefix – just the constraint codes. Each input
+constraint will consume one argument from the call instruction. It is not
+permitted for the asm to write to any input register or memory location (unless
+that input is tied to an output). Note also that multiple inputs may all be
+assigned to the same register, if LLVM can determine that they necessarily all
+contain the same value.</p>
+<p>Instead of providing a Constraint Code, input constraints may also “tie”
+themselves to an output constraint, by providing an integer as the constraint
+string. Tied inputs still consume an argument from the call instruction, and
+take up a position in the asm template numbering as is usual – they will simply
+be constrained to always use the same register as the output they’ve been tied
+to. For example, a constraint string of “<tt class="docutils literal"><span class="pre">=r,0</span></tt>” says to assign a register for
+output, and use that register as an input as well (it being the 0’th
+constraint).</p>
+<p>It is permitted to tie an input to an “early-clobber” output. In that case, no
+<em>other</em> input may share the same register as the input tied to the early-clobber
+(even when the other input has the same value).</p>
+<p>You may only tie an input to an output which has a register constraint, not a
+memory constraint. Only a single input may be tied to an output.</p>
+<p>There is also an “interesting” feature which deserves a bit of explanation: if a
+register class constraint allocates a register which is too small for the value
+type operand provided as input, the input value will be split into multiple
+registers, and all of them passed to the inline asm.</p>
+<p>However, this feature is often not as useful as you might think.</p>
+<p>Firstly, the registers are <em>not</em> guaranteed to be consecutive. So, on those
+architectures that have instructions which operate on multiple consecutive
+instructions, this is not an appropriate way to support them. (e.g. the 32-bit
+SparcV8 has a 64-bit load, which instruction takes a single 32-bit register. The
+hardware then loads into both the named register, and the next register. This
+feature of inline asm would not be useful to support that.)</p>
+<p>A few of the targets provide a template string modifier allowing explicit access
+to the second register of a two-register operand (e.g. MIPS <tt class="docutils literal"><span class="pre">L</span></tt>, <tt class="docutils literal"><span class="pre">M</span></tt>, and
+<tt class="docutils literal"><span class="pre">D</span></tt>). On such an architecture, you can actually access the second allocated
+register (yet, still, not any subsequent ones). But, in that case, you’re still
+probably better off simply splitting the value into two separate operands, for
+clarity. (e.g. see the description of the <tt class="docutils literal"><span class="pre">A</span></tt> constraint on X86, which,
+despite existing only for use with this feature, is not really a good idea to
+use)</p>
+</div>
+<div class="section" id="indirect-inputs-and-outputs">
+<h5><a class="toc-backref" href="#id885">Indirect inputs and outputs</a><a class="headerlink" href="#indirect-inputs-and-outputs" title="Permalink to this headline">¶</a></h5>
+<p>Indirect output or input constraints can be specified by the “<tt class="docutils literal"><span class="pre">*</span></tt>” modifier
+(which goes after the “<tt class="docutils literal"><span class="pre">=</span></tt>” in case of an output). This indicates that the asm
+will write to or read from the contents of an <em>address</em> provided as an input
+argument. (Note that in this way, indirect outputs act more like an <em>input</em> than
+an output: just like an input, they consume an argument of the call expression,
+rather than producing a return value. An indirect output constraint is an
+“output” only in that the asm is expected to write to the contents of the input
+memory location, instead of just read from it).</p>
+<p>This is most typically used for memory constraint, e.g. “<tt class="docutils literal"><span class="pre">=*m</span></tt>”, to pass the
+address of a variable as a value.</p>
+<p>It is also possible to use an indirect <em>register</em> constraint, but only on output
+(e.g. “<tt class="docutils literal"><span class="pre">=*r</span></tt>”). This will cause LLVM to allocate a register for an output
+value normally, and then, separately emit a store to the address provided as
+input, after the provided inline asm. (It’s not clear what value this
+functionality provides, compared to writing the store explicitly after the asm
+statement, and it can only produce worse code, since it bypasses many
+optimization passes. I would recommend not using it.)</p>
+</div>
+<div class="section" id="clobber-constraints">
+<h5><a class="toc-backref" href="#id886">Clobber constraints</a><a class="headerlink" href="#clobber-constraints" title="Permalink to this headline">¶</a></h5>
+<p>A clobber constraint is indicated by a “<tt class="docutils literal"><span class="pre">~</span></tt>” prefix. A clobber does not
+consume an input operand, nor generate an output. Clobbers cannot use any of the
+general constraint code letters – they may use only explicit register
+constraints, e.g. “<tt class="docutils literal"><span class="pre">~{eax}</span></tt>”. The one exception is that a clobber string of
+“<tt class="docutils literal"><span class="pre">~{memory}</span></tt>” indicates that the assembly writes to arbitrary undeclared
+memory locations – not only the memory pointed to by a declared indirect
+output.</p>
+<p>Note that clobbering named registers that are also present in output
+constraints is not legal.</p>
+</div>
+<div class="section" id="constraint-codes">
+<h5><a class="toc-backref" href="#id887">Constraint Codes</a><a class="headerlink" href="#constraint-codes" title="Permalink to this headline">¶</a></h5>
+<p>After a potential prefix comes constraint code, or codes.</p>
+<p>A Constraint Code is either a single letter (e.g. “<tt class="docutils literal"><span class="pre">r</span></tt>”), a “<tt class="docutils literal"><span class="pre">^</span></tt>” character
+followed by two letters (e.g. “<tt class="docutils literal"><span class="pre">^wc</span></tt>”), or “<tt class="docutils literal"><span class="pre">{</span></tt>” register-name “<tt class="docutils literal"><span class="pre">}</span></tt>”
+(e.g. “<tt class="docutils literal"><span class="pre">{eax}</span></tt>”).</p>
+<p>The one and two letter constraint codes are typically chosen to be the same as
+GCC’s constraint codes.</p>
+<p>A single constraint may include one or more than constraint code in it, leaving
+it up to LLVM to choose which one to use. This is included mainly for
+compatibility with the translation of GCC inline asm coming from clang.</p>
+<p>There are two ways to specify alternatives, and either or both may be used in an
+inline asm constraint list:</p>
+<ol class="arabic simple">
+<li>Append the codes to each other, making a constraint code set. E.g. “<tt class="docutils literal"><span class="pre">im</span></tt>”
+or “<tt class="docutils literal"><span class="pre">{eax}m</span></tt>”. This means “choose any of the options in the set”. The
+choice of constraint is made independently for each constraint in the
+constraint list.</li>
+<li>Use “<tt class="docutils literal"><span class="pre">|</span></tt>” between constraint code sets, creating alternatives. Every
+constraint in the constraint list must have the same number of alternative
+sets. With this syntax, the same alternative in <em>all</em> of the items in the
+constraint list will be chosen together.</li>
+</ol>
+<p>Putting those together, you might have a two operand constraint string like
+<tt class="docutils literal"><span class="pre">"rm|r,ri|rm"</span></tt>. This indicates that if operand 0 is <tt class="docutils literal"><span class="pre">r</span></tt> or <tt class="docutils literal"><span class="pre">m</span></tt>, then
+operand 1 may be one of <tt class="docutils literal"><span class="pre">r</span></tt> or <tt class="docutils literal"><span class="pre">i</span></tt>. If operand 0 is <tt class="docutils literal"><span class="pre">r</span></tt>, then operand 1
+may be one of <tt class="docutils literal"><span class="pre">r</span></tt> or <tt class="docutils literal"><span class="pre">m</span></tt>. But, operand 0 and 1 cannot both be of type m.</p>
+<p>However, the use of either of the alternatives features is <em>NOT</em> recommended, as
+LLVM is not able to make an intelligent choice about which one to use. (At the
+point it currently needs to choose, not enough information is available to do so
+in a smart way.) Thus, it simply tries to make a choice that’s most likely to
+compile, not one that will be optimal performance. (e.g., given “<tt class="docutils literal"><span class="pre">rm</span></tt>”, it’ll
+always choose to use memory, not registers). And, if given multiple registers,
+or multiple register classes, it will simply choose the first one. (In fact, it
+doesn’t currently even ensure explicitly specified physical registers are
+unique, so specifying multiple physical registers as alternatives, like
+<tt class="docutils literal"><span class="pre">{r11}{r12},{r11}{r12}</span></tt>, will assign r11 to both operands, not at all what was
+intended.)</p>
+</div>
+<div class="section" id="supported-constraint-code-list">
+<h5><a class="toc-backref" href="#id888">Supported Constraint Code List</a><a class="headerlink" href="#supported-constraint-code-list" title="Permalink to this headline">¶</a></h5>
+<p>The constraint codes are, in general, expected to behave the same way they do in
+GCC. LLVM’s support is often implemented on an ‘as-needed’ basis, to support C
+inline asm code which was supported by GCC. A mismatch in behavior between LLVM
+and GCC likely indicates a bug in LLVM.</p>
+<p>Some constraint codes are typically supported by all targets:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">r</span></tt>: A register in the target’s general purpose register class.</li>
+<li><tt class="docutils literal"><span class="pre">m</span></tt>: A memory address operand. It is target-specific what addressing modes
+are supported, typical examples are register, or register + register offset,
+or register + immediate offset (of some target-specific size).</li>
+<li><tt class="docutils literal"><span class="pre">i</span></tt>: An integer constant (of target-specific width). Allows either a simple
+immediate, or a relocatable value.</li>
+<li><tt class="docutils literal"><span class="pre">n</span></tt>: An integer constant – <em>not</em> including relocatable values.</li>
+<li><tt class="docutils literal"><span class="pre">s</span></tt>: An integer constant, but allowing <em>only</em> relocatable values.</li>
+<li><tt class="docutils literal"><span class="pre">X</span></tt>: Allows an operand of any kind, no constraint whatsoever. Typically
+useful to pass a label for an asm branch or call.</li>
+<li><tt class="docutils literal"><span class="pre">{register-name}</span></tt>: Requires exactly the named physical register.</li>
+</ul>
+<p>Other constraints are target-specific:</p>
+<p>AArch64:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">z</span></tt>: An immediate integer 0. Outputs <tt class="docutils literal"><span class="pre">WZR</span></tt> or <tt class="docutils literal"><span class="pre">XZR</span></tt>, as appropriate.</li>
+<li><tt class="docutils literal"><span class="pre">I</span></tt>: An immediate integer valid for an <tt class="docutils literal"><span class="pre">ADD</span></tt> or <tt class="docutils literal"><span class="pre">SUB</span></tt> instruction,
+i.e. 0 to 4095 with optional shift by 12.</li>
+<li><tt class="docutils literal"><span class="pre">J</span></tt>: An immediate integer that, when negated, is valid for an <tt class="docutils literal"><span class="pre">ADD</span></tt> or
+<tt class="docutils literal"><span class="pre">SUB</span></tt> instruction, i.e. -1 to -4095 with optional left shift by 12.</li>
+<li><tt class="docutils literal"><span class="pre">K</span></tt>: An immediate integer that is valid for the ‘bitmask immediate 32’ of a
+logical instruction like <tt class="docutils literal"><span class="pre">AND</span></tt>, <tt class="docutils literal"><span class="pre">EOR</span></tt>, or <tt class="docutils literal"><span class="pre">ORR</span></tt> with a 32-bit register.</li>
+<li><tt class="docutils literal"><span class="pre">L</span></tt>: An immediate integer that is valid for the ‘bitmask immediate 64’ of a
+logical instruction like <tt class="docutils literal"><span class="pre">AND</span></tt>, <tt class="docutils literal"><span class="pre">EOR</span></tt>, or <tt class="docutils literal"><span class="pre">ORR</span></tt> with a 64-bit register.</li>
+<li><tt class="docutils literal"><span class="pre">M</span></tt>: An immediate integer for use with the <tt class="docutils literal"><span class="pre">MOV</span></tt> assembly alias on a
+32-bit register. This is a superset of <tt class="docutils literal"><span class="pre">K</span></tt>: in addition to the bitmask
+immediate, also allows immediate integers which can be loaded with a single
+<tt class="docutils literal"><span class="pre">MOVZ</span></tt> or <tt class="docutils literal"><span class="pre">MOVL</span></tt> instruction.</li>
+<li><tt class="docutils literal"><span class="pre">N</span></tt>: An immediate integer for use with the <tt class="docutils literal"><span class="pre">MOV</span></tt> assembly alias on a
+64-bit register. This is a superset of <tt class="docutils literal"><span class="pre">L</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">Q</span></tt>: Memory address operand must be in a single register (no
+offsets). (However, LLVM currently does this for the <tt class="docutils literal"><span class="pre">m</span></tt> constraint as
+well.)</li>
+<li><tt class="docutils literal"><span class="pre">r</span></tt>: A 32 or 64-bit integer register (W* or X*).</li>
+<li><tt class="docutils literal"><span class="pre">w</span></tt>: A 32, 64, or 128-bit floating-point/SIMD register.</li>
+<li><tt class="docutils literal"><span class="pre">x</span></tt>: A lower 128-bit floating-point/SIMD register (<tt class="docutils literal"><span class="pre">V0</span></tt> to <tt class="docutils literal"><span class="pre">V15</span></tt>).</li>
+</ul>
+<p>AMDGPU:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">r</span></tt>: A 32 or 64-bit integer register.</li>
+<li><tt class="docutils literal"><span class="pre">[0-9]v</span></tt>: The 32-bit VGPR register, number 0-9.</li>
+<li><tt class="docutils literal"><span class="pre">[0-9]s</span></tt>: The 32-bit SGPR register, number 0-9.</li>
+</ul>
+<p>All ARM modes:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">Q</span></tt>, <tt class="docutils literal"><span class="pre">Um</span></tt>, <tt class="docutils literal"><span class="pre">Un</span></tt>, <tt class="docutils literal"><span class="pre">Uq</span></tt>, <tt class="docutils literal"><span class="pre">Us</span></tt>, <tt class="docutils literal"><span class="pre">Ut</span></tt>, <tt class="docutils literal"><span class="pre">Uv</span></tt>, <tt class="docutils literal"><span class="pre">Uy</span></tt>: Memory address
+operand. Treated the same as operand <tt class="docutils literal"><span class="pre">m</span></tt>, at the moment.</li>
+</ul>
+<p>ARM and ARM’s Thumb2 mode:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">j</span></tt>: An immediate integer between 0 and 65535 (valid for <tt class="docutils literal"><span class="pre">MOVW</span></tt>)</li>
+<li><tt class="docutils literal"><span class="pre">I</span></tt>: An immediate integer valid for a data-processing instruction.</li>
+<li><tt class="docutils literal"><span class="pre">J</span></tt>: An immediate integer between -4095 and 4095.</li>
+<li><tt class="docutils literal"><span class="pre">K</span></tt>: An immediate integer whose bitwise inverse is valid for a
+data-processing instruction. (Can be used with template modifier “<tt class="docutils literal"><span class="pre">B</span></tt>” to
+print the inverted value).</li>
+<li><tt class="docutils literal"><span class="pre">L</span></tt>: An immediate integer whose negation is valid for a data-processing
+instruction. (Can be used with template modifier “<tt class="docutils literal"><span class="pre">n</span></tt>” to print the negated
+value).</li>
+<li><tt class="docutils literal"><span class="pre">M</span></tt>: A power of two or a integer between 0 and 32.</li>
+<li><tt class="docutils literal"><span class="pre">N</span></tt>: Invalid immediate constraint.</li>
+<li><tt class="docutils literal"><span class="pre">O</span></tt>: Invalid immediate constraint.</li>
+<li><tt class="docutils literal"><span class="pre">r</span></tt>: A general-purpose 32-bit integer register (<tt class="docutils literal"><span class="pre">r0-r15</span></tt>).</li>
+<li><tt class="docutils literal"><span class="pre">l</span></tt>: In Thumb2 mode, low 32-bit GPR registers (<tt class="docutils literal"><span class="pre">r0-r7</span></tt>). In ARM mode, same
+as <tt class="docutils literal"><span class="pre">r</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">h</span></tt>: In Thumb2 mode, a high 32-bit GPR register (<tt class="docutils literal"><span class="pre">r8-r15</span></tt>). In ARM mode,
+invalid.</li>
+<li><tt class="docutils literal"><span class="pre">w</span></tt>: A 32, 64, or 128-bit floating-point/SIMD register: <tt class="docutils literal"><span class="pre">s0-s31</span></tt>,
+<tt class="docutils literal"><span class="pre">d0-d31</span></tt>, or <tt class="docutils literal"><span class="pre">q0-q15</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">x</span></tt>: A 32, 64, or 128-bit floating-point/SIMD register: <tt class="docutils literal"><span class="pre">s0-s15</span></tt>,
+<tt class="docutils literal"><span class="pre">d0-d7</span></tt>, or <tt class="docutils literal"><span class="pre">q0-q3</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">t</span></tt>: A floating-point/SIMD register, only supports 32-bit values:
+<tt class="docutils literal"><span class="pre">s0-s31</span></tt>.</li>
+</ul>
+<p>ARM’s Thumb1 mode:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">I</span></tt>: An immediate integer between 0 and 255.</li>
+<li><tt class="docutils literal"><span class="pre">J</span></tt>: An immediate integer between -255 and -1.</li>
+<li><tt class="docutils literal"><span class="pre">K</span></tt>: An immediate integer between 0 and 255, with optional left-shift by
+some amount.</li>
+<li><tt class="docutils literal"><span class="pre">L</span></tt>: An immediate integer between -7 and 7.</li>
+<li><tt class="docutils literal"><span class="pre">M</span></tt>: An immediate integer which is a multiple of 4 between 0 and 1020.</li>
+<li><tt class="docutils literal"><span class="pre">N</span></tt>: An immediate integer between 0 and 31.</li>
+<li><tt class="docutils literal"><span class="pre">O</span></tt>: An immediate integer which is a multiple of 4 between -508 and 508.</li>
+<li><tt class="docutils literal"><span class="pre">r</span></tt>: A low 32-bit GPR register (<tt class="docutils literal"><span class="pre">r0-r7</span></tt>).</li>
+<li><tt class="docutils literal"><span class="pre">l</span></tt>: A low 32-bit GPR register (<tt class="docutils literal"><span class="pre">r0-r7</span></tt>).</li>
+<li><tt class="docutils literal"><span class="pre">h</span></tt>: A high GPR register (<tt class="docutils literal"><span class="pre">r0-r7</span></tt>).</li>
+<li><tt class="docutils literal"><span class="pre">w</span></tt>: A 32, 64, or 128-bit floating-point/SIMD register: <tt class="docutils literal"><span class="pre">s0-s31</span></tt>,
+<tt class="docutils literal"><span class="pre">d0-d31</span></tt>, or <tt class="docutils literal"><span class="pre">q0-q15</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">x</span></tt>: A 32, 64, or 128-bit floating-point/SIMD register: <tt class="docutils literal"><span class="pre">s0-s15</span></tt>,
+<tt class="docutils literal"><span class="pre">d0-d7</span></tt>, or <tt class="docutils literal"><span class="pre">q0-q3</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">t</span></tt>: A floating-point/SIMD register, only supports 32-bit values:
+<tt class="docutils literal"><span class="pre">s0-s31</span></tt>.</li>
+</ul>
+<p>Hexagon:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">o</span></tt>, <tt class="docutils literal"><span class="pre">v</span></tt>: A memory address operand, treated the same as constraint <tt class="docutils literal"><span class="pre">m</span></tt>,
+at the moment.</li>
+<li><tt class="docutils literal"><span class="pre">r</span></tt>: A 32 or 64-bit register.</li>
+</ul>
+<p>MSP430:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">r</span></tt>: An 8 or 16-bit register.</li>
+</ul>
+<p>MIPS:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">I</span></tt>: An immediate signed 16-bit integer.</li>
+<li><tt class="docutils literal"><span class="pre">J</span></tt>: An immediate integer zero.</li>
+<li><tt class="docutils literal"><span class="pre">K</span></tt>: An immediate unsigned 16-bit integer.</li>
+<li><tt class="docutils literal"><span class="pre">L</span></tt>: An immediate 32-bit integer, where the lower 16 bits are 0.</li>
+<li><tt class="docutils literal"><span class="pre">N</span></tt>: An immediate integer between -65535 and -1.</li>
+<li><tt class="docutils literal"><span class="pre">O</span></tt>: An immediate signed 15-bit integer.</li>
+<li><tt class="docutils literal"><span class="pre">P</span></tt>: An immediate integer between 1 and 65535.</li>
+<li><tt class="docutils literal"><span class="pre">m</span></tt>: A memory address operand. In MIPS-SE mode, allows a base address
+register plus 16-bit immediate offset. In MIPS mode, just a base register.</li>
+<li><tt class="docutils literal"><span class="pre">R</span></tt>: A memory address operand. In MIPS-SE mode, allows a base address
+register plus a 9-bit signed offset. In MIPS mode, the same as constraint
+<tt class="docutils literal"><span class="pre">m</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">ZC</span></tt>: A memory address operand, suitable for use in a <tt class="docutils literal"><span class="pre">pref</span></tt>, <tt class="docutils literal"><span class="pre">ll</span></tt>, or
+<tt class="docutils literal"><span class="pre">sc</span></tt> instruction on the given subtarget (details vary).</li>
+<li><tt class="docutils literal"><span class="pre">r</span></tt>, <tt class="docutils literal"><span class="pre">d</span></tt>,  <tt class="docutils literal"><span class="pre">y</span></tt>: A 32 or 64-bit GPR register.</li>
+<li><tt class="docutils literal"><span class="pre">f</span></tt>: A 32 or 64-bit FPU register (<tt class="docutils literal"><span class="pre">F0-F31</span></tt>), or a 128-bit MSA register
+(<tt class="docutils literal"><span class="pre">W0-W31</span></tt>). In the case of MSA registers, it is recommended to use the <tt class="docutils literal"><span class="pre">w</span></tt>
+argument modifier for compatibility with GCC.</li>
+<li><tt class="docutils literal"><span class="pre">c</span></tt>: A 32-bit or 64-bit GPR register suitable for indirect jump (always
+<tt class="docutils literal"><span class="pre">25</span></tt>).</li>
+<li><tt class="docutils literal"><span class="pre">l</span></tt>: The <tt class="docutils literal"><span class="pre">lo</span></tt> register, 32 or 64-bit.</li>
+<li><tt class="docutils literal"><span class="pre">x</span></tt>: Invalid.</li>
+</ul>
+<p>NVPTX:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">b</span></tt>: A 1-bit integer register.</li>
+<li><tt class="docutils literal"><span class="pre">c</span></tt> or <tt class="docutils literal"><span class="pre">h</span></tt>: A 16-bit integer register.</li>
+<li><tt class="docutils literal"><span class="pre">r</span></tt>: A 32-bit integer register.</li>
+<li><tt class="docutils literal"><span class="pre">l</span></tt> or <tt class="docutils literal"><span class="pre">N</span></tt>: A 64-bit integer register.</li>
+<li><tt class="docutils literal"><span class="pre">f</span></tt>: A 32-bit float register.</li>
+<li><tt class="docutils literal"><span class="pre">d</span></tt>: A 64-bit float register.</li>
+</ul>
+<p>PowerPC:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">I</span></tt>: An immediate signed 16-bit integer.</li>
+<li><tt class="docutils literal"><span class="pre">J</span></tt>: An immediate unsigned 16-bit integer, shifted left 16 bits.</li>
+<li><tt class="docutils literal"><span class="pre">K</span></tt>: An immediate unsigned 16-bit integer.</li>
+<li><tt class="docutils literal"><span class="pre">L</span></tt>: An immediate signed 16-bit integer, shifted left 16 bits.</li>
+<li><tt class="docutils literal"><span class="pre">M</span></tt>: An immediate integer greater than 31.</li>
+<li><tt class="docutils literal"><span class="pre">N</span></tt>: An immediate integer that is an exact power of 2.</li>
+<li><tt class="docutils literal"><span class="pre">O</span></tt>: The immediate integer constant 0.</li>
+<li><tt class="docutils literal"><span class="pre">P</span></tt>: An immediate integer constant whose negation is a signed 16-bit
+constant.</li>
+<li><tt class="docutils literal"><span class="pre">es</span></tt>, <tt class="docutils literal"><span class="pre">o</span></tt>, <tt class="docutils literal"><span class="pre">Q</span></tt>, <tt class="docutils literal"><span class="pre">Z</span></tt>, <tt class="docutils literal"><span class="pre">Zy</span></tt>: A memory address operand, currently
+treated the same as <tt class="docutils literal"><span class="pre">m</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">r</span></tt>: A 32 or 64-bit integer register.</li>
+<li><tt class="docutils literal"><span class="pre">b</span></tt>: A 32 or 64-bit integer register, excluding <tt class="docutils literal"><span class="pre">R0</span></tt> (that is:
+<tt class="docutils literal"><span class="pre">R1-R31</span></tt>).</li>
+<li><tt class="docutils literal"><span class="pre">f</span></tt>: A 32 or 64-bit float register (<tt class="docutils literal"><span class="pre">F0-F31</span></tt>), or when QPX is enabled, a
+128 or 256-bit QPX register (<tt class="docutils literal"><span class="pre">Q0-Q31</span></tt>; aliases the <tt class="docutils literal"><span class="pre">F</span></tt> registers).</li>
+<li><tt class="docutils literal"><span class="pre">v</span></tt>: For <tt class="docutils literal"><span class="pre">4</span> <span class="pre">x</span> <span class="pre">f32</span></tt> or <tt class="docutils literal"><span class="pre">4</span> <span class="pre">x</span> <span class="pre">f64</span></tt> types, when QPX is enabled, a
+128 or 256-bit QPX register (<tt class="docutils literal"><span class="pre">Q0-Q31</span></tt>), otherwise a 128-bit
+altivec vector register (<tt class="docutils literal"><span class="pre">V0-V31</span></tt>).</li>
+<li><tt class="docutils literal"><span class="pre">y</span></tt>: Condition register (<tt class="docutils literal"><span class="pre">CR0-CR7</span></tt>).</li>
+<li><tt class="docutils literal"><span class="pre">wc</span></tt>: An individual CR bit in a CR register.</li>
+<li><tt class="docutils literal"><span class="pre">wa</span></tt>, <tt class="docutils literal"><span class="pre">wd</span></tt>, <tt class="docutils literal"><span class="pre">wf</span></tt>: Any 128-bit VSX vector register, from the full VSX
+register set (overlapping both the floating-point and vector register files).</li>
+<li><tt class="docutils literal"><span class="pre">ws</span></tt>: A 32 or 64-bit floating point register, from the full VSX register
+set.</li>
+</ul>
+<p>Sparc:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">I</span></tt>: An immediate 13-bit signed integer.</li>
+<li><tt class="docutils literal"><span class="pre">r</span></tt>: A 32-bit integer register.</li>
+<li><tt class="docutils literal"><span class="pre">f</span></tt>: Any floating-point register on SparcV8, or a floating point
+register in the “low” half of the registers on SparcV9.</li>
+<li><tt class="docutils literal"><span class="pre">e</span></tt>: Any floating point register. (Same as <tt class="docutils literal"><span class="pre">f</span></tt> on SparcV8.)</li>
+</ul>
+<p>SystemZ:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">I</span></tt>: An immediate unsigned 8-bit integer.</li>
+<li><tt class="docutils literal"><span class="pre">J</span></tt>: An immediate unsigned 12-bit integer.</li>
+<li><tt class="docutils literal"><span class="pre">K</span></tt>: An immediate signed 16-bit integer.</li>
+<li><tt class="docutils literal"><span class="pre">L</span></tt>: An immediate signed 20-bit integer.</li>
+<li><tt class="docutils literal"><span class="pre">M</span></tt>: An immediate integer 0x7fffffff.</li>
+<li><tt class="docutils literal"><span class="pre">Q</span></tt>: A memory address operand with a base address and a 12-bit immediate
+unsigned displacement.</li>
+<li><tt class="docutils literal"><span class="pre">R</span></tt>: A memory address operand with a base address, a 12-bit immediate
+unsigned displacement, and an index register.</li>
+<li><tt class="docutils literal"><span class="pre">S</span></tt>: A memory address operand with a base address and a 20-bit immediate
+signed displacement.</li>
+<li><tt class="docutils literal"><span class="pre">T</span></tt>: A memory address operand with a base address, a 20-bit immediate
+signed displacement, and an index register.</li>
+<li><tt class="docutils literal"><span class="pre">r</span></tt> or <tt class="docutils literal"><span class="pre">d</span></tt>: A 32, 64, or 128-bit integer register.</li>
+<li><tt class="docutils literal"><span class="pre">a</span></tt>: A 32, 64, or 128-bit integer address register (excludes R0, which in an
+address context evaluates as zero).</li>
+<li><tt class="docutils literal"><span class="pre">h</span></tt>: A 32-bit value in the high part of a 64bit data register
+(LLVM-specific)</li>
+<li><tt class="docutils literal"><span class="pre">f</span></tt>: A 32, 64, or 128-bit floating point register.</li>
+</ul>
+<p>X86:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">I</span></tt>: An immediate integer between 0 and 31.</li>
+<li><tt class="docutils literal"><span class="pre">J</span></tt>: An immediate integer between 0 and 64.</li>
+<li><tt class="docutils literal"><span class="pre">K</span></tt>: An immediate signed 8-bit integer.</li>
+<li><tt class="docutils literal"><span class="pre">L</span></tt>: An immediate integer, 0xff or 0xffff or (in 64-bit mode only)
+0xffffffff.</li>
+<li><tt class="docutils literal"><span class="pre">M</span></tt>: An immediate integer between 0 and 3.</li>
+<li><tt class="docutils literal"><span class="pre">N</span></tt>: An immediate unsigned 8-bit integer.</li>
+<li><tt class="docutils literal"><span class="pre">O</span></tt>: An immediate integer between 0 and 127.</li>
+<li><tt class="docutils literal"><span class="pre">e</span></tt>: An immediate 32-bit signed integer.</li>
+<li><tt class="docutils literal"><span class="pre">Z</span></tt>: An immediate 32-bit unsigned integer.</li>
+<li><tt class="docutils literal"><span class="pre">o</span></tt>, <tt class="docutils literal"><span class="pre">v</span></tt>: Treated the same as <tt class="docutils literal"><span class="pre">m</span></tt>, at the moment.</li>
+<li><tt class="docutils literal"><span class="pre">q</span></tt>: An 8, 16, 32, or 64-bit register which can be accessed as an 8-bit
+<tt class="docutils literal"><span class="pre">l</span></tt> integer register. On X86-32, this is the <tt class="docutils literal"><span class="pre">a</span></tt>, <tt class="docutils literal"><span class="pre">b</span></tt>, <tt class="docutils literal"><span class="pre">c</span></tt>, and <tt class="docutils literal"><span class="pre">d</span></tt>
+registers, and on X86-64, it is all of the integer registers.</li>
+<li><tt class="docutils literal"><span class="pre">Q</span></tt>: An 8, 16, 32, or 64-bit register which can be accessed as an 8-bit
+<tt class="docutils literal"><span class="pre">h</span></tt> integer register. This is the <tt class="docutils literal"><span class="pre">a</span></tt>, <tt class="docutils literal"><span class="pre">b</span></tt>, <tt class="docutils literal"><span class="pre">c</span></tt>, and <tt class="docutils literal"><span class="pre">d</span></tt> registers.</li>
+<li><tt class="docutils literal"><span class="pre">r</span></tt> or <tt class="docutils literal"><span class="pre">l</span></tt>: An 8, 16, 32, or 64-bit integer register.</li>
+<li><tt class="docutils literal"><span class="pre">R</span></tt>: An 8, 16, 32, or 64-bit “legacy” integer register – one which has
+existed since i386, and can be accessed without the REX prefix.</li>
+<li><tt class="docutils literal"><span class="pre">f</span></tt>: A 32, 64, or 80-bit ‘387 FPU stack pseudo-register.</li>
+<li><tt class="docutils literal"><span class="pre">y</span></tt>: A 64-bit MMX register, if MMX is enabled.</li>
+<li><tt class="docutils literal"><span class="pre">x</span></tt>: If SSE is enabled: a 32 or 64-bit scalar operand, or 128-bit vector
+operand in a SSE register. If AVX is also enabled, can also be a 256-bit
+vector operand in an AVX register. If AVX-512 is also enabled, can also be a
+512-bit vector operand in an AVX512 register, Otherwise, an error.</li>
+<li><tt class="docutils literal"><span class="pre">Y</span></tt>: The same as <tt class="docutils literal"><span class="pre">x</span></tt>, if <em>SSE2</em> is enabled, otherwise an error.</li>
+<li><tt class="docutils literal"><span class="pre">A</span></tt>: Special case: allocates EAX first, then EDX, for a single operand (in
+32-bit mode, a 64-bit integer operand will get split into two registers). It
+is not recommended to use this constraint, as in 64-bit mode, the 64-bit
+operand will get allocated only to RAX – if two 32-bit operands are needed,
+you’re better off splitting it yourself, before passing it to the asm
+statement.</li>
+</ul>
+<p>XCore:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">r</span></tt>: A 32-bit integer register.</li>
+</ul>
+</div>
+</div>
+<div class="section" id="asm-template-argument-modifiers">
+<span id="inline-asm-modifiers"></span><h4><a class="toc-backref" href="#id889">Asm template argument modifiers</a><a class="headerlink" href="#asm-template-argument-modifiers" title="Permalink to this headline">¶</a></h4>
+<p>In the asm template string, modifiers can be used on the operand reference, like
+“<tt class="docutils literal"><span class="pre">${0:n}</span></tt>”.</p>
+<p>The modifiers are, in general, expected to behave the same way they do in
+GCC. LLVM’s support is often implemented on an ‘as-needed’ basis, to support C
+inline asm code which was supported by GCC. A mismatch in behavior between LLVM
+and GCC likely indicates a bug in LLVM.</p>
+<p>Target-independent:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">c</span></tt>: Print an immediate integer constant unadorned, without
+the target-specific immediate punctuation (e.g. no <tt class="docutils literal"><span class="pre">$</span></tt> prefix).</li>
+<li><tt class="docutils literal"><span class="pre">n</span></tt>: Negate and print immediate integer constant unadorned, without the
+target-specific immediate punctuation (e.g. no <tt class="docutils literal"><span class="pre">$</span></tt> prefix).</li>
+<li><tt class="docutils literal"><span class="pre">l</span></tt>: Print as an unadorned label, without the target-specific label
+punctuation (e.g. no <tt class="docutils literal"><span class="pre">$</span></tt> prefix).</li>
+</ul>
+<p>AArch64:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">w</span></tt>: Print a GPR register with a <tt class="docutils literal"><span class="pre">w*</span></tt> name instead of <tt class="docutils literal"><span class="pre">x*</span></tt> name. E.g.,
+instead of <tt class="docutils literal"><span class="pre">x30</span></tt>, print <tt class="docutils literal"><span class="pre">w30</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">x</span></tt>: Print a GPR register with a <tt class="docutils literal"><span class="pre">x*</span></tt> name. (this is the default, anyhow).</li>
+<li><tt class="docutils literal"><span class="pre">b</span></tt>, <tt class="docutils literal"><span class="pre">h</span></tt>, <tt class="docutils literal"><span class="pre">s</span></tt>, <tt class="docutils literal"><span class="pre">d</span></tt>, <tt class="docutils literal"><span class="pre">q</span></tt>: Print a floating-point/SIMD register with a
+<tt class="docutils literal"><span class="pre">b*</span></tt>, <tt class="docutils literal"><span class="pre">h*</span></tt>, <tt class="docutils literal"><span class="pre">s*</span></tt>, <tt class="docutils literal"><span class="pre">d*</span></tt>, or <tt class="docutils literal"><span class="pre">q*</span></tt> name, rather than the default of
+<tt class="docutils literal"><span class="pre">v*</span></tt>.</li>
+</ul>
+<p>AMDGPU:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">r</span></tt>: No effect.</li>
+</ul>
+<p>ARM:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">a</span></tt>: Print an operand as an address (with <tt class="docutils literal"><span class="pre">[</span></tt> and <tt class="docutils literal"><span class="pre">]</span></tt> surrounding a
+register).</li>
+<li><tt class="docutils literal"><span class="pre">P</span></tt>: No effect.</li>
+<li><tt class="docutils literal"><span class="pre">q</span></tt>: No effect.</li>
+<li><tt class="docutils literal"><span class="pre">y</span></tt>: Print a VFP single-precision register as an indexed double (e.g. print
+as <tt class="docutils literal"><span class="pre">d4[1]</span></tt> instead of <tt class="docutils literal"><span class="pre">s9</span></tt>)</li>
+<li><tt class="docutils literal"><span class="pre">B</span></tt>: Bitwise invert and print an immediate integer constant without <tt class="docutils literal"><span class="pre">#</span></tt>
+prefix.</li>
+<li><tt class="docutils literal"><span class="pre">L</span></tt>: Print the low 16-bits of an immediate integer constant.</li>
+<li><tt class="docutils literal"><span class="pre">M</span></tt>: Print as a register set suitable for ldm/stm. Also prints <em>all</em>
+register operands subsequent to the specified one (!), so use carefully.</li>
+<li><tt class="docutils literal"><span class="pre">Q</span></tt>: Print the low-order register of a register-pair, or the low-order
+register of a two-register operand.</li>
+<li><tt class="docutils literal"><span class="pre">R</span></tt>: Print the high-order register of a register-pair, or the high-order
+register of a two-register operand.</li>
+<li><tt class="docutils literal"><span class="pre">H</span></tt>: Print the second register of a register-pair. (On a big-endian system,
+<tt class="docutils literal"><span class="pre">H</span></tt> is equivalent to <tt class="docutils literal"><span class="pre">Q</span></tt>, and on little-endian system, <tt class="docutils literal"><span class="pre">H</span></tt> is equivalent
+to <tt class="docutils literal"><span class="pre">R</span></tt>.)</li>
+<li><tt class="docutils literal"><span class="pre">e</span></tt>: Print the low doubleword register of a NEON quad register.</li>
+<li><tt class="docutils literal"><span class="pre">f</span></tt>: Print the high doubleword register of a NEON quad register.</li>
+<li><tt class="docutils literal"><span class="pre">m</span></tt>: Print the base register of a memory operand without the <tt class="docutils literal"><span class="pre">[</span></tt> and <tt class="docutils literal"><span class="pre">]</span></tt>
+adornment.</li>
+</ul>
+<p>Hexagon:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">L</span></tt>: Print the second register of a two-register operand. Requires that it
+has been allocated consecutively to the first.</li>
+<li><tt class="docutils literal"><span class="pre">I</span></tt>: Print the letter ‘i’ if the operand is an integer constant, otherwise
+nothing. Used to print ‘addi’ vs ‘add’ instructions.</li>
+</ul>
+<p>MSP430:</p>
+<p>No additional modifiers.</p>
+<p>MIPS:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">X</span></tt>: Print an immediate integer as hexadecimal</li>
+<li><tt class="docutils literal"><span class="pre">x</span></tt>: Print the low 16 bits of an immediate integer as hexadecimal.</li>
+<li><tt class="docutils literal"><span class="pre">d</span></tt>: Print an immediate integer as decimal.</li>
+<li><tt class="docutils literal"><span class="pre">m</span></tt>: Subtract one and print an immediate integer as decimal.</li>
+<li><tt class="docutils literal"><span class="pre">z</span></tt>: Print $0 if an immediate zero, otherwise print normally.</li>
+<li><tt class="docutils literal"><span class="pre">L</span></tt>: Print the low-order register of a two-register operand, or prints the
+address of the low-order word of a double-word memory operand.</li>
+<li><tt class="docutils literal"><span class="pre">M</span></tt>: Print the high-order register of a two-register operand, or prints the
+address of the high-order word of a double-word memory operand.</li>
+<li><tt class="docutils literal"><span class="pre">D</span></tt>: Print the second register of a two-register operand, or prints the
+second word of a double-word memory operand. (On a big-endian system, <tt class="docutils literal"><span class="pre">D</span></tt> is
+equivalent to <tt class="docutils literal"><span class="pre">L</span></tt>, and on little-endian system, <tt class="docutils literal"><span class="pre">D</span></tt> is equivalent to
+<tt class="docutils literal"><span class="pre">M</span></tt>.)</li>
+<li><tt class="docutils literal"><span class="pre">w</span></tt>: No effect. Provided for compatibility with GCC which requires this
+modifier in order to print MSA registers (<tt class="docutils literal"><span class="pre">W0-W31</span></tt>) with the <tt class="docutils literal"><span class="pre">f</span></tt>
+constraint.</li>
+</ul>
+<p>NVPTX:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">r</span></tt>: No effect.</li>
+</ul>
+<p>PowerPC:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">L</span></tt>: Print the second register of a two-register operand. Requires that it
+has been allocated consecutively to the first.</li>
+<li><tt class="docutils literal"><span class="pre">I</span></tt>: Print the letter ‘i’ if the operand is an integer constant, otherwise
+nothing. Used to print ‘addi’ vs ‘add’ instructions.</li>
+<li><tt class="docutils literal"><span class="pre">y</span></tt>: For a memory operand, prints formatter for a two-register X-form
+instruction. (Currently always prints <tt class="docutils literal"><span class="pre">r0,OPERAND</span></tt>).</li>
+<li><tt class="docutils literal"><span class="pre">U</span></tt>: Prints ‘u’ if the memory operand is an update form, and nothing
+otherwise. (NOTE: LLVM does not support update form, so this will currently
+always print nothing)</li>
+<li><tt class="docutils literal"><span class="pre">X</span></tt>: Prints ‘x’ if the memory operand is an indexed form. (NOTE: LLVM does
+not support indexed form, so this will currently always print nothing)</li>
+</ul>
+<p>Sparc:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">r</span></tt>: No effect.</li>
+</ul>
+<p>SystemZ:</p>
+<p>SystemZ implements only <tt class="docutils literal"><span class="pre">n</span></tt>, and does <em>not</em> support any of the other
+target-independent modifiers.</p>
+<p>X86:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">c</span></tt>: Print an unadorned integer or symbol name. (The latter is
+target-specific behavior for this typically target-independent modifier).</li>
+<li><tt class="docutils literal"><span class="pre">A</span></tt>: Print a register name with a ‘<tt class="docutils literal"><span class="pre">*</span></tt>‘ before it.</li>
+<li><tt class="docutils literal"><span class="pre">b</span></tt>: Print an 8-bit register name (e.g. <tt class="docutils literal"><span class="pre">al</span></tt>); do nothing on a memory
+operand.</li>
+<li><tt class="docutils literal"><span class="pre">h</span></tt>: Print the upper 8-bit register name (e.g. <tt class="docutils literal"><span class="pre">ah</span></tt>); do nothing on a
+memory operand.</li>
+<li><tt class="docutils literal"><span class="pre">w</span></tt>: Print the 16-bit register name (e.g. <tt class="docutils literal"><span class="pre">ax</span></tt>); do nothing on a memory
+operand.</li>
+<li><tt class="docutils literal"><span class="pre">k</span></tt>: Print the 32-bit register name (e.g. <tt class="docutils literal"><span class="pre">eax</span></tt>); do nothing on a memory
+operand.</li>
+<li><tt class="docutils literal"><span class="pre">q</span></tt>: Print the 64-bit register name (e.g. <tt class="docutils literal"><span class="pre">rax</span></tt>), if 64-bit registers are
+available, otherwise the 32-bit register name; do nothing on a memory operand.</li>
+<li><tt class="docutils literal"><span class="pre">n</span></tt>: Negate and print an unadorned integer, or, for operands other than an
+immediate integer (e.g. a relocatable symbol expression), print a ‘-‘ before
+the operand. (The behavior for relocatable symbol expressions is a
+target-specific behavior for this typically target-independent modifier)</li>
+<li><tt class="docutils literal"><span class="pre">H</span></tt>: Print a memory reference with additional offset +8.</li>
+<li><tt class="docutils literal"><span class="pre">P</span></tt>: Print a memory reference or operand for use as the argument of a call
+instruction. (E.g. omit <tt class="docutils literal"><span class="pre">(rip)</span></tt>, even though it’s PC-relative.)</li>
+</ul>
+<p>XCore:</p>
+<p>No additional modifiers.</p>
+</div>
+<div class="section" id="inline-asm-metadata">
+<h4><a class="toc-backref" href="#id890">Inline Asm Metadata</a><a class="headerlink" href="#inline-asm-metadata" title="Permalink to this headline">¶</a></h4>
+<p>The call instructions that wrap inline asm nodes may have a
+“<tt class="docutils literal"><span class="pre">!srcloc</span></tt>” MDNode attached to it that contains a list of constant
+integers. If present, the code generator will use the integer as the
+location cookie value when report errors through the <tt class="docutils literal"><span class="pre">LLVMContext</span></tt>
+error reporting mechanisms. This allows a front-end to correlate backend
+errors that occur with inline asm back to the source code that produced
+it. For example:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="k">call</span> <span class="kt">void</span> <span class="k">asm</span> <span class="k">sideeffect</span> <span class="s">"something bad"</span><span class="p">,</span> <span class="s">""</span><span class="p">(),</span> <span class="nv">!srcloc</span> <span class="nv-Anonymous">!42</span>
+<span class="p">...</span>
+<span class="nv-Anonymous">!42</span> <span class="p">=</span> <span class="p">!{</span> <span class="k">i32</span> <span class="m">1234567</span> <span class="p">}</span>
+</pre></div>
+</div>
+<p>It is up to the front-end to make sense of the magic numbers it places
+in the IR. If the MDNode contains multiple constants, the code generator
+will use the one that corresponds to the line of the asm that the error
+occurs on.</p>
+</div>
+</div>
+</div>
+<div class="section" id="metadata">
+<span id="id5"></span><h2><a class="toc-backref" href="#id891">Metadata</a><a class="headerlink" href="#metadata" title="Permalink to this headline">¶</a></h2>
+<p>LLVM IR allows metadata to be attached to instructions in the program
+that can convey extra information about the code to the optimizers and
+code generator. One example application of metadata is source-level
+debug information. There are two metadata primitives: strings and nodes.</p>
+<p>Metadata does not have a type, and is not a value. If referenced from a
+<tt class="docutils literal"><span class="pre">call</span></tt> instruction, it uses the <tt class="docutils literal"><span class="pre">metadata</span></tt> type.</p>
+<p>All metadata are identified in syntax by a exclamation point (‘<tt class="docutils literal"><span class="pre">!</span></tt>‘).</p>
+<div class="section" id="metadata-nodes-and-metadata-strings">
+<span id="metadata-string"></span><h3><a class="toc-backref" href="#id892">Metadata Nodes and Metadata Strings</a><a class="headerlink" href="#metadata-nodes-and-metadata-strings" title="Permalink to this headline">¶</a></h3>
+<p>A metadata string is a string surrounded by double quotes. It can
+contain any character by escaping non-printable characters with
+“<tt class="docutils literal"><span class="pre">\xx</span></tt>” where “<tt class="docutils literal"><span class="pre">xx</span></tt>” is the two digit hex code. For example:
+“<tt class="docutils literal"><span class="pre">!"test\00"</span></tt>”.</p>
+<p>Metadata nodes are represented with notation similar to structure
+constants (a comma separated list of elements, surrounded by braces and
+preceded by an exclamation point). Metadata nodes can have any values as
+their operand. For example:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="p">!{</span> <span class="nv">!"test\00"</span><span class="p">,</span> <span class="k">i32</span> <span class="m">10</span><span class="p">}</span>
+</pre></div>
+</div>
+<p>Metadata nodes that aren’t uniqued use the <tt class="docutils literal"><span class="pre">distinct</span></tt> keyword. For example:</p>
+<div class="highlight-text"><div class="highlight"><pre>!0 = distinct !{!"test\00", i32 10}
+</pre></div>
+</div>
+<p><tt class="docutils literal"><span class="pre">distinct</span></tt> nodes are useful when nodes shouldn’t be merged based on their
+content. They can also occur when transformations cause uniquing collisions
+when metadata operands change.</p>
+<p>A <a class="reference internal" href="#namedmetadatastructure"><em>named metadata</em></a> is a collection of
+metadata nodes, which can be looked up in the module symbol table. For
+example:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">!foo</span> <span class="p">=</span> <span class="p">!{</span><span class="nv-Anonymous">!4</span><span class="p">,</span> <span class="nv-Anonymous">!3</span><span class="p">}</span>
+</pre></div>
+</div>
+<p>Metadata can be used as function arguments. Here the <tt class="docutils literal"><span class="pre">llvm.dbg.value</span></tt>
+intrinsic is using three metadata arguments:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="k">call</span> <span class="kt">void</span> <span class="vg">@llvm.dbg.value</span><span class="p">(</span><span class="kt">metadata</span> <span class="nv-Anonymous">!24</span><span class="p">,</span> <span class="kt">metadata</span> <span class="nv-Anonymous">!25</span><span class="p">,</span> <span class="kt">metadata</span> <span class="nv-Anonymous">!26</span><span class="p">)</span>
+</pre></div>
+</div>
+<p>Metadata can be attached to an instruction. Here metadata <tt class="docutils literal"><span class="pre">!21</span></tt> is attached
+to the <tt class="docutils literal"><span class="pre">add</span></tt> instruction using the <tt class="docutils literal"><span class="pre">!dbg</span></tt> identifier:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%indvar.next</span> <span class="p">=</span> <span class="k">add</span> <span class="k">i64</span> <span class="nv">%indvar</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="nv">!dbg</span> <span class="nv-Anonymous">!21</span>
+</pre></div>
+</div>
+<p>Metadata can also be attached to a function or a global variable. Here metadata
+<tt class="docutils literal"><span class="pre">!22</span></tt> is attached to the <tt class="docutils literal"><span class="pre">f1</span></tt> and <tt class="docutils literal"><span class="pre">f2</span> <span class="pre">functions,</span> <span class="pre">and</span> <span class="pre">the</span> <span class="pre">globals</span> <span class="pre">``g1</span></tt>
+and <tt class="docutils literal"><span class="pre">g2</span></tt> using the <tt class="docutils literal"><span class="pre">!dbg</span></tt> identifier:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="k">declare</span> <span class="nv">!dbg</span> <span class="nv-Anonymous">!22</span> <span class="kt">void</span> <span class="vg">@f1</span><span class="p">()</span>
+<span class="k">define</span> <span class="kt">void</span> <span class="vg">@f2</span><span class="p">()</span> <span class="nv">!dbg</span> <span class="nv-Anonymous">!22</span> <span class="p">{</span>
+  <span class="k">ret</span> <span class="kt">void</span>
+<span class="p">}</span>
+
+<span class="vg">@g1</span> <span class="p">=</span> <span class="k">global</span> <span class="k">i32</span> <span class="m">0</span><span class="p">,</span> <span class="nv">!dbg</span> <span class="nv-Anonymous">!22</span>
+<span class="vg">@g2</span> <span class="p">=</span> <span class="k">external</span> <span class="k">global</span> <span class="k">i32</span><span class="p">,</span> <span class="nv">!dbg</span> <span class="nv-Anonymous">!22</span>
+</pre></div>
+</div>
+<p>A transformation is required to drop any metadata attachment that it does not
+know or know it can’t preserve. Currently there is an exception for metadata
+attachment to globals for <tt class="docutils literal"><span class="pre">!type</span></tt> and <tt class="docutils literal"><span class="pre">!absolute_symbol</span></tt> which can’t be
+unconditionally dropped unless the global is itself deleted.</p>
+<p>Metadata attached to a module using named metadata may not be dropped, with
+the exception of debug metadata (named metadata with the name <tt class="docutils literal"><span class="pre">!llvm.dbg.*</span></tt>).</p>
+<p>More information about specific metadata nodes recognized by the
+optimizers and code generator is found below.</p>
+<div class="section" id="specialized-metadata-nodes">
+<span id="specialized-metadata"></span><h4><a class="toc-backref" href="#id893">Specialized Metadata Nodes</a><a class="headerlink" href="#specialized-metadata-nodes" title="Permalink to this headline">¶</a></h4>
+<p>Specialized metadata nodes are custom data structures in metadata (as opposed
+to generic tuples). Their fields are labelled, and can be specified in any
+order.</p>
+<p>These aren’t inherently debug info centric, but currently all the specialized
+metadata nodes are related to debug info.</p>
+<div class="section" id="dicompileunit">
+<span id="id6"></span><h5><a class="toc-backref" href="#id894">DICompileUnit</a><a class="headerlink" href="#dicompileunit" title="Permalink to this headline">¶</a></h5>
+<p><tt class="docutils literal"><span class="pre">DICompileUnit</span></tt> nodes represent a compile unit. The <tt class="docutils literal"><span class="pre">enums:</span></tt>,
+<tt class="docutils literal"><span class="pre">retainedTypes:</span></tt>, <tt class="docutils literal"><span class="pre">globals:</span></tt>, <tt class="docutils literal"><span class="pre">imports:</span></tt> and <tt class="docutils literal"><span class="pre">macros:</span></tt> fields are tuples
+containing the debug info to be emitted along with the compile unit, regardless
+of code optimizations (some nodes are only emitted if there are references to
+them from instructions). The <tt class="docutils literal"><span class="pre">debugInfoForProfiling:</span></tt> field is a boolean
+indicating whether or not line-table discriminators are updated to provide
+more-accurate debug info for profiling results.</p>
+<div class="highlight-text"><div class="highlight"><pre>!0 = !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang",
+                    isOptimized: true, flags: "-O2", runtimeVersion: 2,
+                    splitDebugFilename: "abc.debug", emissionKind: FullDebug,
+                    enums: !2, retainedTypes: !3, globals: !4, imports: !5,
+                    macros: !6, dwoId: 0x0abcd)
+</pre></div>
+</div>
+<p>Compile unit descriptors provide the root scope for objects declared in a
+specific compilation unit. File descriptors are defined using this scope.  These
+descriptors are collected by a named metadata node <tt class="docutils literal"><span class="pre">!llvm.dbg.cu</span></tt>. They keep
+track of global variables, type information, and imported entities (declarations
+and namespaces).</p>
+</div>
+<div class="section" id="difile">
+<span id="id7"></span><h5><a class="toc-backref" href="#id895">DIFile</a><a class="headerlink" href="#difile" title="Permalink to this headline">¶</a></h5>
+<p><tt class="docutils literal"><span class="pre">DIFile</span></tt> nodes represent files. The <tt class="docutils literal"><span class="pre">filename:</span></tt> can include slashes.</p>
+<div class="highlight-none"><div class="highlight"><pre>!0 = !DIFile(filename: "path/to/file", directory: "/path/to/dir",
+             checksumkind: CSK_MD5,
+             checksum: "000102030405060708090a0b0c0d0e0f")
+</pre></div>
+</div>
+<p>Files are sometimes used in <tt class="docutils literal"><span class="pre">scope:</span></tt> fields, and are the only valid target
+for <tt class="docutils literal"><span class="pre">file:</span></tt> fields.
+Valid values for <tt class="docutils literal"><span class="pre">checksumkind:</span></tt> field are: {CSK_None, CSK_MD5, CSK_SHA1}</p>
+</div>
+<div class="section" id="dibasictype">
+<span id="id8"></span><h5><a class="toc-backref" href="#id896">DIBasicType</a><a class="headerlink" href="#dibasictype" title="Permalink to this headline">¶</a></h5>
+<p><tt class="docutils literal"><span class="pre">DIBasicType</span></tt> nodes represent primitive types, such as <tt class="docutils literal"><span class="pre">int</span></tt>, <tt class="docutils literal"><span class="pre">bool</span></tt> and
+<tt class="docutils literal"><span class="pre">float</span></tt>. <tt class="docutils literal"><span class="pre">tag:</span></tt> defaults to <tt class="docutils literal"><span class="pre">DW_TAG_base_type</span></tt>.</p>
+<div class="highlight-text"><div class="highlight"><pre>!0 = !DIBasicType(name: "unsigned char", size: 8, align: 8,
+                  encoding: DW_ATE_unsigned_char)
+!1 = !DIBasicType(tag: DW_TAG_unspecified_type, name: "decltype(nullptr)")
+</pre></div>
+</div>
+<p>The <tt class="docutils literal"><span class="pre">encoding:</span></tt> describes the details of the type. Usually it’s one of the
+following:</p>
+<div class="highlight-text"><div class="highlight"><pre>DW_ATE_address       = 1
+DW_ATE_boolean       = 2
+DW_ATE_float         = 4
+DW_ATE_signed        = 5
+DW_ATE_signed_char   = 6
+DW_ATE_unsigned      = 7
+DW_ATE_unsigned_char = 8
+</pre></div>
+</div>
+</div>
+<div class="section" id="disubroutinetype">
+<span id="id9"></span><h5><a class="toc-backref" href="#id897">DISubroutineType</a><a class="headerlink" href="#disubroutinetype" title="Permalink to this headline">¶</a></h5>
+<p><tt class="docutils literal"><span class="pre">DISubroutineType</span></tt> nodes represent subroutine types. Their <tt class="docutils literal"><span class="pre">types:</span></tt> field
+refers to a tuple; the first operand is the return type, while the rest are the
+types of the formal arguments in order. If the first operand is <tt class="docutils literal"><span class="pre">null</span></tt>, that
+represents a function with no return value (such as <tt class="docutils literal"><span class="pre">void</span> <span class="pre">foo()</span> <span class="pre">{}</span></tt> in C++).</p>
+<div class="highlight-text"><div class="highlight"><pre>!0 = !BasicType(name: "int", size: 32, align: 32, DW_ATE_signed)
+!1 = !BasicType(name: "char", size: 8, align: 8, DW_ATE_signed_char)
+!2 = !DISubroutineType(types: !{null, !0, !1}) ; void (int, char)
+</pre></div>
+</div>
+</div>
+<div class="section" id="diderivedtype">
+<span id="id10"></span><h5><a class="toc-backref" href="#id898">DIDerivedType</a><a class="headerlink" href="#diderivedtype" title="Permalink to this headline">¶</a></h5>
+<p><tt class="docutils literal"><span class="pre">DIDerivedType</span></tt> nodes represent types derived from other types, such as
+qualified types.</p>
+<div class="highlight-text"><div class="highlight"><pre>!0 = !DIBasicType(name: "unsigned char", size: 8, align: 8,
+                  encoding: DW_ATE_unsigned_char)
+!1 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !0, size: 32,
+                    align: 32)
+</pre></div>
+</div>
+<p>The following <tt class="docutils literal"><span class="pre">tag:</span></tt> values are valid:</p>
+<div class="highlight-text"><div class="highlight"><pre>DW_TAG_member             = 13
+DW_TAG_pointer_type       = 15
+DW_TAG_reference_type     = 16
+DW_TAG_typedef            = 22
+DW_TAG_inheritance        = 28
+DW_TAG_ptr_to_member_type = 31
+DW_TAG_const_type         = 38
+DW_TAG_friend             = 42
+DW_TAG_volatile_type      = 53
+DW_TAG_restrict_type      = 55
+DW_TAG_atomic_type        = 71
+</pre></div>
+</div>
+<p id="diderivedtypemember"><tt class="docutils literal"><span class="pre">DW_TAG_member</span></tt> is used to define a member of a <a class="reference internal" href="#dicompositetype"><em>composite type</em></a>. The type of the member is the <tt class="docutils literal"><span class="pre">baseType:</span></tt>. The
+<tt class="docutils literal"><span class="pre">offset:</span></tt> is the member’s bit offset.  If the composite type has an ODR
+<tt class="docutils literal"><span class="pre">identifier:</span></tt> and does not set <tt class="docutils literal"><span class="pre">flags:</span> <span class="pre">DIFwdDecl</span></tt>, then the member is
+uniqued based only on its <tt class="docutils literal"><span class="pre">name:</span></tt> and <tt class="docutils literal"><span class="pre">scope:</span></tt>.</p>
+<p><tt class="docutils literal"><span class="pre">DW_TAG_inheritance</span></tt> and <tt class="docutils literal"><span class="pre">DW_TAG_friend</span></tt> are used in the <tt class="docutils literal"><span class="pre">elements:</span></tt>
+field of <a class="reference internal" href="#dicompositetype"><em>composite types</em></a> to describe parents and
+friends.</p>
+<p><tt class="docutils literal"><span class="pre">DW_TAG_typedef</span></tt> is used to provide a name for the <tt class="docutils literal"><span class="pre">baseType:</span></tt>.</p>
+<p><tt class="docutils literal"><span class="pre">DW_TAG_pointer_type</span></tt>, <tt class="docutils literal"><span class="pre">DW_TAG_reference_type</span></tt>, <tt class="docutils literal"><span class="pre">DW_TAG_const_type</span></tt>,
+<tt class="docutils literal"><span class="pre">DW_TAG_volatile_type</span></tt>, <tt class="docutils literal"><span class="pre">DW_TAG_restrict_type</span></tt> and <tt class="docutils literal"><span class="pre">DW_TAG_atomic_type</span></tt>
+are used to qualify the <tt class="docutils literal"><span class="pre">baseType:</span></tt>.</p>
+<p>Note that the <tt class="docutils literal"><span class="pre">void</span> <span class="pre">*</span></tt> type is expressed as a type derived from NULL.</p>
+</div>
+<div class="section" id="dicompositetype">
+<span id="id11"></span><h5><a class="toc-backref" href="#id899">DICompositeType</a><a class="headerlink" href="#dicompositetype" title="Permalink to this headline">¶</a></h5>
+<p><tt class="docutils literal"><span class="pre">DICompositeType</span></tt> nodes represent types composed of other types, like
+structures and unions. <tt class="docutils literal"><span class="pre">elements:</span></tt> points to a tuple of the composed types.</p>
+<p>If the source language supports ODR, the <tt class="docutils literal"><span class="pre">identifier:</span></tt> field gives the unique
+identifier used for type merging between modules.  When specified,
+<a class="reference internal" href="#disubprogramdeclaration"><em>subprogram declarations</em></a> and <a class="reference internal" href="#diderivedtypemember"><em>member
+derived types</em></a> that reference the ODR-type in their
+<tt class="docutils literal"><span class="pre">scope:</span></tt> change uniquing rules.</p>
+<p>For a given <tt class="docutils literal"><span class="pre">identifier:</span></tt>, there should only be a single composite type that
+does not have  <tt class="docutils literal"><span class="pre">flags:</span> <span class="pre">DIFlagFwdDecl</span></tt> set.  LLVM tools that link modules
+together will unique such definitions at parse time via the <tt class="docutils literal"><span class="pre">identifier:</span></tt>
+field, even if the nodes are <tt class="docutils literal"><span class="pre">distinct</span></tt>.</p>
+<div class="highlight-text"><div class="highlight"><pre>!0 = !DIEnumerator(name: "SixKind", value: 7)
+!1 = !DIEnumerator(name: "SevenKind", value: 7)
+!2 = !DIEnumerator(name: "NegEightKind", value: -8)
+!3 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "Enum", file: !12,
+                      line: 2, size: 32, align: 32, identifier: "_M4Enum",
+                      elements: !{!0, !1, !2})
+</pre></div>
+</div>
+<p>The following <tt class="docutils literal"><span class="pre">tag:</span></tt> values are valid:</p>
+<div class="highlight-text"><div class="highlight"><pre>DW_TAG_array_type       = 1
+DW_TAG_class_type       = 2
+DW_TAG_enumeration_type = 4
+DW_TAG_structure_type   = 19
+DW_TAG_union_type       = 23
+</pre></div>
+</div>
+<p>For <tt class="docutils literal"><span class="pre">DW_TAG_array_type</span></tt>, the <tt class="docutils literal"><span class="pre">elements:</span></tt> should be <a class="reference internal" href="#disubrange"><em>subrange
+descriptors</em></a>, each representing the range of subscripts at that
+level of indexing. The <tt class="docutils literal"><span class="pre">DIFlagVector</span></tt> flag to <tt class="docutils literal"><span class="pre">flags:</span></tt> indicates that an
+array type is a native packed vector.</p>
+<p>For <tt class="docutils literal"><span class="pre">DW_TAG_enumeration_type</span></tt>, the <tt class="docutils literal"><span class="pre">elements:</span></tt> should be <a class="reference internal" href="#dienumerator"><em>enumerator
+descriptors</em></a>, each representing the definition of an enumeration
+value for the set. All enumeration type descriptors are collected in the
+<tt class="docutils literal"><span class="pre">enums:</span></tt> field of the <a class="reference internal" href="#dicompileunit"><em>compile unit</em></a>.</p>
+<p>For <tt class="docutils literal"><span class="pre">DW_TAG_structure_type</span></tt>, <tt class="docutils literal"><span class="pre">DW_TAG_class_type</span></tt>, and
+<tt class="docutils literal"><span class="pre">DW_TAG_union_type</span></tt>, the <tt class="docutils literal"><span class="pre">elements:</span></tt> should be <a class="reference internal" href="#diderivedtype"><em>derived types</em></a> with <tt class="docutils literal"><span class="pre">tag:</span> <span class="pre">DW_TAG_member</span></tt>, <tt class="docutils literal"><span class="pre">tag:</span> <span class="pre">DW_TAG_inheritance</span></tt>, or
+<tt class="docutils literal"><span class="pre">tag:</span> <span class="pre">DW_TAG_friend</span></tt>; or <a class="reference internal" href="#disubprogram"><em>subprograms</em></a> with
+<tt class="docutils literal"><span class="pre">isDefinition:</span> <span class="pre">false</span></tt>.</p>
+</div>
+<div class="section" id="disubrange">
+<span id="id12"></span><h5><a class="toc-backref" href="#id900">DISubrange</a><a class="headerlink" href="#disubrange" title="Permalink to this headline">¶</a></h5>
+<p><tt class="docutils literal"><span class="pre">DISubrange</span></tt> nodes are the elements for <tt class="docutils literal"><span class="pre">DW_TAG_array_type</span></tt> variants of
+<a class="reference internal" href="#dicompositetype"><em>DICompositeType</em></a>. <tt class="docutils literal"><span class="pre">count:</span> <span class="pre">-1</span></tt> indicates an empty array.</p>
+<div class="highlight-llvm"><pre>!0 = !DISubrange(count: 5, lowerBound: 0) ; array counting from 0
+!1 = !DISubrange(count: 5, lowerBound: 1) ; array counting from 1
+!2 = !DISubrange(count: -1) ; empty array.</pre>
+</div>
+</div>
+<div class="section" id="dienumerator">
+<span id="id13"></span><h5><a class="toc-backref" href="#id901">DIEnumerator</a><a class="headerlink" href="#dienumerator" title="Permalink to this headline">¶</a></h5>
+<p><tt class="docutils literal"><span class="pre">DIEnumerator</span></tt> nodes are the elements for <tt class="docutils literal"><span class="pre">DW_TAG_enumeration_type</span></tt>
+variants of <a class="reference internal" href="#dicompositetype"><em>DICompositeType</em></a>.</p>
+<div class="highlight-llvm"><pre>!0 = !DIEnumerator(name: "SixKind", value: 7)
+!1 = !DIEnumerator(name: "SevenKind", value: 7)
+!2 = !DIEnumerator(name: "NegEightKind", value: -8)</pre>
+</div>
+</div>
+<div class="section" id="ditemplatetypeparameter">
+<h5><a class="toc-backref" href="#id902">DITemplateTypeParameter</a><a class="headerlink" href="#ditemplatetypeparameter" title="Permalink to this headline">¶</a></h5>
+<p><tt class="docutils literal"><span class="pre">DITemplateTypeParameter</span></tt> nodes represent type parameters to generic source
+language constructs. They are used (optionally) in <a class="reference internal" href="#dicompositetype"><em>DICompositeType</em></a> and
+<a class="reference internal" href="#disubprogram"><em>DISubprogram</em></a> <tt class="docutils literal"><span class="pre">templateParams:</span></tt> fields.</p>
+<div class="highlight-llvm"><pre>!0 = !DITemplateTypeParameter(name: "Ty", type: !1)</pre>
+</div>
+</div>
+<div class="section" id="ditemplatevalueparameter">
+<h5><a class="toc-backref" href="#id903">DITemplateValueParameter</a><a class="headerlink" href="#ditemplatevalueparameter" title="Permalink to this headline">¶</a></h5>
+<p><tt class="docutils literal"><span class="pre">DITemplateValueParameter</span></tt> nodes represent value parameters to generic source
+language constructs. <tt class="docutils literal"><span class="pre">tag:</span></tt> defaults to <tt class="docutils literal"><span class="pre">DW_TAG_template_value_parameter</span></tt>,
+but if specified can also be set to <tt class="docutils literal"><span class="pre">DW_TAG_GNU_template_template_param</span></tt> or
+<tt class="docutils literal"><span class="pre">DW_TAG_GNU_template_param_pack</span></tt>. They are used (optionally) in
+<a class="reference internal" href="#dicompositetype"><em>DICompositeType</em></a> and <a class="reference internal" href="#disubprogram"><em>DISubprogram</em></a> <tt class="docutils literal"><span class="pre">templateParams:</span></tt> fields.</p>
+<div class="highlight-llvm"><pre>!0 = !DITemplateValueParameter(name: "Ty", type: !1, value: i32 7)</pre>
+</div>
+</div>
+<div class="section" id="dinamespace">
+<h5><a class="toc-backref" href="#id904">DINamespace</a><a class="headerlink" href="#dinamespace" title="Permalink to this headline">¶</a></h5>
+<p><tt class="docutils literal"><span class="pre">DINamespace</span></tt> nodes represent namespaces in the source language.</p>
+<div class="highlight-llvm"><pre>!0 = !DINamespace(name: "myawesomeproject", scope: !1, file: !2, line: 7)</pre>
+</div>
+</div>
+<div class="section" id="diglobalvariable">
+<h5><a class="toc-backref" href="#id905">DIGlobalVariable</a><a class="headerlink" href="#diglobalvariable" title="Permalink to this headline">¶</a></h5>
+<p><tt class="docutils literal"><span class="pre">DIGlobalVariable</span></tt> nodes represent global variables in the source language.</p>
+<div class="highlight-llvm"><pre>!0 = !DIGlobalVariable(name: "foo", linkageName: "foo", scope: !1,
+                       file: !2, line: 7, type: !3, isLocal: true,
+                       isDefinition: false, variable: i32* @foo,
+                       declaration: !4)</pre>
+</div>
+<p>All global variables should be referenced by the <cite>globals:</cite> field of a
+<a class="reference internal" href="#dicompileunit"><em>compile unit</em></a>.</p>
+</div>
+<div class="section" id="disubprogram">
+<span id="id14"></span><h5><a class="toc-backref" href="#id906">DISubprogram</a><a class="headerlink" href="#disubprogram" title="Permalink to this headline">¶</a></h5>
+<p><tt class="docutils literal"><span class="pre">DISubprogram</span></tt> nodes represent functions from the source language. A
+<tt class="docutils literal"><span class="pre">DISubprogram</span></tt> may be attached to a function definition using <tt class="docutils literal"><span class="pre">!dbg</span></tt>
+metadata. The <tt class="docutils literal"><span class="pre">variables:</span></tt> field points at <a class="reference internal" href="#dilocalvariable"><em>variables</em></a>
+that must be retained, even if their IR counterparts are optimized out of
+the IR. The <tt class="docutils literal"><span class="pre">type:</span></tt> field must point at an <a class="reference internal" href="#disubroutinetype"><em>DISubroutineType</em></a>.</p>
+<p id="disubprogramdeclaration">When <tt class="docutils literal"><span class="pre">isDefinition:</span> <span class="pre">false</span></tt>, subprograms describe a declaration in the type
+tree as opposed to a definition of a function.  If the scope is a composite
+type with an ODR <tt class="docutils literal"><span class="pre">identifier:</span></tt> and that does not set <tt class="docutils literal"><span class="pre">flags:</span> <span class="pre">DIFwdDecl</span></tt>,
+then the subprogram declaration is uniqued based only on its <tt class="docutils literal"><span class="pre">linkageName:</span></tt>
+and <tt class="docutils literal"><span class="pre">scope:</span></tt>.</p>
+<div class="highlight-text"><div class="highlight"><pre>define void @_Z3foov() !dbg !0 {
+  ...
+}
+
+!0 = distinct !DISubprogram(name: "foo", linkageName: "_Zfoov", scope: !1,
+                            file: !2, line: 7, type: !3, isLocal: true,
+                            isDefinition: true, scopeLine: 8,
+                            containingType: !4,
+                            virtuality: DW_VIRTUALITY_pure_virtual,
+                            virtualIndex: 10, flags: DIFlagPrototyped,
+                            isOptimized: true, unit: !5, templateParams: !6,
+                            declaration: !7, variables: !8, thrownTypes: !9)
+</pre></div>
+</div>
+</div>
+<div class="section" id="dilexicalblock">
+<span id="id15"></span><h5><a class="toc-backref" href="#id907">DILexicalBlock</a><a class="headerlink" href="#dilexicalblock" title="Permalink to this headline">¶</a></h5>
+<p><tt class="docutils literal"><span class="pre">DILexicalBlock</span></tt> nodes describe nested blocks within a <a class="reference internal" href="#disubprogram"><em>subprogram</em></a>. The line number and column numbers are used to distinguish
+two lexical blocks at same depth. They are valid targets for <tt class="docutils literal"><span class="pre">scope:</span></tt>
+fields.</p>
+<div class="highlight-text"><div class="highlight"><pre>!0 = distinct !DILexicalBlock(scope: !1, file: !2, line: 7, column: 35)
+</pre></div>
+</div>
+<p>Usually lexical blocks are <tt class="docutils literal"><span class="pre">distinct</span></tt> to prevent node merging based on
+operands.</p>
+</div>
+<div class="section" id="dilexicalblockfile">
+<span id="id16"></span><h5><a class="toc-backref" href="#id908">DILexicalBlockFile</a><a class="headerlink" href="#dilexicalblockfile" title="Permalink to this headline">¶</a></h5>
+<p><tt class="docutils literal"><span class="pre">DILexicalBlockFile</span></tt> nodes are used to discriminate between sections of a
+<a class="reference internal" href="#dilexicalblock"><em>lexical block</em></a>. The <tt class="docutils literal"><span class="pre">file:</span></tt> field can be changed to
+indicate textual inclusion, or the <tt class="docutils literal"><span class="pre">discriminator:</span></tt> field can be used to
+discriminate between control flow within a single block in the source language.</p>
+<div class="highlight-llvm"><pre>!0 = !DILexicalBlock(scope: !3, file: !4, line: 7, column: 35)
+!1 = !DILexicalBlockFile(scope: !0, file: !4, discriminator: 0)
+!2 = !DILexicalBlockFile(scope: !0, file: !4, discriminator: 1)</pre>
+</div>
+</div>
+<div class="section" id="dilocation">
+<span id="id17"></span><h5><a class="toc-backref" href="#id909">DILocation</a><a class="headerlink" href="#dilocation" title="Permalink to this headline">¶</a></h5>
+<p><tt class="docutils literal"><span class="pre">DILocation</span></tt> nodes represent source debug locations. The <tt class="docutils literal"><span class="pre">scope:</span></tt> field is
+mandatory, and points at an <a class="reference internal" href="#dilexicalblockfile"><em>DILexicalBlockFile</em></a>, an
+<a class="reference internal" href="#dilexicalblock"><em>DILexicalBlock</em></a>, or an <a class="reference internal" href="#disubprogram"><em>DISubprogram</em></a>.</p>
+<div class="highlight-llvm"><pre>!0 = !DILocation(line: 2900, column: 42, scope: !1, inlinedAt: !2)</pre>
+</div>
+</div>
+<div class="section" id="dilocalvariable">
+<span id="id18"></span><h5><a class="toc-backref" href="#id910">DILocalVariable</a><a class="headerlink" href="#dilocalvariable" title="Permalink to this headline">¶</a></h5>
+<p><tt class="docutils literal"><span class="pre">DILocalVariable</span></tt> nodes represent local variables in the source language. If
+the <tt class="docutils literal"><span class="pre">arg:</span></tt> field is set to non-zero, then this variable is a subprogram
+parameter, and it will be included in the <tt class="docutils literal"><span class="pre">variables:</span></tt> field of its
+<a class="reference internal" href="#disubprogram"><em>DISubprogram</em></a>.</p>
+<div class="highlight-text"><div class="highlight"><pre>!0 = !DILocalVariable(name: "this", arg: 1, scope: !3, file: !2, line: 7,
+                      type: !3, flags: DIFlagArtificial)
+!1 = !DILocalVariable(name: "x", arg: 2, scope: !4, file: !2, line: 7,
+                      type: !3)
+!2 = !DILocalVariable(name: "y", scope: !5, file: !2, line: 7, type: !3)
+</pre></div>
+</div>
+</div>
+<div class="section" id="diexpression">
+<h5><a class="toc-backref" href="#id911">DIExpression</a><a class="headerlink" href="#diexpression" title="Permalink to this headline">¶</a></h5>
+<p><tt class="docutils literal"><span class="pre">DIExpression</span></tt> nodes represent expressions that are inspired by the DWARF
+expression language. They are used in <a class="reference internal" href="#dbg-intrinsics"><em>debug intrinsics</em></a>
+(such as <tt class="docutils literal"><span class="pre">llvm.dbg.declare</span></tt> and <tt class="docutils literal"><span class="pre">llvm.dbg.value</span></tt>) to describe how the
+referenced LLVM variable relates to the source language variable.</p>
+<p>The current supported vocabulary is limited:</p>
+<ul class="simple">
+<li><tt class="docutils literal"><span class="pre">DW_OP_deref</span></tt> dereferences the top of the expression stack.</li>
+<li><tt class="docutils literal"><span class="pre">DW_OP_plus</span></tt> pops the last two entries from the expression stack, adds
+them together and appends the result to the expression stack.</li>
+<li><tt class="docutils literal"><span class="pre">DW_OP_minus</span></tt> pops the last two entries from the expression stack, subtracts
+the last entry from the second last entry and appends the result to the
+expression stack.</li>
+<li><tt class="docutils literal"><span class="pre">DW_OP_plus_uconst,</span> <span class="pre">93</span></tt> adds <tt class="docutils literal"><span class="pre">93</span></tt> to the working expression.</li>
+<li><tt class="docutils literal"><span class="pre">DW_OP_LLVM_fragment,</span> <span class="pre">16,</span> <span class="pre">8</span></tt> specifies the offset and size (<tt class="docutils literal"><span class="pre">16</span></tt> and <tt class="docutils literal"><span class="pre">8</span></tt>
+here, respectively) of the variable fragment from the working expression. Note
+that contrary to DW_OP_bit_piece, the offset is describing the the location
+within the described source variable.</li>
+<li><tt class="docutils literal"><span class="pre">DW_OP_swap</span></tt> swaps top two stack entries.</li>
+<li><tt class="docutils literal"><span class="pre">DW_OP_xderef</span></tt> provides extended dereference mechanism. The entry at the top
+of the stack is treated as an address. The second stack entry is treated as an
+address space identifier.</li>
+<li><tt class="docutils literal"><span class="pre">DW_OP_stack_value</span></tt> marks a constant value.</li>
+</ul>
+<p>DWARF specifies three kinds of simple location descriptions: Register, memory,
+and implicit location descriptions. Register and memory location descriptions
+describe the <em>location</em> of a source variable (in the sense that a debugger might
+modify its value), whereas implicit locations describe merely the <em>value</em> of a
+source variable. DIExpressions also follow this model: A DIExpression that
+doesn’t have a trailing <tt class="docutils literal"><span class="pre">DW_OP_stack_value</span></tt> will describe an <em>address</em> when
+combined with a concrete location.</p>
+<div class="highlight-text"><div class="highlight"><pre>!0 = !DIExpression(DW_OP_deref)
+!1 = !DIExpression(DW_OP_plus_uconst, 3)
+!1 = !DIExpression(DW_OP_constu, 3, DW_OP_plus)
+!2 = !DIExpression(DW_OP_bit_piece, 3, 7)
+!3 = !DIExpression(DW_OP_deref, DW_OP_constu, 3, DW_OP_plus, DW_OP_LLVM_fragment, 3, 7)
+!4 = !DIExpression(DW_OP_constu, 2, DW_OP_swap, DW_OP_xderef)
+!5 = !DIExpression(DW_OP_constu, 42, DW_OP_stack_value)
+</pre></div>
+</div>
+</div>
+<div class="section" id="diobjcproperty">
+<h5><a class="toc-backref" href="#id912">DIObjCProperty</a><a class="headerlink" href="#diobjcproperty" title="Permalink to this headline">¶</a></h5>
+<p><tt class="docutils literal"><span class="pre">DIObjCProperty</span></tt> nodes represent Objective-C property nodes.</p>
+<div class="highlight-llvm"><pre>!3 = !DIObjCProperty(name: "foo", file: !1, line: 7, setter: "setFoo",
+                     getter: "getFoo", attributes: 7, type: !2)</pre>
+</div>
+</div>
+<div class="section" id="diimportedentity">
+<h5><a class="toc-backref" href="#id913">DIImportedEntity</a><a class="headerlink" href="#diimportedentity" title="Permalink to this headline">¶</a></h5>
+<p><tt class="docutils literal"><span class="pre">DIImportedEntity</span></tt> nodes represent entities (such as modules) imported into a
+compile unit.</p>
+<div class="highlight-text"><div class="highlight"><pre>!2 = !DIImportedEntity(tag: DW_TAG_imported_module, name: "foo", scope: !0,
+                       entity: !1, line: 7)
+</pre></div>
+</div>
+</div>
+<div class="section" id="dimacro">
+<h5><a class="toc-backref" href="#id914">DIMacro</a><a class="headerlink" href="#dimacro" title="Permalink to this headline">¶</a></h5>
+<p><tt class="docutils literal"><span class="pre">DIMacro</span></tt> nodes represent definition or undefinition of a macro identifiers.
+The <tt class="docutils literal"><span class="pre">name:</span></tt> field is the macro identifier, followed by macro parameters when
+defining a function-like macro, and the <tt class="docutils literal"><span class="pre">value</span></tt> field is the token-string
+used to expand the macro identifier.</p>
+<div class="highlight-text"><div class="highlight"><pre>!2 = !DIMacro(macinfo: DW_MACINFO_define, line: 7, name: "foo(x)",
+              value: "((x) + 1)")
+!3 = !DIMacro(macinfo: DW_MACINFO_undef, line: 30, name: "foo")
+</pre></div>
+</div>
+</div>
+<div class="section" id="dimacrofile">
+<h5><a class="toc-backref" href="#id915">DIMacroFile</a><a class="headerlink" href="#dimacrofile" title="Permalink to this headline">¶</a></h5>
+<p><tt class="docutils literal"><span class="pre">DIMacroFile</span></tt> nodes represent inclusion of source files.
+The <tt class="docutils literal"><span class="pre">nodes:</span></tt> field is a list of <tt class="docutils literal"><span class="pre">DIMacro</span></tt> and <tt class="docutils literal"><span class="pre">DIMacroFile</span></tt> nodes that
+appear in the included source file.</p>
+<div class="highlight-text"><div class="highlight"><pre>!2 = !DIMacroFile(macinfo: DW_MACINFO_start_file, line: 7, file: !2,
+                  nodes: !3)
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="tbaa-metadata">
+<h4><a class="toc-backref" href="#id916">‘<tt class="docutils literal"><span class="pre">tbaa</span></tt>‘ Metadata</a><a class="headerlink" href="#tbaa-metadata" title="Permalink to this headline">¶</a></h4>
+<p>In LLVM IR, memory does not have types, so LLVM’s own type system is not
+suitable for doing type based alias analysis (TBAA). Instead, metadata is
+added to the IR to describe a type system of a higher level language. This
+can be used to implement C/C++ strict type aliasing rules, but it can also
+be used to implement custom alias analysis behavior for other languages.</p>
+<p>This description of LLVM’s TBAA system is broken into two parts:
+<a class="reference internal" href="#tbaa-node-semantics"><em>Semantics</em></a> talks about high level issues, and
+<a class="reference internal" href="#tbaa-node-representation"><em>Representation</em></a> talks about the metadata
+encoding of various entities.</p>
+<p>It is always possible to trace any TBAA node to a “root” TBAA node (details
+in the <a class="reference internal" href="#tbaa-node-representation"><em>Representation</em></a> section).  TBAA
+nodes with different roots have an unknown aliasing relationship, and LLVM
+conservatively infers <tt class="docutils literal"><span class="pre">MayAlias</span></tt> between them.  The rules mentioned in
+this section only pertain to TBAA nodes living under the same root.</p>
+<div class="section" id="semantics">
+<span id="tbaa-node-semantics"></span><h5><a class="toc-backref" href="#id917">Semantics</a><a class="headerlink" href="#semantics" title="Permalink to this headline">¶</a></h5>
+<p>The TBAA metadata system, referred to as “struct path TBAA” (not to be
+confused with <tt class="docutils literal"><span class="pre">tbaa.struct</span></tt>), consists of the following high level
+concepts: <em>Type Descriptors</em>, further subdivided into scalar type
+descriptors and struct type descriptors; and <em>Access Tags</em>.</p>
+<p><strong>Type descriptors</strong> describe the type system of the higher level language
+being compiled.  <strong>Scalar type descriptors</strong> describe types that do not
+contain other types.  Each scalar type has a parent type, which must also
+be a scalar type or the TBAA root.  Via this parent relation, scalar types
+within a TBAA root form a tree.  <strong>Struct type descriptors</strong> denote types
+that contain a sequence of other type descriptors, at known offsets.  These
+contained type descriptors can either be struct type descriptors themselves
+or scalar type descriptors.</p>
+<p><strong>Access tags</strong> are metadata nodes attached to load and store instructions.
+Access tags use type descriptors to describe the <em>location</em> being accessed
+in terms of the type system of the higher level language.  Access tags are
+tuples consisting of a base type, an access type and an offset.  The base
+type is a scalar type descriptor or a struct type descriptor, the access
+type is a scalar type descriptor, and the offset is a constant integer.</p>
+<p>The access tag <tt class="docutils literal"><span class="pre">(BaseTy,</span> <span class="pre">AccessTy,</span> <span class="pre">Offset)</span></tt> can describe one of two
+things:</p>
+<blockquote>
+<div><ul class="simple">
+<li>If <tt class="docutils literal"><span class="pre">BaseTy</span></tt> is a struct type, the tag describes a memory access (load
+or store) of a value of type <tt class="docutils literal"><span class="pre">AccessTy</span></tt> contained in the struct type
+<tt class="docutils literal"><span class="pre">BaseTy</span></tt> at offset <tt class="docutils literal"><span class="pre">Offset</span></tt>.</li>
+<li>If <tt class="docutils literal"><span class="pre">BaseTy</span></tt> is a scalar type, <tt class="docutils literal"><span class="pre">Offset</span></tt> must be 0 and <tt class="docutils literal"><span class="pre">BaseTy</span></tt> and
+<tt class="docutils literal"><span class="pre">AccessTy</span></tt> must be the same; and the access tag describes a scalar
+access with scalar type <tt class="docutils literal"><span class="pre">AccessTy</span></tt>.</li>
+</ul>
+</div></blockquote>
+<p>We first define an <tt class="docutils literal"><span class="pre">ImmediateParent</span></tt> relation on <tt class="docutils literal"><span class="pre">(BaseTy,</span> <span class="pre">Offset)</span></tt>
+tuples this way:</p>
+<blockquote>
+<div><ul class="simple">
+<li>If <tt class="docutils literal"><span class="pre">BaseTy</span></tt> is a scalar type then <tt class="docutils literal"><span class="pre">ImmediateParent(BaseTy,</span> <span class="pre">0)</span></tt> is
+<tt class="docutils literal"><span class="pre">(ParentTy,</span> <span class="pre">0)</span></tt> where <tt class="docutils literal"><span class="pre">ParentTy</span></tt> is the parent of the scalar type as
+described in the TBAA metadata.  <tt class="docutils literal"><span class="pre">ImmediateParent(BaseTy,</span> <span class="pre">Offset)</span></tt> is
+undefined if <tt class="docutils literal"><span class="pre">Offset</span></tt> is non-zero.</li>
+<li>If <tt class="docutils literal"><span class="pre">BaseTy</span></tt> is a struct type then <tt class="docutils literal"><span class="pre">ImmediateParent(BaseTy,</span> <span class="pre">Offset)</span></tt>
+is <tt class="docutils literal"><span class="pre">(NewTy,</span> <span class="pre">NewOffset)</span></tt> where <tt class="docutils literal"><span class="pre">NewTy</span></tt> is the type contained in
+<tt class="docutils literal"><span class="pre">BaseTy</span></tt> at offset <tt class="docutils literal"><span class="pre">Offset</span></tt> and <tt class="docutils literal"><span class="pre">NewOffset</span></tt> is <tt class="docutils literal"><span class="pre">Offset</span></tt> adjusted
+to be relative within that inner type.</li>
+</ul>
+</div></blockquote>
+<p>A memory access with an access tag <tt class="docutils literal"><span class="pre">(BaseTy1,</span> <span class="pre">AccessTy1,</span> <span class="pre">Offset1)</span></tt>
+aliases a memory access with an access tag <tt class="docutils literal"><span class="pre">(BaseTy2,</span> <span class="pre">AccessTy2,</span>
+<span class="pre">Offset2)</span></tt> if either <tt class="docutils literal"><span class="pre">(BaseTy1,</span> <span class="pre">Offset1)</span></tt> is reachable from <tt class="docutils literal"><span class="pre">(Base2,</span>
+<span class="pre">Offset2)</span></tt> via the <tt class="docutils literal"><span class="pre">Parent</span></tt> relation or vice versa.</p>
+<p>As a concrete example, the type descriptor graph for the following program</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="k">struct</span> <span class="n">Inner</span> <span class="p">{</span>
+  <span class="kt">int</span> <span class="n">i</span><span class="p">;</span>    <span class="c1">// offset 0</span>
+  <span class="kt">float</span> <span class="n">f</span><span class="p">;</span>  <span class="c1">// offset 4</span>
+<span class="p">};</span>
+
+<span class="k">struct</span> <span class="n">Outer</span> <span class="p">{</span>
+  <span class="kt">float</span> <span class="n">f</span><span class="p">;</span>  <span class="c1">// offset 0</span>
+  <span class="kt">double</span> <span class="n">d</span><span class="p">;</span> <span class="c1">// offset 4</span>
+  <span class="k">struct</span> <span class="n">Inner</span> <span class="n">inner_a</span><span class="p">;</span>  <span class="c1">// offset 12</span>
+<span class="p">};</span>
+
+<span class="kt">void</span> <span class="nf">f</span><span class="p">(</span><span class="k">struct</span> <span class="n">Outer</span><span class="o">*</span> <span class="n">outer</span><span class="p">,</span> <span class="k">struct</span> <span class="n">Inner</span><span class="o">*</span> <span class="n">inner</span><span class="p">,</span> <span class="kt">float</span><span class="o">*</span> <span class="n">f</span><span class="p">,</span> <span class="kt">int</span><span class="o">*</span> <span class="n">i</span><span class="p">,</span> <span class="kt">char</span><span class="o">*</span> <span class="n">c</span><span class="p">)</span> <span class="p">{</span>
+  <span class="n">outer</span><span class="o">-></span><span class="n">f</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>            <span class="c1">// tag0: (OuterStructTy, FloatScalarTy, 0)</span>
+  <span class="n">outer</span><span class="o">-></span><span class="n">inner_a</span><span class="p">.</span><span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>    <span class="c1">// tag1: (OuterStructTy, IntScalarTy, 12)</span>
+  <span class="n">outer</span><span class="o">-></span><span class="n">inner_a</span><span class="p">.</span><span class="n">f</span> <span class="o">=</span> <span class="mf">0.0</span><span class="p">;</span>  <span class="c1">// tag2: (OuterStructTy, IntScalarTy, 16)</span>
+  <span class="o">*</span><span class="n">f</span> <span class="o">=</span> <span class="mf">0.0</span><span class="p">;</span>                <span class="c1">// tag3: (FloatScalarTy, FloatScalarTy, 0)</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>is (note that in C and C++, <tt class="docutils literal"><span class="pre">char</span></tt> can be used to access any arbitrary
+type):</p>
+<div class="highlight-text"><div class="highlight"><pre>Root = "TBAA Root"
+CharScalarTy = ("char", Root, 0)
+FloatScalarTy = ("float", CharScalarTy, 0)
+DoubleScalarTy = ("double", CharScalarTy, 0)
+IntScalarTy = ("int", CharScalarTy, 0)
+InnerStructTy = {"Inner" (IntScalarTy, 0), (FloatScalarTy, 4)}
+OuterStructTy = {"Outer", (FloatScalarTy, 0), (DoubleScalarTy, 4),
+                 (InnerStructTy, 12)}
+</pre></div>
+</div>
+<p>with (e.g.) <tt class="docutils literal"><span class="pre">ImmediateParent(OuterStructTy,</span> <span class="pre">12)</span></tt> = <tt class="docutils literal"><span class="pre">(InnerStructTy,</span>
+<span class="pre">0)</span></tt>, <tt class="docutils literal"><span class="pre">ImmediateParent(InnerStructTy,</span> <span class="pre">0)</span></tt> = <tt class="docutils literal"><span class="pre">(IntScalarTy,</span> <span class="pre">0)</span></tt>, and
+<tt class="docutils literal"><span class="pre">ImmediateParent(IntScalarTy,</span> <span class="pre">0)</span></tt> = <tt class="docutils literal"><span class="pre">(CharScalarTy,</span> <span class="pre">0)</span></tt>.</p>
+</div>
+<div class="section" id="representation">
+<span id="tbaa-node-representation"></span><h5><a class="toc-backref" href="#id918">Representation</a><a class="headerlink" href="#representation" title="Permalink to this headline">¶</a></h5>
+<p>The root node of a TBAA type hierarchy is an <tt class="docutils literal"><span class="pre">MDNode</span></tt> with 0 operands or
+with exactly one <tt class="docutils literal"><span class="pre">MDString</span></tt> operand.</p>
+<p>Scalar type descriptors are represented as an <tt class="docutils literal"><span class="pre">MDNode</span></tt> s with two
+operands.  The first operand is an <tt class="docutils literal"><span class="pre">MDString</span></tt> denoting the name of the
+struct type.  LLVM does not assign meaning to the value of this operand, it
+only cares about it being an <tt class="docutils literal"><span class="pre">MDString</span></tt>.  The second operand is an
+<tt class="docutils literal"><span class="pre">MDNode</span></tt> which points to the parent for said scalar type descriptor,
+which is either another scalar type descriptor or the TBAA root.  Scalar
+type descriptors can have an optional third argument, but that must be the
+constant integer zero.</p>
+<p>Struct type descriptors are represented as <tt class="docutils literal"><span class="pre">MDNode</span></tt> s with an odd number
+of operands greater than 1.  The first operand is an <tt class="docutils literal"><span class="pre">MDString</span></tt> denoting
+the name of the struct type.  Like in scalar type descriptors the actual
+value of this name operand is irrelevant to LLVM.  After the name operand,
+the struct type descriptors have a sequence of alternating <tt class="docutils literal"><span class="pre">MDNode</span></tt> and
+<tt class="docutils literal"><span class="pre">ConstantInt</span></tt> operands.  With N starting from 1, the 2N - 1 th operand,
+an <tt class="docutils literal"><span class="pre">MDNode</span></tt>, denotes a contained field, and the 2N th operand, a
+<tt class="docutils literal"><span class="pre">ConstantInt</span></tt>, is the offset of the said contained field.  The offsets
+must be in non-decreasing order.</p>
+<p>Access tags are represented as <tt class="docutils literal"><span class="pre">MDNode</span></tt> s with either 3 or 4 operands.
+The first operand is an <tt class="docutils literal"><span class="pre">MDNode</span></tt> pointing to the node representing the
+base type.  The second operand is an <tt class="docutils literal"><span class="pre">MDNode</span></tt> pointing to the node
+representing the access type.  The third operand is a <tt class="docutils literal"><span class="pre">ConstantInt</span></tt> that
+states the offset of the access.  If a fourth field is present, it must be
+a <tt class="docutils literal"><span class="pre">ConstantInt</span></tt> valued at 0 or 1.  If it is 1 then the access tag states
+that the location being accessed is “constant” (meaning
+<tt class="docutils literal"><span class="pre">pointsToConstantMemory</span></tt> should return true; see <a class="reference external" href="AliasAnalysis.html#OtherItfs">other useful
+AliasAnalysis methods</a>).  The TBAA root of
+the access type and the base type of an access tag must be the same, and
+that is the TBAA root of the access tag.</p>
+</div>
+</div>
+<div class="section" id="tbaa-struct-metadata">
+<h4><a class="toc-backref" href="#id919">‘<tt class="docutils literal"><span class="pre">tbaa.struct</span></tt>‘ Metadata</a><a class="headerlink" href="#tbaa-struct-metadata" title="Permalink to this headline">¶</a></h4>
+<p>The <a class="reference internal" href="#int-memcpy"><em>llvm.memcpy</em></a> is often used to implement
+aggregate assignment operations in C and similar languages, however it
+is defined to copy a contiguous region of memory, which is more than
+strictly necessary for aggregate types which contain holes due to
+padding. Also, it doesn’t contain any TBAA information about the fields
+of the aggregate.</p>
+<p><tt class="docutils literal"><span class="pre">!tbaa.struct</span></tt> metadata can describe which memory subregions in a
+memcpy are padding and what the TBAA tags of the struct are.</p>
+<p>The current metadata format is very simple. <tt class="docutils literal"><span class="pre">!tbaa.struct</span></tt> metadata
+nodes are a list of operands which are in conceptual groups of three.
+For each group of three, the first operand gives the byte offset of a
+field in bytes, the second gives its size in bytes, and the third gives
+its tbaa tag. e.g.:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv-Anonymous">!4</span> <span class="p">=</span> <span class="p">!{</span> <span class="k">i64</span> <span class="m">0</span><span class="p">,</span> <span class="k">i64</span> <span class="m">4</span><span class="p">,</span> <span class="nv-Anonymous">!1</span><span class="p">,</span> <span class="k">i64</span> <span class="m">8</span><span class="p">,</span> <span class="k">i64</span> <span class="m">4</span><span class="p">,</span> <span class="nv-Anonymous">!2</span> <span class="p">}</span>
+</pre></div>
+</div>
+<p>This describes a struct with two fields. The first is at offset 0 bytes
+with size 4 bytes, and has tbaa tag !1. The second is at offset 8 bytes
+and has size 4 bytes and has tbaa tag !2.</p>
+<p>Note that the fields need not be contiguous. In this example, there is a
+4 byte gap between the two fields. This gap represents padding which
+does not carry useful data and need not be preserved.</p>
+</div>
+<div class="section" id="noalias-and-alias-scope-metadata">
+<h4><a class="toc-backref" href="#id920">‘<tt class="docutils literal"><span class="pre">noalias</span></tt>‘ and ‘<tt class="docutils literal"><span class="pre">alias.scope</span></tt>‘ Metadata</a><a class="headerlink" href="#noalias-and-alias-scope-metadata" title="Permalink to this headline">¶</a></h4>
+<p><tt class="docutils literal"><span class="pre">noalias</span></tt> and <tt class="docutils literal"><span class="pre">alias.scope</span></tt> metadata provide the ability to specify generic
+noalias memory-access sets. This means that some collection of memory access
+instructions (loads, stores, memory-accessing calls, etc.) that carry
+<tt class="docutils literal"><span class="pre">noalias</span></tt> metadata can specifically be specified not to alias with some other
+collection of memory access instructions that carry <tt class="docutils literal"><span class="pre">alias.scope</span></tt> metadata.
+Each type of metadata specifies a list of scopes where each scope has an id and
+a domain.</p>
+<p>When evaluating an aliasing query, if for some domain, the set
+of scopes with that domain in one instruction’s <tt class="docutils literal"><span class="pre">alias.scope</span></tt> list is a
+subset of (or equal to) the set of scopes for that domain in another
+instruction’s <tt class="docutils literal"><span class="pre">noalias</span></tt> list, then the two memory accesses are assumed not to
+alias.</p>
+<p>Because scopes in one domain don’t affect scopes in other domains, separate
+domains can be used to compose multiple independent noalias sets.  This is
+used for example during inlining.  As the noalias function parameters are
+turned into noalias scope metadata, a new domain is used every time the
+function is inlined.</p>
+<p>The metadata identifying each domain is itself a list containing one or two
+entries. The first entry is the name of the domain. Note that if the name is a
+string then it can be combined across functions and translation units. A
+self-reference can be used to create globally unique domain names. A
+descriptive string may optionally be provided as a second list entry.</p>
+<p>The metadata identifying each scope is also itself a list containing two or
+three entries. The first entry is the name of the scope. Note that if the name
+is a string then it can be combined across functions and translation units. A
+self-reference can be used to create globally unique scope names. A metadata
+reference to the scope’s domain is the second entry. A descriptive string may
+optionally be provided as a third list entry.</p>
+<p>For example,</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="c">; Two scope domains:</span>
+<span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="p">!{</span><span class="nv-Anonymous">!0</span><span class="p">}</span>
+<span class="nv-Anonymous">!1</span> <span class="p">=</span> <span class="p">!{</span><span class="nv-Anonymous">!1</span><span class="p">}</span>
+
+<span class="c">; Some scopes in these domains:</span>
+<span class="nv-Anonymous">!2</span> <span class="p">=</span> <span class="p">!{</span><span class="nv-Anonymous">!2</span><span class="p">,</span> <span class="nv-Anonymous">!0</span><span class="p">}</span>
+<span class="nv-Anonymous">!3</span> <span class="p">=</span> <span class="p">!{</span><span class="nv-Anonymous">!3</span><span class="p">,</span> <span class="nv-Anonymous">!0</span><span class="p">}</span>
+<span class="nv-Anonymous">!4</span> <span class="p">=</span> <span class="p">!{</span><span class="nv-Anonymous">!4</span><span class="p">,</span> <span class="nv-Anonymous">!1</span><span class="p">}</span>
+
+<span class="c">; Some scope lists:</span>
+<span class="nv-Anonymous">!5</span> <span class="p">=</span> <span class="p">!{</span><span class="nv-Anonymous">!4</span><span class="p">}</span> <span class="c">; A list containing only scope !4</span>
+<span class="nv-Anonymous">!6</span> <span class="p">=</span> <span class="p">!{</span><span class="nv-Anonymous">!4</span><span class="p">,</span> <span class="nv-Anonymous">!3</span><span class="p">,</span> <span class="nv-Anonymous">!2</span><span class="p">}</span>
+<span class="nv-Anonymous">!7</span> <span class="p">=</span> <span class="p">!{</span><span class="nv-Anonymous">!3</span><span class="p">}</span>
+
+<span class="c">; These two instructions don't alias:</span>
+<span class="nv-Anonymous">%0</span> <span class="p">=</span> <span class="k">load</span> <span class="kt">float</span><span class="p">,</span> <span class="kt">float</span><span class="p">*</span> <span class="nv">%c</span><span class="p">,</span> <span class="k">align</span> <span class="m">4</span><span class="p">,</span> <span class="nv">!alias.scope</span> <span class="nv-Anonymous">!5</span>
+<span class="k">store</span> <span class="kt">float</span> <span class="nv-Anonymous">%0</span><span class="p">,</span> <span class="kt">float</span><span class="p">*</span> <span class="nv">%arrayidx.i</span><span class="p">,</span> <span class="k">align</span> <span class="m">4</span><span class="p">,</span> <span class="nv">!noalias</span> <span class="nv-Anonymous">!5</span>
+
+<span class="c">; These two instructions also don't alias (for domain !1, the set of scopes</span>
+<span class="c">; in the !alias.scope equals that in the !noalias list):</span>
+<span class="nv-Anonymous">%2</span> <span class="p">=</span> <span class="k">load</span> <span class="kt">float</span><span class="p">,</span> <span class="kt">float</span><span class="p">*</span> <span class="nv">%c</span><span class="p">,</span> <span class="k">align</span> <span class="m">4</span><span class="p">,</span> <span class="nv">!alias.scope</span> <span class="nv-Anonymous">!5</span>
+<span class="k">store</span> <span class="kt">float</span> <span class="nv-Anonymous">%2</span><span class="p">,</span> <span class="kt">float</span><span class="p">*</span> <span class="nv">%arrayidx.i2</span><span class="p">,</span> <span class="k">align</span> <span class="m">4</span><span class="p">,</span> <span class="nv">!noalias</span> <span class="nv-Anonymous">!6</span>
+
+<span class="c">; These two instructions may alias (for domain !0, the set of scopes in</span>
+<span class="c">; the !noalias list is not a superset of, or equal to, the scopes in the</span>
+<span class="c">; !alias.scope list):</span>
+<span class="nv-Anonymous">%2</span> <span class="p">=</span> <span class="k">load</span> <span class="kt">float</span><span class="p">,</span> <span class="kt">float</span><span class="p">*</span> <span class="nv">%c</span><span class="p">,</span> <span class="k">align</span> <span class="m">4</span><span class="p">,</span> <span class="nv">!alias.scope</span> <span class="nv-Anonymous">!6</span>
+<span class="k">store</span> <span class="kt">float</span> <span class="nv-Anonymous">%0</span><span class="p">,</span> <span class="kt">float</span><span class="p">*</span> <span class="nv">%arrayidx.i</span><span class="p">,</span> <span class="k">align</span> <span class="m">4</span><span class="p">,</span> <span class="nv">!noalias</span> <span class="nv-Anonymous">!7</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="fpmath-metadata">
+<h4><a class="toc-backref" href="#id921">‘<tt class="docutils literal"><span class="pre">fpmath</span></tt>‘ Metadata</a><a class="headerlink" href="#fpmath-metadata" title="Permalink to this headline">¶</a></h4>
+<p><tt class="docutils literal"><span class="pre">fpmath</span></tt> metadata may be attached to any instruction of floating point
+type. It can be used to express the maximum acceptable error in the
+result of that instruction, in ULPs, thus potentially allowing the
+compiler to use a more efficient but less accurate method of computing
+it. ULP is defined as follows:</p>
+<blockquote>
+<div>If <tt class="docutils literal"><span class="pre">x</span></tt> is a real number that lies between two finite consecutive
+floating-point numbers <tt class="docutils literal"><span class="pre">a</span></tt> and <tt class="docutils literal"><span class="pre">b</span></tt>, without being equal to one
+of them, then <tt class="docutils literal"><span class="pre">ulp(x)</span> <span class="pre">=</span> <span class="pre">|b</span> <span class="pre">-</span> <span class="pre">a|</span></tt>, otherwise <tt class="docutils literal"><span class="pre">ulp(x)</span></tt> is the
+distance between the two non-equal finite floating-point numbers
+nearest <tt class="docutils literal"><span class="pre">x</span></tt>. Moreover, <tt class="docutils literal"><span class="pre">ulp(NaN)</span></tt> is <tt class="docutils literal"><span class="pre">NaN</span></tt>.</div></blockquote>
+<p>The metadata node shall consist of a single positive float type number
+representing the maximum relative error, for example:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="p">!{</span> <span class="kt">float</span> <span class="m">2.5</span> <span class="p">}</span> <span class="c">; maximum acceptable inaccuracy is 2.5 ULPs</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="range-metadata">
+<span id="id19"></span><h4><a class="toc-backref" href="#id922">‘<tt class="docutils literal"><span class="pre">range</span></tt>‘ Metadata</a><a class="headerlink" href="#range-metadata" title="Permalink to this headline">¶</a></h4>
+<p><tt class="docutils literal"><span class="pre">range</span></tt> metadata may be attached only to <tt class="docutils literal"><span class="pre">load</span></tt>, <tt class="docutils literal"><span class="pre">call</span></tt> and <tt class="docutils literal"><span class="pre">invoke</span></tt> of
+integer types. It expresses the possible ranges the loaded value or the value
+returned by the called function at this call site is in. The ranges are
+represented with a flattened list of integers. The loaded value or the value
+returned is known to be in the union of the ranges defined by each consecutive
+pair. Each pair has the following properties:</p>
+<ul class="simple">
+<li>The type must match the type loaded by the instruction.</li>
+<li>The pair <tt class="docutils literal"><span class="pre">a,b</span></tt> represents the range <tt class="docutils literal"><span class="pre">[a,b)</span></tt>.</li>
+<li>Both <tt class="docutils literal"><span class="pre">a</span></tt> and <tt class="docutils literal"><span class="pre">b</span></tt> are constants.</li>
+<li>The range is allowed to wrap.</li>
+<li>The range should not represent the full or empty set. That is,
+<tt class="docutils literal"><span class="pre">a!=b</span></tt>.</li>
+</ul>
+<p>In addition, the pairs must be in signed order of the lower bound and
+they must be non-contiguous.</p>
+<p>Examples:</p>
+<div class="highlight-llvm"><div class="highlight"><pre>  <span class="nv">%a</span> <span class="p">=</span> <span class="k">load</span> <span class="k">i8</span><span class="p">,</span> <span class="k">i8</span><span class="p">*</span> <span class="nv">%x</span><span class="p">,</span> <span class="k">align</span> <span class="m">1</span><span class="p">,</span> <span class="nv">!range</span> <span class="nv-Anonymous">!0</span> <span class="c">; Can only be 0 or 1</span>
+  <span class="nv">%b</span> <span class="p">=</span> <span class="k">load</span> <span class="k">i8</span><span class="p">,</span> <span class="k">i8</span><span class="p">*</span> <span class="nv">%y</span><span class="p">,</span> <span class="k">align</span> <span class="m">1</span><span class="p">,</span> <span class="nv">!range</span> <span class="nv-Anonymous">!1</span> <span class="c">; Can only be 255 (-1), 0 or 1</span>
+  <span class="nv">%c</span> <span class="p">=</span> <span class="k">call</span> <span class="k">i8</span> <span class="vg">@foo</span><span class="p">(),</span>       <span class="nv">!range</span> <span class="nv-Anonymous">!2</span> <span class="c">; Can only be 0, 1, 3, 4 or 5</span>
+  <span class="nv">%d</span> <span class="p">=</span> <span class="k">invoke</span> <span class="k">i8</span> <span class="vg">@bar</span><span class="p">()</span> <span class="k">to</span> <span class="kt">label</span> <span class="nv">%cont</span>
+         <span class="k">unwind</span> <span class="kt">label</span> <span class="nv">%lpad</span><span class="p">,</span> <span class="nv">!range</span> <span class="nv-Anonymous">!3</span> <span class="c">; Can only be -2, -1, 3, 4 or 5</span>
+<span class="p">...</span>
+<span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="p">!{</span> <span class="k">i8</span> <span class="m">0</span><span class="p">,</span> <span class="k">i8</span> <span class="m">2</span> <span class="p">}</span>
+<span class="nv-Anonymous">!1</span> <span class="p">=</span> <span class="p">!{</span> <span class="k">i8</span> <span class="m">255</span><span class="p">,</span> <span class="k">i8</span> <span class="m">2</span> <span class="p">}</span>
+<span class="nv-Anonymous">!2</span> <span class="p">=</span> <span class="p">!{</span> <span class="k">i8</span> <span class="m">0</span><span class="p">,</span> <span class="k">i8</span> <span class="m">2</span><span class="p">,</span> <span class="k">i8</span> <span class="m">3</span><span class="p">,</span> <span class="k">i8</span> <span class="m">6</span> <span class="p">}</span>
+<span class="nv-Anonymous">!3</span> <span class="p">=</span> <span class="p">!{</span> <span class="k">i8</span> <span class="m">-2</span><span class="p">,</span> <span class="k">i8</span> <span class="m">0</span><span class="p">,</span> <span class="k">i8</span> <span class="m">3</span><span class="p">,</span> <span class="k">i8</span> <span class="m">6</span> <span class="p">}</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="absolute-symbol-metadata">
+<h4><a class="toc-backref" href="#id923">‘<tt class="docutils literal"><span class="pre">absolute_symbol</span></tt>‘ Metadata</a><a class="headerlink" href="#absolute-symbol-metadata" title="Permalink to this headline">¶</a></h4>
+<p><tt class="docutils literal"><span class="pre">absolute_symbol</span></tt> metadata may be attached to a global variable
+declaration. It marks the declaration as a reference to an absolute symbol,
+which causes the backend to use absolute relocations for the symbol even
+in position independent code, and expresses the possible ranges that the
+global variable’s <em>address</em> (not its value) is in, in the same format as
+<tt class="docutils literal"><span class="pre">range</span></tt> metadata, with the extension that the pair <tt class="docutils literal"><span class="pre">all-ones,all-ones</span></tt>
+may be used to represent the full set.</p>
+<p>Example (assuming 64-bit pointers):</p>
+<div class="highlight-llvm"><div class="highlight"><pre>  <span class="vg">@a</span> <span class="p">=</span> <span class="k">external</span> <span class="k">global</span> <span class="k">i8</span><span class="p">,</span> <span class="nv">!absolute_symbol</span> <span class="nv-Anonymous">!0</span> <span class="c">; Absolute symbol in range [0,256)</span>
+  <span class="vg">@b</span> <span class="p">=</span> <span class="k">external</span> <span class="k">global</span> <span class="k">i8</span><span class="p">,</span> <span class="nv">!absolute_symbol</span> <span class="nv-Anonymous">!1</span> <span class="c">; Absolute symbol in range [0,2^64)</span>
+
+<span class="p">...</span>
+<span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="p">!{</span> <span class="k">i64</span> <span class="m">0</span><span class="p">,</span> <span class="k">i64</span> <span class="m">256</span> <span class="p">}</span>
+<span class="nv-Anonymous">!1</span> <span class="p">=</span> <span class="p">!{</span> <span class="k">i64</span> <span class="m">-1</span><span class="p">,</span> <span class="k">i64</span> <span class="m">-1</span> <span class="p">}</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="callees-metadata">
+<h4><a class="toc-backref" href="#id924">‘<tt class="docutils literal"><span class="pre">callees</span></tt>‘ Metadata</a><a class="headerlink" href="#callees-metadata" title="Permalink to this headline">¶</a></h4>
+<p><tt class="docutils literal"><span class="pre">callees</span></tt> metadata may be attached to indirect call sites. If <tt class="docutils literal"><span class="pre">callees</span></tt>
+metadata is attached to a call site, and any callee is not among the set of
+functions provided by the metadata, the behavior is undefined. The intent of
+this metadata is to facilitate optimizations such as indirect-call promotion.
+For example, in the code below, the call instruction may only target the
+<tt class="docutils literal"><span class="pre">add</span></tt> or <tt class="docutils literal"><span class="pre">sub</span></tt> functions:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%result</span> <span class="p">=</span> <span class="k">call</span> <span class="k">i64</span> <span class="nv">%binop</span><span class="p">(</span><span class="k">i64</span> <span class="nv">%x</span><span class="p">,</span> <span class="k">i64</span> <span class="nv">%y</span><span class="p">),</span> <span class="nv">!callees</span> <span class="nv-Anonymous">!0</span>
+
+<span class="p">...</span>
+<span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="p">!{</span><span class="k">i64</span> <span class="p">(</span><span class="k">i64</span><span class="p">,</span> <span class="k">i64</span><span class="p">)*</span> <span class="vg">@add</span><span class="p">,</span> <span class="k">i64</span> <span class="p">(</span><span class="k">i64</span><span class="p">,</span> <span class="k">i64</span><span class="p">)*</span> <span class="vg">@sub</span><span class="p">}</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="unpredictable-metadata">
+<h4><a class="toc-backref" href="#id925">‘<tt class="docutils literal"><span class="pre">unpredictable</span></tt>‘ Metadata</a><a class="headerlink" href="#unpredictable-metadata" title="Permalink to this headline">¶</a></h4>
+<p><tt class="docutils literal"><span class="pre">unpredictable</span></tt> metadata may be attached to any branch or switch
+instruction. It can be used to express the unpredictability of control
+flow. Similar to the llvm.expect intrinsic, it may be used to alter
+optimizations related to compare and branch instructions. The metadata
+is treated as a boolean value; if it exists, it signals that the branch
+or switch that it is attached to is completely unpredictable.</p>
+</div>
+<div class="section" id="llvm-loop">
+<h4><a class="toc-backref" href="#id926">‘<tt class="docutils literal"><span class="pre">llvm.loop</span></tt>‘</a><a class="headerlink" href="#llvm-loop" title="Permalink to this headline">¶</a></h4>
+<p>It is sometimes useful to attach information to loop constructs. Currently,
+loop metadata is implemented as metadata attached to the branch instruction
+in the loop latch block. This type of metadata refer to a metadata node that is
+guaranteed to be separate for each loop. The loop identifier metadata is
+specified with the name <tt class="docutils literal"><span class="pre">llvm.loop</span></tt>.</p>
+<p>The loop identifier metadata is implemented using a metadata that refers to
+itself to avoid merging it with any other identifier metadata, e.g.,
+during module linkage or function inlining. That is, each loop should refer
+to their own identification metadata even if they reside in separate functions.
+The following example contains loop identifier metadata for two separate loop
+constructs:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="p">!{</span><span class="nv-Anonymous">!0</span><span class="p">}</span>
+<span class="nv-Anonymous">!1</span> <span class="p">=</span> <span class="p">!{</span><span class="nv-Anonymous">!1</span><span class="p">}</span>
+</pre></div>
+</div>
+<p>The loop identifier metadata can be used to specify additional
+per-loop metadata. Any operands after the first operand can be treated
+as user-defined metadata. For example the <tt class="docutils literal"><span class="pre">llvm.loop.unroll.count</span></tt>
+suggests an unroll factor to the loop unroller:</p>
+<div class="highlight-llvm"><div class="highlight"><pre>  <span class="k">br</span> <span class="k">i1</span> <span class="nv">%exitcond</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%._crit_edge</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%.lr.ph</span><span class="p">,</span> <span class="nv">!llvm.loop</span> <span class="nv-Anonymous">!0</span>
+<span class="p">...</span>
+<span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="p">!{</span><span class="nv-Anonymous">!0</span><span class="p">,</span> <span class="nv-Anonymous">!1</span><span class="p">}</span>
+<span class="nv-Anonymous">!1</span> <span class="p">=</span> <span class="p">!{</span><span class="nv">!"llvm.loop.unroll.count"</span><span class="p">,</span> <span class="k">i32</span> <span class="m">4</span><span class="p">}</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="llvm-loop-vectorize-and-llvm-loop-interleave">
+<h4><a class="toc-backref" href="#id927">‘<tt class="docutils literal"><span class="pre">llvm.loop.vectorize</span></tt>‘ and ‘<tt class="docutils literal"><span class="pre">llvm.loop.interleave</span></tt>‘</a><a class="headerlink" href="#llvm-loop-vectorize-and-llvm-loop-interleave" title="Permalink to this headline">¶</a></h4>
+<p>Metadata prefixed with <tt class="docutils literal"><span class="pre">llvm.loop.vectorize</span></tt> or <tt class="docutils literal"><span class="pre">llvm.loop.interleave</span></tt> are
+used to control per-loop vectorization and interleaving parameters such as
+vectorization width and interleave count. These metadata should be used in
+conjunction with <tt class="docutils literal"><span class="pre">llvm.loop</span></tt> loop identification metadata. The
+<tt class="docutils literal"><span class="pre">llvm.loop.vectorize</span></tt> and <tt class="docutils literal"><span class="pre">llvm.loop.interleave</span></tt> metadata are only
+optimization hints and the optimizer will only interleave and vectorize loops if
+it believes it is safe to do so. The <tt class="docutils literal"><span class="pre">llvm.mem.parallel_loop_access</span></tt> metadata
+which contains information about loop-carried memory dependencies can be helpful
+in determining the safety of these transformations.</p>
+</div>
+<div class="section" id="llvm-loop-interleave-count-metadata">
+<h4><a class="toc-backref" href="#id928">‘<tt class="docutils literal"><span class="pre">llvm.loop.interleave.count</span></tt>‘ Metadata</a><a class="headerlink" href="#llvm-loop-interleave-count-metadata" title="Permalink to this headline">¶</a></h4>
+<p>This metadata suggests an interleave count to the loop interleaver.
+The first operand is the string <tt class="docutils literal"><span class="pre">llvm.loop.interleave.count</span></tt> and the
+second operand is an integer specifying the interleave count. For
+example:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="p">!{</span><span class="nv">!"llvm.loop.interleave.count"</span><span class="p">,</span> <span class="k">i32</span> <span class="m">4</span><span class="p">}</span>
+</pre></div>
+</div>
+<p>Note that setting <tt class="docutils literal"><span class="pre">llvm.loop.interleave.count</span></tt> to 1 disables interleaving
+multiple iterations of the loop. If <tt class="docutils literal"><span class="pre">llvm.loop.interleave.count</span></tt> is set to 0
+then the interleave count will be determined automatically.</p>
+</div>
+<div class="section" id="llvm-loop-vectorize-enable-metadata">
+<h4><a class="toc-backref" href="#id929">‘<tt class="docutils literal"><span class="pre">llvm.loop.vectorize.enable</span></tt>‘ Metadata</a><a class="headerlink" href="#llvm-loop-vectorize-enable-metadata" title="Permalink to this headline">¶</a></h4>
+<p>This metadata selectively enables or disables vectorization for the loop. The
+first operand is the string <tt class="docutils literal"><span class="pre">llvm.loop.vectorize.enable</span></tt> and the second operand
+is a bit. If the bit operand value is 1 vectorization is enabled. A value of
+0 disables vectorization:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="p">!{</span><span class="nv">!"llvm.loop.vectorize.enable"</span><span class="p">,</span> <span class="k">i1</span> <span class="m">0</span><span class="p">}</span>
+<span class="nv-Anonymous">!1</span> <span class="p">=</span> <span class="p">!{</span><span class="nv">!"llvm.loop.vectorize.enable"</span><span class="p">,</span> <span class="k">i1</span> <span class="m">1</span><span class="p">}</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="llvm-loop-vectorize-width-metadata">
+<h4><a class="toc-backref" href="#id930">‘<tt class="docutils literal"><span class="pre">llvm.loop.vectorize.width</span></tt>‘ Metadata</a><a class="headerlink" href="#llvm-loop-vectorize-width-metadata" title="Permalink to this headline">¶</a></h4>
+<p>This metadata sets the target width of the vectorizer. The first
+operand is the string <tt class="docutils literal"><span class="pre">llvm.loop.vectorize.width</span></tt> and the second
+operand is an integer specifying the width. For example:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="p">!{</span><span class="nv">!"llvm.loop.vectorize.width"</span><span class="p">,</span> <span class="k">i32</span> <span class="m">4</span><span class="p">}</span>
+</pre></div>
+</div>
+<p>Note that setting <tt class="docutils literal"><span class="pre">llvm.loop.vectorize.width</span></tt> to 1 disables
+vectorization of the loop. If <tt class="docutils literal"><span class="pre">llvm.loop.vectorize.width</span></tt> is set to
+0 or if the loop does not have this metadata the width will be
+determined automatically.</p>
+</div>
+<div class="section" id="llvm-loop-unroll">
+<h4><a class="toc-backref" href="#id931">‘<tt class="docutils literal"><span class="pre">llvm.loop.unroll</span></tt>‘</a><a class="headerlink" href="#llvm-loop-unroll" title="Permalink to this headline">¶</a></h4>
+<p>Metadata prefixed with <tt class="docutils literal"><span class="pre">llvm.loop.unroll</span></tt> are loop unrolling
+optimization hints such as the unroll factor. <tt class="docutils literal"><span class="pre">llvm.loop.unroll</span></tt>
+metadata should be used in conjunction with <tt class="docutils literal"><span class="pre">llvm.loop</span></tt> loop
+identification metadata. The <tt class="docutils literal"><span class="pre">llvm.loop.unroll</span></tt> metadata are only
+optimization hints and the unrolling will only be performed if the
+optimizer believes it is safe to do so.</p>
+</div>
+<div class="section" id="llvm-loop-unroll-count-metadata">
+<h4><a class="toc-backref" href="#id932">‘<tt class="docutils literal"><span class="pre">llvm.loop.unroll.count</span></tt>‘ Metadata</a><a class="headerlink" href="#llvm-loop-unroll-count-metadata" title="Permalink to this headline">¶</a></h4>
+<p>This metadata suggests an unroll factor to the loop unroller. The
+first operand is the string <tt class="docutils literal"><span class="pre">llvm.loop.unroll.count</span></tt> and the second
+operand is a positive integer specifying the unroll factor. For
+example:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="p">!{</span><span class="nv">!"llvm.loop.unroll.count"</span><span class="p">,</span> <span class="k">i32</span> <span class="m">4</span><span class="p">}</span>
+</pre></div>
+</div>
+<p>If the trip count of the loop is less than the unroll count the loop
+will be partially unrolled.</p>
+</div>
+<div class="section" id="llvm-loop-unroll-disable-metadata">
+<h4><a class="toc-backref" href="#id933">‘<tt class="docutils literal"><span class="pre">llvm.loop.unroll.disable</span></tt>‘ Metadata</a><a class="headerlink" href="#llvm-loop-unroll-disable-metadata" title="Permalink to this headline">¶</a></h4>
+<p>This metadata disables loop unrolling. The metadata has a single operand
+which is the string <tt class="docutils literal"><span class="pre">llvm.loop.unroll.disable</span></tt>. For example:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="p">!{</span><span class="nv">!"llvm.loop.unroll.disable"</span><span class="p">}</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="llvm-loop-unroll-runtime-disable-metadata">
+<h4><a class="toc-backref" href="#id934">‘<tt class="docutils literal"><span class="pre">llvm.loop.unroll.runtime.disable</span></tt>‘ Metadata</a><a class="headerlink" href="#llvm-loop-unroll-runtime-disable-metadata" title="Permalink to this headline">¶</a></h4>
+<p>This metadata disables runtime loop unrolling. The metadata has a single
+operand which is the string <tt class="docutils literal"><span class="pre">llvm.loop.unroll.runtime.disable</span></tt>. For example:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="p">!{</span><span class="nv">!"llvm.loop.unroll.runtime.disable"</span><span class="p">}</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="llvm-loop-unroll-enable-metadata">
+<h4><a class="toc-backref" href="#id935">‘<tt class="docutils literal"><span class="pre">llvm.loop.unroll.enable</span></tt>‘ Metadata</a><a class="headerlink" href="#llvm-loop-unroll-enable-metadata" title="Permalink to this headline">¶</a></h4>
+<p>This metadata suggests that the loop should be fully unrolled if the trip count
+is known at compile time and partially unrolled if the trip count is not known
+at compile time. The metadata has a single operand which is the string
+<tt class="docutils literal"><span class="pre">llvm.loop.unroll.enable</span></tt>.  For example:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="p">!{</span><span class="nv">!"llvm.loop.unroll.enable"</span><span class="p">}</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="llvm-loop-unroll-full-metadata">
+<h4><a class="toc-backref" href="#id936">‘<tt class="docutils literal"><span class="pre">llvm.loop.unroll.full</span></tt>‘ Metadata</a><a class="headerlink" href="#llvm-loop-unroll-full-metadata" title="Permalink to this headline">¶</a></h4>
+<p>This metadata suggests that the loop should be unrolled fully. The
+metadata has a single operand which is the string <tt class="docutils literal"><span class="pre">llvm.loop.unroll.full</span></tt>.
+For example:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="p">!{</span><span class="nv">!"llvm.loop.unroll.full"</span><span class="p">}</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="llvm-loop-licm-versioning-disable-metadata">
+<h4><a class="toc-backref" href="#id937">‘<tt class="docutils literal"><span class="pre">llvm.loop.licm_versioning.disable</span></tt>‘ Metadata</a><a class="headerlink" href="#llvm-loop-licm-versioning-disable-metadata" title="Permalink to this headline">¶</a></h4>
+<p>This metadata indicates that the loop should not be versioned for the purpose
+of enabling loop-invariant code motion (LICM). The metadata has a single operand
+which is the string <tt class="docutils literal"><span class="pre">llvm.loop.licm_versioning.disable</span></tt>. For example:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="p">!{</span><span class="nv">!"llvm.loop.licm_versioning.disable"</span><span class="p">}</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="llvm-loop-distribute-enable-metadata">
+<h4><a class="toc-backref" href="#id938">‘<tt class="docutils literal"><span class="pre">llvm.loop.distribute.enable</span></tt>‘ Metadata</a><a class="headerlink" href="#llvm-loop-distribute-enable-metadata" title="Permalink to this headline">¶</a></h4>
+<p>Loop distribution allows splitting a loop into multiple loops.  Currently,
+this is only performed if the entire loop cannot be vectorized due to unsafe
+memory dependencies.  The transformation will attempt to isolate the unsafe
+dependencies into their own loop.</p>
+<p>This metadata can be used to selectively enable or disable distribution of the
+loop.  The first operand is the string <tt class="docutils literal"><span class="pre">llvm.loop.distribute.enable</span></tt> and the
+second operand is a bit. If the bit operand value is 1 distribution is
+enabled. A value of 0 disables distribution:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="p">!{</span><span class="nv">!"llvm.loop.distribute.enable"</span><span class="p">,</span> <span class="k">i1</span> <span class="m">0</span><span class="p">}</span>
+<span class="nv-Anonymous">!1</span> <span class="p">=</span> <span class="p">!{</span><span class="nv">!"llvm.loop.distribute.enable"</span><span class="p">,</span> <span class="k">i1</span> <span class="m">1</span><span class="p">}</span>
+</pre></div>
+</div>
+<p>This metadata should be used in conjunction with <tt class="docutils literal"><span class="pre">llvm.loop</span></tt> loop
+identification metadata.</p>
+</div>
+<div class="section" id="llvm-mem">
+<h4><a class="toc-backref" href="#id939">‘<tt class="docutils literal"><span class="pre">llvm.mem</span></tt>‘</a><a class="headerlink" href="#llvm-mem" title="Permalink to this headline">¶</a></h4>
+<p>Metadata types used to annotate memory accesses with information helpful
+for optimizations are prefixed with <tt class="docutils literal"><span class="pre">llvm.mem</span></tt>.</p>
+</div>
+<div class="section" id="llvm-mem-parallel-loop-access-metadata">
+<h4><a class="toc-backref" href="#id940">‘<tt class="docutils literal"><span class="pre">llvm.mem.parallel_loop_access</span></tt>‘ Metadata</a><a class="headerlink" href="#llvm-mem-parallel-loop-access-metadata" title="Permalink to this headline">¶</a></h4>
+<p>The <tt class="docutils literal"><span class="pre">llvm.mem.parallel_loop_access</span></tt> metadata refers to a loop identifier,
+or metadata containing a list of loop identifiers for nested loops.
+The metadata is attached to memory accessing instructions and denotes that
+no loop carried memory dependence exist between it and other instructions denoted
+with the same loop identifier. The metadata on memory reads also implies that
+if conversion (i.e. speculative execution within a loop iteration) is safe.</p>
+<p>Precisely, given two instructions <tt class="docutils literal"><span class="pre">m1</span></tt> and <tt class="docutils literal"><span class="pre">m2</span></tt> that both have the
+<tt class="docutils literal"><span class="pre">llvm.mem.parallel_loop_access</span></tt> metadata, with <tt class="docutils literal"><span class="pre">L1</span></tt> and <tt class="docutils literal"><span class="pre">L2</span></tt> being the
+set of loops associated with that metadata, respectively, then there is no loop
+carried dependence between <tt class="docutils literal"><span class="pre">m1</span></tt> and <tt class="docutils literal"><span class="pre">m2</span></tt> for loops in both <tt class="docutils literal"><span class="pre">L1</span></tt> and
+<tt class="docutils literal"><span class="pre">L2</span></tt>.</p>
+<p>As a special case, if all memory accessing instructions in a loop have
+<tt class="docutils literal"><span class="pre">llvm.mem.parallel_loop_access</span></tt> metadata that refers to that loop, then the
+loop has no loop carried memory dependences and is considered to be a parallel
+loop.</p>
+<p>Note that if not all memory access instructions have such metadata referring to
+the loop, then the loop is considered not being trivially parallel. Additional
+memory dependence analysis is required to make that determination. As a fail
+safe mechanism, this causes loops that were originally parallel to be considered
+sequential (if optimization passes that are unaware of the parallel semantics
+insert new memory instructions into the loop body).</p>
+<p>Example of a loop that is considered parallel due to its correct use of
+both <tt class="docutils literal"><span class="pre">llvm.loop</span></tt> and <tt class="docutils literal"><span class="pre">llvm.mem.parallel_loop_access</span></tt>
+metadata types that refer to the same loop identifier metadata.</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nl">for.body:</span>
+  <span class="p">...</span>
+  <span class="nv">%val0</span> <span class="p">=</span> <span class="k">load</span> <span class="k">i32</span><span class="p">,</span> <span class="k">i32</span><span class="p">*</span> <span class="nv">%arrayidx</span><span class="p">,</span> <span class="nv">!llvm.mem.parallel_loop_access</span> <span class="nv-Anonymous">!0</span>
+  <span class="p">...</span>
+  <span class="k">store</span> <span class="k">i32</span> <span class="nv">%val0</span><span class="p">,</span> <span class="k">i32</span><span class="p">*</span> <span class="nv">%arrayidx1</span><span class="p">,</span> <span class="nv">!llvm.mem.parallel_loop_access</span> <span class="nv-Anonymous">!0</span>
+  <span class="p">...</span>
+  <span class="k">br</span> <span class="k">i1</span> <span class="nv">%exitcond</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%for.end</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%for.body</span><span class="p">,</span> <span class="nv">!llvm.loop</span> <span class="nv-Anonymous">!0</span>
+
+<span class="nl">for.end:</span>
+<span class="p">...</span>
+<span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="p">!{</span><span class="nv-Anonymous">!0</span><span class="p">}</span>
+</pre></div>
+</div>
+<p>It is also possible to have nested parallel loops. In that case the
+memory accesses refer to a list of loop identifier metadata nodes instead of
+the loop identifier metadata node directly:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nl">outer.for.body:</span>
+  <span class="p">...</span>
+  <span class="nv">%val1</span> <span class="p">=</span> <span class="k">load</span> <span class="k">i32</span><span class="p">,</span> <span class="k">i32</span><span class="p">*</span> <span class="nv">%arrayidx3</span><span class="p">,</span> <span class="nv">!llvm.mem.parallel_loop_access</span> <span class="nv-Anonymous">!2</span>
+  <span class="p">...</span>
+  <span class="k">br</span> <span class="kt">label</span> <span class="nv">%inner.for.body</span>
+
+<span class="nl">inner.for.body:</span>
+  <span class="p">...</span>
+  <span class="nv">%val0</span> <span class="p">=</span> <span class="k">load</span> <span class="k">i32</span><span class="p">,</span> <span class="k">i32</span><span class="p">*</span> <span class="nv">%arrayidx1</span><span class="p">,</span> <span class="nv">!llvm.mem.parallel_loop_access</span> <span class="nv-Anonymous">!0</span>
+  <span class="p">...</span>
+  <span class="k">store</span> <span class="k">i32</span> <span class="nv">%val0</span><span class="p">,</span> <span class="k">i32</span><span class="p">*</span> <span class="nv">%arrayidx2</span><span class="p">,</span> <span class="nv">!llvm.mem.parallel_loop_access</span> <span class="nv-Anonymous">!0</span>
+  <span class="p">...</span>
+  <span class="k">br</span> <span class="k">i1</span> <span class="nv">%exitcond</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%inner.for.end</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%inner.for.body</span><span class="p">,</span> <span class="nv">!llvm.loop</span> <span class="nv-Anonymous">!1</span>
+
+<span class="nl">inner.for.end:</span>
+  <span class="p">...</span>
+  <span class="k">store</span> <span class="k">i32</span> <span class="nv">%val1</span><span class="p">,</span> <span class="k">i32</span><span class="p">*</span> <span class="nv">%arrayidx4</span><span class="p">,</span> <span class="nv">!llvm.mem.parallel_loop_access</span> <span class="nv-Anonymous">!2</span>
+  <span class="p">...</span>
+  <span class="k">br</span> <span class="k">i1</span> <span class="nv">%exitcond</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%outer.for.end</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%outer.for.body</span><span class="p">,</span> <span class="nv">!llvm.loop</span> <span class="nv-Anonymous">!2</span>
+
+<span class="nl">outer.for.end:</span>                                          <span class="c">; preds = %for.body</span>
+<span class="p">...</span>
+<span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="p">!{</span><span class="nv-Anonymous">!1</span><span class="p">,</span> <span class="nv-Anonymous">!2</span><span class="p">}</span> <span class="c">; a list of loop identifiers</span>
+<span class="nv-Anonymous">!1</span> <span class="p">=</span> <span class="p">!{</span><span class="nv-Anonymous">!1</span><span class="p">}</span> <span class="c">; an identifier for the inner loop</span>
+<span class="nv-Anonymous">!2</span> <span class="p">=</span> <span class="p">!{</span><span class="nv-Anonymous">!2</span><span class="p">}</span> <span class="c">; an identifier for the outer loop</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="irr-loop-metadata">
+<h4><a class="toc-backref" href="#id941">‘<tt class="docutils literal"><span class="pre">irr_loop</span></tt>‘ Metadata</a><a class="headerlink" href="#irr-loop-metadata" title="Permalink to this headline">¶</a></h4>
+<p><tt class="docutils literal"><span class="pre">irr_loop</span></tt> metadata may be attached to the terminator instruction of a basic
+block that’s an irreducible loop header (note that an irreducible loop has more
+than once header basic blocks.) If <tt class="docutils literal"><span class="pre">irr_loop</span></tt> metadata is attached to the
+terminator instruction of a basic block that is not really an irreducible loop
+header, the behavior is undefined. The intent of this metadata is to improve the
+accuracy of the block frequency propagation. For example, in the code below, the
+block <tt class="docutils literal"><span class="pre">header0</span></tt> may have a loop header weight (relative to the other headers of
+the irreducible loop) of 100:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nl">header0:</span>
+<span class="p">...</span>
+<span class="k">br</span> <span class="k">i1</span> <span class="nv">%cmp</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%t1</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%t2</span><span class="p">,</span> <span class="nv">!irr_loop</span> <span class="nv-Anonymous">!0</span>
+
+<span class="p">...</span>
+<span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="p">!{</span><span class="s">"loop_header_weight"</span><span class="p">,</span> <span class="k">i64</span> <span class="m">100</span><span class="p">}</span>
+</pre></div>
+</div>
+<p>Irreducible loop header weights are typically based on profile data.</p>
+</div>
+<div class="section" id="invariant-group-metadata">
+<h4><a class="toc-backref" href="#id942">‘<tt class="docutils literal"><span class="pre">invariant.group</span></tt>‘ Metadata</a><a class="headerlink" href="#invariant-group-metadata" title="Permalink to this headline">¶</a></h4>
+<p>The <tt class="docutils literal"><span class="pre">invariant.group</span></tt> metadata may be attached to <tt class="docutils literal"><span class="pre">load</span></tt>/<tt class="docutils literal"><span class="pre">store</span></tt> instructions.
+The existence of the <tt class="docutils literal"><span class="pre">invariant.group</span></tt> metadata on the instruction tells
+the optimizer that every <tt class="docutils literal"><span class="pre">load</span></tt> and <tt class="docutils literal"><span class="pre">store</span></tt> to the same pointer operand
+within the same invariant group can be assumed to load or store the same
+value (but see the <tt class="docutils literal"><span class="pre">llvm.invariant.group.barrier</span></tt> intrinsic which affects
+when two pointers are considered the same). Pointers returned by bitcast or
+getelementptr with only zero indices are considered the same.</p>
+<p>Examples:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="vg">@unknownPtr</span> <span class="p">=</span> <span class="k">external</span> <span class="k">global</span> <span class="k">i8</span>
+<span class="p">...</span>
+<span class="nv">%ptr</span> <span class="p">=</span> <span class="k">alloca</span> <span class="k">i8</span>
+<span class="k">store</span> <span class="k">i8</span> <span class="m">42</span><span class="p">,</span> <span class="k">i8</span><span class="p">*</span> <span class="nv">%ptr</span><span class="p">,</span> <span class="nv">!invariant.group</span> <span class="nv-Anonymous">!0</span>
+<span class="k">call</span> <span class="kt">void</span> <span class="vg">@foo</span><span class="p">(</span><span class="k">i8</span><span class="p">*</span> <span class="nv">%ptr</span><span class="p">)</span>
+
+<span class="nv">%a</span> <span class="p">=</span> <span class="k">load</span> <span class="k">i8</span><span class="p">,</span> <span class="k">i8</span><span class="p">*</span> <span class="nv">%ptr</span><span class="p">,</span> <span class="nv">!invariant.group</span> <span class="nv-Anonymous">!0</span> <span class="c">; Can assume that value under %ptr didn't change</span>
+<span class="k">call</span> <span class="kt">void</span> <span class="vg">@foo</span><span class="p">(</span><span class="k">i8</span><span class="p">*</span> <span class="nv">%ptr</span><span class="p">)</span>
+<span class="nv">%b</span> <span class="p">=</span> <span class="k">load</span> <span class="k">i8</span><span class="p">,</span> <span class="k">i8</span><span class="p">*</span> <span class="nv">%ptr</span><span class="p">,</span> <span class="nv">!invariant.group</span> <span class="nv-Anonymous">!1</span> <span class="c">; Can't assume anything, because group changed</span>
+
+<span class="nv">%newPtr</span> <span class="p">=</span> <span class="k">call</span> <span class="k">i8</span><span class="p">*</span> <span class="vg">@getPointer</span><span class="p">(</span><span class="k">i8</span><span class="p">*</span> <span class="nv">%ptr</span><span class="p">)</span>
+<span class="nv">%c</span> <span class="p">=</span> <span class="k">load</span> <span class="k">i8</span><span class="p">,</span> <span class="k">i8</span><span class="p">*</span> <span class="nv">%newPtr</span><span class="p">,</span> <span class="nv">!invariant.group</span> <span class="nv-Anonymous">!0</span> <span class="c">; Can't assume anything, because we only have information about %ptr</span>
+
+<span class="nv">%unknownValue</span> <span class="p">=</span> <span class="k">load</span> <span class="k">i8</span><span class="p">,</span> <span class="k">i8</span><span class="p">*</span> <span class="vg">@unknownPtr</span>
+<span class="k">store</span> <span class="k">i8</span> <span class="nv">%unknownValue</span><span class="p">,</span> <span class="k">i8</span><span class="p">*</span> <span class="nv">%ptr</span><span class="p">,</span> <span class="nv">!invariant.group</span> <span class="nv-Anonymous">!0</span> <span class="c">; Can assume that %unknownValue == 42</span>
+
+<span class="k">call</span> <span class="kt">void</span> <span class="vg">@foo</span><span class="p">(</span><span class="k">i8</span><span class="p">*</span> <span class="nv">%ptr</span><span class="p">)</span>
+<span class="nv">%newPtr2</span> <span class="p">=</span> <span class="k">call</span> <span class="k">i8</span><span class="p">*</span> <span class="vg">@llvm.invariant.group.barrier</span><span class="p">(</span><span class="k">i8</span><span class="p">*</span> <span class="nv">%ptr</span><span class="p">)</span>
+<span class="nv">%d</span> <span class="p">=</span> <span class="k">load</span> <span class="k">i8</span><span class="p">,</span> <span class="k">i8</span><span class="p">*</span> <span class="nv">%newPtr2</span><span class="p">,</span> <span class="nv">!invariant.group</span> <span class="nv-Anonymous">!0</span>  <span class="c">; Can't step through invariant.group.barrier to get value of %ptr</span>
+
+<span class="p">...</span>
+<span class="k">declare</span> <span class="kt">void</span> <span class="vg">@foo</span><span class="p">(</span><span class="k">i8</span><span class="p">*)</span>
+<span class="k">declare</span> <span class="k">i8</span><span class="p">*</span> <span class="vg">@getPointer</span><span class="p">(</span><span class="k">i8</span><span class="p">*)</span>
+<span class="k">declare</span> <span class="k">i8</span><span class="p">*</span> <span class="vg">@llvm.invariant.group.barrier</span><span class="p">(</span><span class="k">i8</span><span class="p">*)</span>
+
+<span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="p">!{</span><span class="nv">!"magic ptr"</span><span class="p">}</span>
+<span class="nv-Anonymous">!1</span> <span class="p">=</span> <span class="p">!{</span><span class="nv">!"other ptr"</span><span class="p">}</span>
+</pre></div>
+</div>
+<p>The invariant.group metadata must be dropped when replacing one pointer by
+another based on aliasing information. This is because invariant.group is tied
+to the SSA value of the pointer operand.</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%v</span> <span class="p">=</span> <span class="k">load</span> <span class="k">i8</span><span class="p">,</span> <span class="k">i8</span><span class="p">*</span> <span class="nv">%x</span><span class="p">,</span> <span class="nv">!invariant.group</span> <span class="nv-Anonymous">!0</span>
+<span class="c">; if %x mustalias %y then we can replace the above instruction with</span>
+<span class="nv">%v</span> <span class="p">=</span> <span class="k">load</span> <span class="k">i8</span><span class="p">,</span> <span class="k">i8</span><span class="p">*</span> <span class="nv">%y</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="type-metadata">
+<h4><a class="toc-backref" href="#id943">‘<tt class="docutils literal"><span class="pre">type</span></tt>‘ Metadata</a><a class="headerlink" href="#type-metadata" title="Permalink to this headline">¶</a></h4>
+<p>See <a class="reference internal" href="TypeMetadata.html"><em>Type Metadata</em></a>.</p>
+</div>
+<div class="section" id="associated-metadata">
+<h4><a class="toc-backref" href="#id944">‘<tt class="docutils literal"><span class="pre">associated</span></tt>‘ Metadata</a><a class="headerlink" href="#associated-metadata" title="Permalink to this headline">¶</a></h4>
+<p>The <tt class="docutils literal"><span class="pre">associated</span></tt> metadata may be attached to a global object
+declaration with a single argument that references another global object.</p>
+<p>This metadata prevents discarding of the global object in linker GC
+unless the referenced object is also discarded. The linker support for
+this feature is spotty. For best compatibility, globals carrying this
+metadata may also:</p>
+<ul class="simple">
+<li>Be in a comdat with the referenced global.</li>
+<li>Be in @llvm.compiler.used.</li>
+<li>Have an explicit section with a name which is a valid C identifier.</li>
+</ul>
+<p>It does not have any effect on non-ELF targets.</p>
+<p>Example:</p>
+<div class="highlight-text"><div class="highlight"><pre>$a = comdat any
+ at a = global i32 1, comdat $a
+ at b = internal global i32 2, comdat $a, section "abc", !associated !0
+!0 = !{i32* @a}
+</pre></div>
+</div>
+</div>
+<div class="section" id="prof-metadata">
+<h4><a class="toc-backref" href="#id945">‘<tt class="docutils literal"><span class="pre">prof</span></tt>‘ Metadata</a><a class="headerlink" href="#prof-metadata" title="Permalink to this headline">¶</a></h4>
+<p>The <tt class="docutils literal"><span class="pre">prof</span></tt> metadata is used to record profile data in the IR.
+The first operand of the metadata node indicates the profile metadata
+type. There are currently 3 types:
+<a class="reference internal" href="#prof-node-branch-weights"><em>branch_weights</em></a>,
+<a class="reference internal" href="#prof-node-function-entry-count"><em>function_entry_count</em></a>, and
+<a class="reference internal" href="#prof-node-vp"><em>VP</em></a>.</p>
+<div class="section" id="branch-weights">
+<span id="prof-node-branch-weights"></span><h5><a class="toc-backref" href="#id946">branch_weights</a><a class="headerlink" href="#branch-weights" title="Permalink to this headline">¶</a></h5>
+<p>Branch weight metadata attached to a branch, select, switch or call instruction
+represents the likeliness of the associated branch being taken.
+For more information, see <a class="reference internal" href="BranchWeightMetadata.html"><em>LLVM Branch Weight Metadata</em></a>.</p>
+</div>
+<div class="section" id="function-entry-count">
+<span id="prof-node-function-entry-count"></span><h5><a class="toc-backref" href="#id947">function_entry_count</a><a class="headerlink" href="#function-entry-count" title="Permalink to this headline">¶</a></h5>
+<p>Function entry count metadata can be attached to function definitions
+to record the number of times the function is called. Used with BFI
+information, it is also used to derive the basic block profile count.
+For more information, see <a class="reference internal" href="BranchWeightMetadata.html"><em>LLVM Branch Weight Metadata</em></a>.</p>
+</div>
+<div class="section" id="vp">
+<span id="prof-node-vp"></span><h5><a class="toc-backref" href="#id948">VP</a><a class="headerlink" href="#vp" title="Permalink to this headline">¶</a></h5>
+<p>VP (value profile) metadata can be attached to instructions that have
+value profile information. Currently this is indirect calls (where it
+records the hottest callees) and calls to memory intrinsics such as memcpy,
+memmove, and memset (where it records the hottest byte lengths).</p>
+<p>Each VP metadata node contains “VP” string, then a uint32_t value for the value
+profiling kind, a uint64_t value for the total number of times the instruction
+is executed, followed by uint64_t value and execution count pairs.
+The value profiling kind is 0 for indirect call targets and 1 for memory
+operations. For indirect call targets, each profile value is a hash
+of the callee function name, and for memory operations each value is the
+byte length.</p>
+<p>Note that the value counts do not need to add up to the total count
+listed in the third operand (in practice only the top hottest values
+are tracked and reported).</p>
+<p>Indirect call example:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="k">call</span> <span class="kt">void</span> <span class="nv">%f</span><span class="p">(),</span> <span class="nv">!prof</span> <span class="nv-Anonymous">!1</span>
+<span class="nv-Anonymous">!1</span> <span class="p">=</span> <span class="p">!{</span><span class="nv">!"VP"</span><span class="p">,</span> <span class="k">i32</span> <span class="m">0</span><span class="p">,</span> <span class="k">i64</span> <span class="m">1600</span><span class="p">,</span> <span class="k">i64</span> <span class="m">7651369219802541373</span><span class="p">,</span> <span class="k">i64</span> <span class="m">1030</span><span class="p">,</span> <span class="k">i64</span> <span class="m">-4377547752858689819</span><span class="p">,</span> <span class="k">i64</span> <span class="m">410</span><span class="p">}</span>
+</pre></div>
+</div>
+<p>Note that the VP type is 0 (the second operand), which indicates this is
+an indirect call value profile data. The third operand indicates that the
+indirect call executed 1600 times. The 4th and 6th operands give the
+hashes of the 2 hottest target functions’ names (this is the same hash used
+to represent function names in the profile database), and the 5th and 7th
+operands give the execution count that each of the respective prior target
+functions was called.</p>
+</div>
+</div>
+</div>
+</div>
+<div class="section" id="module-flags-metadata">
+<h2><a class="toc-backref" href="#id949">Module Flags Metadata</a><a class="headerlink" href="#module-flags-metadata" title="Permalink to this headline">¶</a></h2>
+<p>Information about the module as a whole is difficult to convey to LLVM’s
+subsystems. The LLVM IR isn’t sufficient to transmit this information.
+The <tt class="docutils literal"><span class="pre">llvm.module.flags</span></tt> named metadata exists in order to facilitate
+this. These flags are in the form of key / value pairs — much like a
+dictionary — making it easy for any subsystem who cares about a flag to
+look it up.</p>
+<p>The <tt class="docutils literal"><span class="pre">llvm.module.flags</span></tt> metadata contains a list of metadata triplets.
+Each triplet has the following form:</p>
+<ul class="simple">
+<li>The first element is a <em>behavior</em> flag, which specifies the behavior
+when two (or more) modules are merged together, and it encounters two
+(or more) metadata with the same ID. The supported behaviors are
+described below.</li>
+<li>The second element is a metadata string that is a unique ID for the
+metadata. Each module may only have one flag entry for each unique ID (not
+including entries with the <strong>Require</strong> behavior).</li>
+<li>The third element is the value of the flag.</li>
+</ul>
+<p>When two (or more) modules are merged together, the resulting
+<tt class="docutils literal"><span class="pre">llvm.module.flags</span></tt> metadata is the union of the modules’ flags. That is, for
+each unique metadata ID string, there will be exactly one entry in the merged
+modules <tt class="docutils literal"><span class="pre">llvm.module.flags</span></tt> metadata table, and the value for that entry will
+be determined by the merge behavior flag, as described below. The only exception
+is that entries with the <em>Require</em> behavior are always preserved.</p>
+<p>The following behaviors are supported:</p>
+<table border="1" class="docutils">
+<colgroup>
+<col width="10%" />
+<col width="90%" />
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">Value</th>
+<th class="head">Behavior</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>1</td>
+<td><dl class="first last docutils">
+<dt><strong>Error</strong></dt>
+<dd>Emits an error if two values disagree, otherwise the resulting value
+is that of the operands.</dd>
+</dl>
+</td>
+</tr>
+<tr class="row-odd"><td>2</td>
+<td><dl class="first last docutils">
+<dt><strong>Warning</strong></dt>
+<dd>Emits a warning if two values disagree. The result value will be the
+operand for the flag from the first module being linked.</dd>
+</dl>
+</td>
+</tr>
+<tr class="row-even"><td>3</td>
+<td><dl class="first last docutils">
+<dt><strong>Require</strong></dt>
+<dd>Adds a requirement that another module flag be present and have a
+specified value after linking is performed. The value must be a
+metadata pair, where the first element of the pair is the ID of the
+module flag to be restricted, and the second element of the pair is
+the value the module flag should be restricted to. This behavior can
+be used to restrict the allowable results (via triggering of an
+error) of linking IDs with the <strong>Override</strong> behavior.</dd>
+</dl>
+</td>
+</tr>
+<tr class="row-odd"><td>4</td>
+<td><dl class="first last docutils">
+<dt><strong>Override</strong></dt>
+<dd>Uses the specified value, regardless of the behavior or value of the
+other module. If both modules specify <strong>Override</strong>, but the values
+differ, an error will be emitted.</dd>
+</dl>
+</td>
+</tr>
+<tr class="row-even"><td>5</td>
+<td><dl class="first last docutils">
+<dt><strong>Append</strong></dt>
+<dd>Appends the two values, which are required to be metadata nodes.</dd>
+</dl>
+</td>
+</tr>
+<tr class="row-odd"><td>6</td>
+<td><dl class="first last docutils">
+<dt><strong>AppendUnique</strong></dt>
+<dd>Appends the two values, which are required to be metadata
+nodes. However, duplicate entries in the second list are dropped
+during the append operation.</dd>
+</dl>
+</td>
+</tr>
+<tr class="row-even"><td>7</td>
+<td><dl class="first last docutils">
+<dt><strong>Max</strong></dt>
+<dd>Takes the max of the two values, which are required to be integers.</dd>
+</dl>
+</td>
+</tr>
+</tbody>
+</table>
+<p>It is an error for a particular unique flag ID to have multiple behaviors,
+except in the case of <strong>Require</strong> (which adds restrictions on another metadata
+value) or <strong>Override</strong>.</p>
+<p>An example of module flags:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="p">!{</span> <span class="k">i32</span> <span class="m">1</span><span class="p">,</span> <span class="nv">!"foo"</span><span class="p">,</span> <span class="k">i32</span> <span class="m">1</span> <span class="p">}</span>
+<span class="nv-Anonymous">!1</span> <span class="p">=</span> <span class="p">!{</span> <span class="k">i32</span> <span class="m">4</span><span class="p">,</span> <span class="nv">!"bar"</span><span class="p">,</span> <span class="k">i32</span> <span class="m">37</span> <span class="p">}</span>
+<span class="nv-Anonymous">!2</span> <span class="p">=</span> <span class="p">!{</span> <span class="k">i32</span> <span class="m">2</span><span class="p">,</span> <span class="nv">!"qux"</span><span class="p">,</span> <span class="k">i32</span> <span class="m">42</span> <span class="p">}</span>
+<span class="nv-Anonymous">!3</span> <span class="p">=</span> <span class="p">!{</span> <span class="k">i32</span> <span class="m">3</span><span class="p">,</span> <span class="nv">!"qux"</span><span class="p">,</span>
+  <span class="p">!{</span>
+    <span class="nv">!"foo"</span><span class="p">,</span> <span class="k">i32</span> <span class="m">1</span>
+  <span class="p">}</span>
+<span class="p">}</span>
+<span class="nv">!llvm.module.flags</span> <span class="p">=</span> <span class="p">!{</span> <span class="nv-Anonymous">!0</span><span class="p">,</span> <span class="nv-Anonymous">!1</span><span class="p">,</span> <span class="nv-Anonymous">!2</span><span class="p">,</span> <span class="nv-Anonymous">!3</span> <span class="p">}</span>
+</pre></div>
+</div>
+<ul>
+<li><p class="first">Metadata <tt class="docutils literal"><span class="pre">!0</span></tt> has the ID <tt class="docutils literal"><span class="pre">!"foo"</span></tt> and the value ‘1’. The behavior
+if two or more <tt class="docutils literal"><span class="pre">!"foo"</span></tt> flags are seen is to emit an error if their
+values are not equal.</p>
+</li>
+<li><p class="first">Metadata <tt class="docutils literal"><span class="pre">!1</span></tt> has the ID <tt class="docutils literal"><span class="pre">!"bar"</span></tt> and the value ‘37’. The
+behavior if two or more <tt class="docutils literal"><span class="pre">!"bar"</span></tt> flags are seen is to use the value
+‘37’.</p>
+</li>
+<li><p class="first">Metadata <tt class="docutils literal"><span class="pre">!2</span></tt> has the ID <tt class="docutils literal"><span class="pre">!"qux"</span></tt> and the value ‘42’. The
+behavior if two or more <tt class="docutils literal"><span class="pre">!"qux"</span></tt> flags are seen is to emit a
+warning if their values are not equal.</p>
+</li>
+<li><p class="first">Metadata <tt class="docutils literal"><span class="pre">!3</span></tt> has the ID <tt class="docutils literal"><span class="pre">!"qux"</span></tt> and the value:</p>
+<div class="highlight-python"><pre>!{ !"foo", i32 1 }</pre>
+</div>
+<p>The behavior is to emit an error if the <tt class="docutils literal"><span class="pre">llvm.module.flags</span></tt> does not
+contain a flag with the ID <tt class="docutils literal"><span class="pre">!"foo"</span></tt> that has the value ‘1’ after linking is
+performed.</p>
+</li>
+</ul>
+<div class="section" id="objective-c-garbage-collection-module-flags-metadata">
+<h3><a class="toc-backref" href="#id950">Objective-C Garbage Collection Module Flags Metadata</a><a class="headerlink" href="#objective-c-garbage-collection-module-flags-metadata" title="Permalink to this headline">¶</a></h3>
+<p>On the Mach-O platform, Objective-C stores metadata about garbage
+collection in a special section called “image info”. The metadata
+consists of a version number and a bitmask specifying what types of
+garbage collection are supported (if any) by the file. If two or more
+modules are linked together their garbage collection metadata needs to
+be merged rather than appended together.</p>
+<p>The Objective-C garbage collection module flags metadata consists of the
+following key-value pairs:</p>
+<table border="1" class="docutils">
+<colgroup>
+<col width="30%" />
+<col width="70%" />
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">Key</th>
+<th class="head">Value</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td><tt class="docutils literal"><span class="pre">Objective-C</span> <span class="pre">Version</span></tt></td>
+<td><strong>[Required]</strong> — The Objective-C ABI version. Valid values are 1 and 2.</td>
+</tr>
+<tr class="row-odd"><td><tt class="docutils literal"><span class="pre">Objective-C</span> <span class="pre">Image</span> <span class="pre">Info</span> <span class="pre">Version</span></tt></td>
+<td><strong>[Required]</strong> — The version of the image info section. Currently
+always 0.</td>
+</tr>
+<tr class="row-even"><td><tt class="docutils literal"><span class="pre">Objective-C</span> <span class="pre">Image</span> <span class="pre">Info</span> <span class="pre">Section</span></tt></td>
+<td><strong>[Required]</strong> — The section to place the metadata. Valid values are
+<tt class="docutils literal"><span class="pre">"__OBJC,</span> <span class="pre">__image_info,</span> <span class="pre">regular"</span></tt> for Objective-C ABI version 1, and
+<tt class="docutils literal"><span class="pre">"__DATA,__objc_imageinfo,</span> <span class="pre">regular,</span> <span class="pre">no_dead_strip"</span></tt> for
+Objective-C ABI version 2.</td>
+</tr>
+<tr class="row-odd"><td><tt class="docutils literal"><span class="pre">Objective-C</span> <span class="pre">Garbage</span> <span class="pre">Collection</span></tt></td>
+<td><strong>[Required]</strong> — Specifies whether garbage collection is supported or
+not. Valid values are 0, for no garbage collection, and 2, for garbage
+collection supported.</td>
+</tr>
+<tr class="row-even"><td><tt class="docutils literal"><span class="pre">Objective-C</span> <span class="pre">GC</span> <span class="pre">Only</span></tt></td>
+<td><strong>[Optional]</strong> — Specifies that only garbage collection is supported.
+If present, its value must be 6. This flag requires that the
+<tt class="docutils literal"><span class="pre">Objective-C</span> <span class="pre">Garbage</span> <span class="pre">Collection</span></tt> flag have the value 2.</td>
+</tr>
+</tbody>
+</table>
+<p>Some important flag interactions:</p>
+<ul class="simple">
+<li>If a module with <tt class="docutils literal"><span class="pre">Objective-C</span> <span class="pre">Garbage</span> <span class="pre">Collection</span></tt> set to 0 is
+merged with a module with <tt class="docutils literal"><span class="pre">Objective-C</span> <span class="pre">Garbage</span> <span class="pre">Collection</span></tt> set to
+2, then the resulting module has the
+<tt class="docutils literal"><span class="pre">Objective-C</span> <span class="pre">Garbage</span> <span class="pre">Collection</span></tt> flag set to 0.</li>
+<li>A module with <tt class="docutils literal"><span class="pre">Objective-C</span> <span class="pre">Garbage</span> <span class="pre">Collection</span></tt> set to 0 cannot be
+merged with a module with <tt class="docutils literal"><span class="pre">Objective-C</span> <span class="pre">GC</span> <span class="pre">Only</span></tt> set to 6.</li>
+</ul>
+</div>
+<div class="section" id="c-type-width-module-flags-metadata">
+<h3><a class="toc-backref" href="#id951">C type width Module Flags Metadata</a><a class="headerlink" href="#c-type-width-module-flags-metadata" title="Permalink to this headline">¶</a></h3>
+<p>The ARM backend emits a section into each generated object file describing the
+options that it was compiled with (in a compiler-independent way) to prevent
+linking incompatible objects, and to allow automatic library selection. Some
+of these options are not visible at the IR level, namely wchar_t width and enum
+width.</p>
+<p>To pass this information to the backend, these options are encoded in module
+flags metadata, using the following key-value pairs:</p>
+<table border="1" class="docutils">
+<colgroup>
+<col width="30%" />
+<col width="70%" />
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">Key</th>
+<th class="head">Value</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>short_wchar</td>
+<td><ul class="first last simple">
+<li>0 — sizeof(wchar_t) == 4</li>
+<li>1 — sizeof(wchar_t) == 2</li>
+</ul>
+</td>
+</tr>
+<tr class="row-odd"><td>short_enum</td>
+<td><ul class="first last simple">
+<li>0 — Enums are at least as large as an <tt class="docutils literal"><span class="pre">int</span></tt>.</li>
+<li>1 — Enums are stored in the smallest integer type which can
+represent all of its values.</li>
+</ul>
+</td>
+</tr>
+</tbody>
+</table>
+<p>For example, the following metadata section specifies that the module was
+compiled with a <tt class="docutils literal"><span class="pre">wchar_t</span></tt> width of 4 bytes, and the underlying type of an
+enum is the smallest type which can represent all of its values:</p>
+<div class="highlight-python"><pre>!llvm.module.flags = !{!0, !1}
+!0 = !{i32 1, !"short_wchar", i32 1}
+!1 = !{i32 1, !"short_enum", i32 0}</pre>
+</div>
+</div>
+</div>
+<div class="section" id="automatic-linker-flags-named-metadata">
+<h2><a class="toc-backref" href="#id952">Automatic Linker Flags Named Metadata</a><a class="headerlink" href="#automatic-linker-flags-named-metadata" title="Permalink to this headline">¶</a></h2>
+<p>Some targets support embedding flags to the linker inside individual object
+files. Typically this is used in conjunction with language extensions which
+allow source files to explicitly declare the libraries they depend on, and have
+these automatically be transmitted to the linker via object files.</p>
+<p>These flags are encoded in the IR using named metadata with the name
+<tt class="docutils literal"><span class="pre">!llvm.linker.options</span></tt>. Each operand is expected to be a metadata node
+which should be a list of other metadata nodes, each of which should be a
+list of metadata strings defining linker options.</p>
+<p>For example, the following metadata section specifies two separate sets of
+linker options, presumably to link against <tt class="docutils literal"><span class="pre">libz</span></tt> and the <tt class="docutils literal"><span class="pre">Cocoa</span></tt>
+framework:</p>
+<div class="highlight-python"><pre>!0 = !{ !"-lz" },
+!1 = !{ !"-framework", !"Cocoa" } } }
+!llvm.linker.options = !{ !0, !1 }</pre>
+</div>
+<p>The metadata encoding as lists of lists of options, as opposed to a collapsed
+list of options, is chosen so that the IR encoding can use multiple option
+strings to specify e.g., a single library, while still having that specifier be
+preserved as an atomic element that can be recognized by a target specific
+assembly writer or object file emitter.</p>
+<p>Each individual option is required to be either a valid option for the target’s
+linker, or an option that is reserved by the target specific assembly writer or
+object file emitter. No other aspect of these options is defined by the IR.</p>
+</div>
+<div class="section" id="intrinsic-global-variables">
+<span id="intrinsicglobalvariables"></span><h2><a class="toc-backref" href="#id953">Intrinsic Global Variables</a><a class="headerlink" href="#intrinsic-global-variables" title="Permalink to this headline">¶</a></h2>
+<p>LLVM has a number of “magic” global variables that contain data that
+affect code generation or other IR semantics. These are documented here.
+All globals of this sort should have a section specified as
+“<tt class="docutils literal"><span class="pre">llvm.metadata</span></tt>”. This section and all globals that start with
+“<tt class="docutils literal"><span class="pre">llvm.</span></tt>” are reserved for use by LLVM.</p>
+<div class="section" id="the-llvm-used-global-variable">
+<span id="gv-llvmused"></span><h3><a class="toc-backref" href="#id954">The ‘<tt class="docutils literal"><span class="pre">llvm.used</span></tt>‘ Global Variable</a><a class="headerlink" href="#the-llvm-used-global-variable" title="Permalink to this headline">¶</a></h3>
+<p>The <tt class="docutils literal"><span class="pre">@llvm.used</span></tt> global is an array which has
+<a class="reference internal" href="#linkage-appending"><em>appending linkage</em></a>. This array contains a list of
+pointers to named global variables, functions and aliases which may optionally
+have a pointer cast formed of bitcast or getelementptr. For example, a legal
+use of it is:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="vg">@X</span> <span class="p">=</span> <span class="k">global</span> <span class="k">i8</span> <span class="m">4</span>
+<span class="vg">@Y</span> <span class="p">=</span> <span class="k">global</span> <span class="k">i32</span> <span class="m">123</span>
+
+<span class="vg">@llvm.used</span> <span class="p">=</span> <span class="k">appending</span> <span class="k">global</span> <span class="p">[</span><span class="m">2</span> <span class="k">x</span> <span class="k">i8</span><span class="p">*]</span> <span class="p">[</span>
+   <span class="k">i8</span><span class="p">*</span> <span class="vg">@X</span><span class="p">,</span>
+   <span class="k">i8</span><span class="p">*</span> <span class="k">bitcast</span> <span class="p">(</span><span class="k">i32</span><span class="p">*</span> <span class="vg">@Y</span> <span class="k">to</span> <span class="k">i8</span><span class="p">*)</span>
+<span class="p">],</span> <span class="k">section</span> <span class="s">"llvm.metadata"</span>
+</pre></div>
+</div>
+<p>If a symbol appears in the <tt class="docutils literal"><span class="pre">@llvm.used</span></tt> list, then the compiler, assembler,
+and linker are required to treat the symbol as if there is a reference to the
+symbol that it cannot see (which is why they have to be named). For example, if
+a variable has internal linkage and no references other than that from the
+<tt class="docutils literal"><span class="pre">@llvm.used</span></tt> list, it cannot be deleted. This is commonly used to represent
+references from inline asms and other things the compiler cannot “see”, and
+corresponds to “<tt class="docutils literal"><span class="pre">attribute((used))</span></tt>” in GNU C.</p>
+<p>On some targets, the code generator must emit a directive to the
+assembler or object file to prevent the assembler and linker from
+molesting the symbol.</p>
+</div>
+<div class="section" id="the-llvm-compiler-used-global-variable">
+<span id="gv-llvmcompilerused"></span><h3><a class="toc-backref" href="#id955">The ‘<tt class="docutils literal"><span class="pre">llvm.compiler.used</span></tt>‘ Global Variable</a><a class="headerlink" href="#the-llvm-compiler-used-global-variable" title="Permalink to this headline">¶</a></h3>
+<p>The <tt class="docutils literal"><span class="pre">@llvm.compiler.used</span></tt> directive is the same as the <tt class="docutils literal"><span class="pre">@llvm.used</span></tt>
+directive, except that it only prevents the compiler from touching the
+symbol. On targets that support it, this allows an intelligent linker to
+optimize references to the symbol without being impeded as it would be
+by <tt class="docutils literal"><span class="pre">@llvm.used</span></tt>.</p>
+<p>This is a rare construct that should only be used in rare circumstances,
+and should not be exposed to source languages.</p>
+</div>
+<div class="section" id="the-llvm-global-ctors-global-variable">
+<span id="gv-llvmglobalctors"></span><h3><a class="toc-backref" href="#id956">The ‘<tt class="docutils literal"><span class="pre">llvm.global_ctors</span></tt>‘ Global Variable</a><a class="headerlink" href="#the-llvm-global-ctors-global-variable" title="Permalink to this headline">¶</a></h3>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv-Anonymous">%0</span> <span class="p">=</span> <span class="k">type</span> <span class="p">{</span> <span class="k">i32</span><span class="p">,</span> <span class="kt">void</span> <span class="p">()*,</span> <span class="k">i8</span><span class="p">*</span> <span class="p">}</span>
+<span class="vg">@llvm.global_ctors</span> <span class="p">=</span> <span class="k">appending</span> <span class="k">global</span> <span class="p">[</span><span class="m">1</span> <span class="k">x</span> <span class="nv-Anonymous">%0</span><span class="p">]</span> <span class="p">[</span><span class="nv-Anonymous">%0</span> <span class="p">{</span> <span class="k">i32</span> <span class="m">65535</span><span class="p">,</span> <span class="kt">void</span> <span class="p">()*</span> <span class="vg">@ctor</span><span class="p">,</span> <span class="k">i8</span><span class="p">*</span> <span class="vg">@data</span> <span class="p">}]</span>
+</pre></div>
+</div>
+<p>The <tt class="docutils literal"><span class="pre">@llvm.global_ctors</span></tt> array contains a list of constructor
+functions, priorities, and an optional associated global or function.
+The functions referenced by this array will be called in ascending order
+of priority (i.e. lowest first) when the module is loaded. The order of
+functions with the same priority is not defined.</p>
+<p>If the third field is present, non-null, and points to a global variable
+or function, the initializer function will only run if the associated
+data from the current module is not discarded.</p>
+</div>
+<div class="section" id="the-llvm-global-dtors-global-variable">
+<span id="llvmglobaldtors"></span><h3><a class="toc-backref" href="#id957">The ‘<tt class="docutils literal"><span class="pre">llvm.global_dtors</span></tt>‘ Global Variable</a><a class="headerlink" href="#the-llvm-global-dtors-global-variable" title="Permalink to this headline">¶</a></h3>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv-Anonymous">%0</span> <span class="p">=</span> <span class="k">type</span> <span class="p">{</span> <span class="k">i32</span><span class="p">,</span> <span class="kt">void</span> <span class="p">()*,</span> <span class="k">i8</span><span class="p">*</span> <span class="p">}</span>
+<span class="vg">@llvm.global_dtors</span> <span class="p">=</span> <span class="k">appending</span> <span class="k">global</span> <span class="p">[</span><span class="m">1</span> <span class="k">x</span> <span class="nv-Anonymous">%0</span><span class="p">]</span> <span class="p">[</span><span class="nv-Anonymous">%0</span> <span class="p">{</span> <span class="k">i32</span> <span class="m">65535</span><span class="p">,</span> <span class="kt">void</span> <span class="p">()*</span> <span class="vg">@dtor</span><span class="p">,</span> <span class="k">i8</span><span class="p">*</span> <span class="vg">@data</span> <span class="p">}]</span>
+</pre></div>
+</div>
+<p>The <tt class="docutils literal"><span class="pre">@llvm.global_dtors</span></tt> array contains a list of destructor
+functions, priorities, and an optional associated global or function.
+The functions referenced by this array will be called in descending
+order of priority (i.e. highest first) when the module is unloaded. The
+order of functions with the same priority is not defined.</p>
+<p>If the third field is present, non-null, and points to a global variable
+or function, the destructor function will only run if the associated
+data from the current module is not discarded.</p>
+</div>
+</div>
+<div class="section" id="instruction-reference">
+<h2><a class="toc-backref" href="#id958">Instruction Reference</a><a class="headerlink" href="#instruction-reference" title="Permalink to this headline">¶</a></h2>
+<p>The LLVM instruction set consists of several different classifications
+of instructions: <a class="reference internal" href="#terminators"><em>terminator instructions</em></a>, <a class="reference internal" href="#binaryops"><em>binary
+instructions</em></a>, <a class="reference internal" href="#bitwiseops"><em>bitwise binary
+instructions</em></a>, <a class="reference internal" href="#memoryops"><em>memory instructions</em></a>, and
+<a class="reference internal" href="#otherops"><em>other instructions</em></a>.</p>
+<div class="section" id="terminator-instructions">
+<span id="terminators"></span><h3><a class="toc-backref" href="#id959">Terminator Instructions</a><a class="headerlink" href="#terminator-instructions" title="Permalink to this headline">¶</a></h3>
+<p>As mentioned <a class="reference internal" href="#functionstructure"><em>previously</em></a>, every basic block in a
+program ends with a “Terminator” instruction, which indicates which
+block should be executed after the current block is finished. These
+terminator instructions typically yield a ‘<tt class="docutils literal"><span class="pre">void</span></tt>‘ value: they produce
+control flow, not values (the one exception being the
+‘<a class="reference internal" href="#i-invoke"><em>invoke</em></a>‘ instruction).</p>
+<p>The terminator instructions are: ‘<a class="reference internal" href="#i-ret"><em>ret</em></a>‘,
+‘<a class="reference internal" href="#i-br"><em>br</em></a>‘, ‘<a class="reference internal" href="#i-switch"><em>switch</em></a>‘,
+‘<a class="reference internal" href="#i-indirectbr"><em>indirectbr</em></a>‘, ‘<a class="reference internal" href="#i-invoke"><em>invoke</em></a>‘,
+‘<a class="reference internal" href="#i-resume"><em>resume</em></a>‘, ‘<a class="reference internal" href="#i-catchswitch"><em>catchswitch</em></a>‘,
+‘<a class="reference internal" href="#i-catchret"><em>catchret</em></a>‘,
+‘<a class="reference internal" href="#i-cleanupret"><em>cleanupret</em></a>‘,
+and ‘<a class="reference internal" href="#i-unreachable"><em>unreachable</em></a>‘.</p>
+<div class="section" id="ret-instruction">
+<span id="i-ret"></span><h4><a class="toc-backref" href="#id960">‘<tt class="docutils literal"><span class="pre">ret</span></tt>‘ Instruction</a><a class="headerlink" href="#ret-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="syntax">
+<h5><a class="toc-backref" href="#id961">Syntax:</a><a class="headerlink" href="#syntax" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>ret <type> <value>       ; Return a value from a non-void function
+ret void                 ; Return from void function</pre>
+</div>
+</div>
+<div class="section" id="overview">
+<h5><a class="toc-backref" href="#id962">Overview:</a><a class="headerlink" href="#overview" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">ret</span></tt>‘ instruction is used to return control flow (and optionally
+a value) from a function back to the caller.</p>
+<p>There are two forms of the ‘<tt class="docutils literal"><span class="pre">ret</span></tt>‘ instruction: one that returns a
+value and then causes control flow, and one that just causes control
+flow to occur.</p>
+</div>
+<div class="section" id="arguments">
+<h5><a class="toc-backref" href="#id963">Arguments:</a><a class="headerlink" href="#arguments" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">ret</span></tt>‘ instruction optionally accepts a single argument, the
+return value. The type of the return value must be a ‘<a class="reference internal" href="#t-firstclass"><em>first
+class</em></a>‘ type.</p>
+<p>A function is not <a class="reference internal" href="#wellformed"><em>well formed</em></a> if it it has a non-void
+return type and contains a ‘<tt class="docutils literal"><span class="pre">ret</span></tt>‘ instruction with no return value or
+a return value with a type that does not match its type, or if it has a
+void return type and contains a ‘<tt class="docutils literal"><span class="pre">ret</span></tt>‘ instruction with a return
+value.</p>
+</div>
+<div class="section" id="id20">
+<h5><a class="toc-backref" href="#id964">Semantics:</a><a class="headerlink" href="#id20" title="Permalink to this headline">¶</a></h5>
+<p>When the ‘<tt class="docutils literal"><span class="pre">ret</span></tt>‘ instruction is executed, control flow returns back to
+the calling function’s context. If the caller is a
+“<a class="reference internal" href="#i-call"><em>call</em></a>” instruction, execution continues at the
+instruction after the call. If the caller was an
+“<a class="reference internal" href="#i-invoke"><em>invoke</em></a>” instruction, execution continues at the
+beginning of the “normal” destination block. If the instruction returns
+a value, that value shall set the call or invoke instruction’s return
+value.</p>
+</div>
+<div class="section" id="example">
+<h5><a class="toc-backref" href="#id965">Example:</a><a class="headerlink" href="#example" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="k">ret</span> <span class="k">i32</span> <span class="m">5</span>                       <span class="c">; Return an integer value of 5</span>
+<span class="k">ret</span> <span class="kt">void</span>                        <span class="c">; Return from a void function</span>
+<span class="k">ret</span> <span class="p">{</span> <span class="k">i32</span><span class="p">,</span> <span class="k">i8</span> <span class="p">}</span> <span class="p">{</span> <span class="k">i32</span> <span class="m">4</span><span class="p">,</span> <span class="k">i8</span> <span class="m">2</span> <span class="p">}</span> <span class="c">; Return a struct of values 4 and 2</span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="br-instruction">
+<span id="i-br"></span><h4><a class="toc-backref" href="#id966">‘<tt class="docutils literal"><span class="pre">br</span></tt>‘ Instruction</a><a class="headerlink" href="#br-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id21">
+<h5><a class="toc-backref" href="#id967">Syntax:</a><a class="headerlink" href="#id21" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>br i1 <cond>, label <iftrue>, label <iffalse>
+br label <dest>          ; Unconditional branch</pre>
+</div>
+</div>
+<div class="section" id="id22">
+<h5><a class="toc-backref" href="#id968">Overview:</a><a class="headerlink" href="#id22" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">br</span></tt>‘ instruction is used to cause control flow to transfer to a
+different basic block in the current function. There are two forms of
+this instruction, corresponding to a conditional branch and an
+unconditional branch.</p>
+</div>
+<div class="section" id="id23">
+<h5><a class="toc-backref" href="#id969">Arguments:</a><a class="headerlink" href="#id23" title="Permalink to this headline">¶</a></h5>
+<p>The conditional branch form of the ‘<tt class="docutils literal"><span class="pre">br</span></tt>‘ instruction takes a single
+‘<tt class="docutils literal"><span class="pre">i1</span></tt>‘ value and two ‘<tt class="docutils literal"><span class="pre">label</span></tt>‘ values. The unconditional form of the
+‘<tt class="docutils literal"><span class="pre">br</span></tt>‘ instruction takes a single ‘<tt class="docutils literal"><span class="pre">label</span></tt>‘ value as a target.</p>
+</div>
+<div class="section" id="id24">
+<h5><a class="toc-backref" href="#id970">Semantics:</a><a class="headerlink" href="#id24" title="Permalink to this headline">¶</a></h5>
+<p>Upon execution of a conditional ‘<tt class="docutils literal"><span class="pre">br</span></tt>‘ instruction, the ‘<tt class="docutils literal"><span class="pre">i1</span></tt>‘
+argument is evaluated. If the value is <tt class="docutils literal"><span class="pre">true</span></tt>, control flows to the
+‘<tt class="docutils literal"><span class="pre">iftrue</span></tt>‘ <tt class="docutils literal"><span class="pre">label</span></tt> argument. If “cond” is <tt class="docutils literal"><span class="pre">false</span></tt>, control flows
+to the ‘<tt class="docutils literal"><span class="pre">iffalse</span></tt>‘ <tt class="docutils literal"><span class="pre">label</span></tt> argument.</p>
+</div>
+<div class="section" id="id25">
+<h5><a class="toc-backref" href="#id971">Example:</a><a class="headerlink" href="#id25" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nl">Test:</span>
+  <span class="nv">%cond</span> <span class="p">=</span> <span class="k">icmp</span> <span class="k">eq</span> <span class="k">i32</span> <span class="nv">%a</span><span class="p">,</span> <span class="nv">%b</span>
+  <span class="k">br</span> <span class="k">i1</span> <span class="nv">%cond</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%IfEqual</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%IfUnequal</span>
+<span class="nl">IfEqual:</span>
+  <span class="k">ret</span> <span class="k">i32</span> <span class="m">1</span>
+<span class="nl">IfUnequal:</span>
+  <span class="k">ret</span> <span class="k">i32</span> <span class="m">0</span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="switch-instruction">
+<span id="i-switch"></span><h4><a class="toc-backref" href="#id972">‘<tt class="docutils literal"><span class="pre">switch</span></tt>‘ Instruction</a><a class="headerlink" href="#switch-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id26">
+<h5><a class="toc-backref" href="#id973">Syntax:</a><a class="headerlink" href="#id26" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>switch <intty> <value>, label <defaultdest> [ <intty> <val>, label <dest> ... ]</pre>
+</div>
+</div>
+<div class="section" id="id27">
+<h5><a class="toc-backref" href="#id974">Overview:</a><a class="headerlink" href="#id27" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">switch</span></tt>‘ instruction is used to transfer control flow to one of
+several different places. It is a generalization of the ‘<tt class="docutils literal"><span class="pre">br</span></tt>‘
+instruction, allowing a branch to occur to one of many possible
+destinations.</p>
+</div>
+<div class="section" id="id28">
+<h5><a class="toc-backref" href="#id975">Arguments:</a><a class="headerlink" href="#id28" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">switch</span></tt>‘ instruction uses three parameters: an integer
+comparison value ‘<tt class="docutils literal"><span class="pre">value</span></tt>‘, a default ‘<tt class="docutils literal"><span class="pre">label</span></tt>‘ destination, and an
+array of pairs of comparison value constants and ‘<tt class="docutils literal"><span class="pre">label</span></tt>‘s. The table
+is not allowed to contain duplicate constant entries.</p>
+</div>
+<div class="section" id="id29">
+<h5><a class="toc-backref" href="#id976">Semantics:</a><a class="headerlink" href="#id29" title="Permalink to this headline">¶</a></h5>
+<p>The <tt class="docutils literal"><span class="pre">switch</span></tt> instruction specifies a table of values and destinations.
+When the ‘<tt class="docutils literal"><span class="pre">switch</span></tt>‘ instruction is executed, this table is searched
+for the given value. If the value is found, control flow is transferred
+to the corresponding destination; otherwise, control flow is transferred
+to the default destination.</p>
+</div>
+<div class="section" id="implementation">
+<h5><a class="toc-backref" href="#id977">Implementation:</a><a class="headerlink" href="#implementation" title="Permalink to this headline">¶</a></h5>
+<p>Depending on properties of the target machine and the particular
+<tt class="docutils literal"><span class="pre">switch</span></tt> instruction, this instruction may be code generated in
+different ways. For example, it could be generated as a series of
+chained conditional branches or with a lookup table.</p>
+</div>
+<div class="section" id="id30">
+<h5><a class="toc-backref" href="#id978">Example:</a><a class="headerlink" href="#id30" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="c">; Emulate a conditional br instruction</span>
+<span class="nv">%Val</span> <span class="p">=</span> <span class="k">zext</span> <span class="k">i1</span> <span class="nv">%value</span> <span class="k">to</span> <span class="k">i32</span>
+<span class="k">switch</span> <span class="k">i32</span> <span class="nv">%Val</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%truedest</span> <span class="p">[</span> <span class="k">i32</span> <span class="m">0</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%falsedest</span> <span class="p">]</span>
+
+<span class="c">; Emulate an unconditional br instruction</span>
+<span class="k">switch</span> <span class="k">i32</span> <span class="m">0</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%dest</span> <span class="p">[</span> <span class="p">]</span>
+
+<span class="c">; Implement a jump table:</span>
+<span class="k">switch</span> <span class="k">i32</span> <span class="nv">%val</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%otherwise</span> <span class="p">[</span> <span class="k">i32</span> <span class="m">0</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%onzero</span>
+                                    <span class="k">i32</span> <span class="m">1</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%onone</span>
+                                    <span class="k">i32</span> <span class="m">2</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%ontwo</span> <span class="p">]</span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="indirectbr-instruction">
+<span id="i-indirectbr"></span><h4><a class="toc-backref" href="#id979">‘<tt class="docutils literal"><span class="pre">indirectbr</span></tt>‘ Instruction</a><a class="headerlink" href="#indirectbr-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id31">
+<h5><a class="toc-backref" href="#id980">Syntax:</a><a class="headerlink" href="#id31" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>indirectbr <somety>* <address>, [ label <dest1>, label <dest2>, ... ]</pre>
+</div>
+</div>
+<div class="section" id="id32">
+<h5><a class="toc-backref" href="#id981">Overview:</a><a class="headerlink" href="#id32" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">indirectbr</span></tt>‘ instruction implements an indirect branch to a
+label within the current function, whose address is specified by
+“<tt class="docutils literal"><span class="pre">address</span></tt>”. Address must be derived from a
+<a class="reference internal" href="#blockaddress"><em>blockaddress</em></a> constant.</p>
+</div>
+<div class="section" id="id33">
+<h5><a class="toc-backref" href="#id982">Arguments:</a><a class="headerlink" href="#id33" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">address</span></tt>‘ argument is the address of the label to jump to. The
+rest of the arguments indicate the full set of possible destinations
+that the address may point to. Blocks are allowed to occur multiple
+times in the destination list, though this isn’t particularly useful.</p>
+<p>This destination list is required so that dataflow analysis has an
+accurate understanding of the CFG.</p>
+</div>
+<div class="section" id="id34">
+<h5><a class="toc-backref" href="#id983">Semantics:</a><a class="headerlink" href="#id34" title="Permalink to this headline">¶</a></h5>
+<p>Control transfers to the block specified in the address argument. All
+possible destination blocks must be listed in the label list, otherwise
+this instruction has undefined behavior. This implies that jumps to
+labels defined in other functions have undefined behavior as well.</p>
+</div>
+<div class="section" id="id35">
+<h5><a class="toc-backref" href="#id984">Implementation:</a><a class="headerlink" href="#id35" title="Permalink to this headline">¶</a></h5>
+<p>This is typically implemented with a jump through a register.</p>
+</div>
+<div class="section" id="id36">
+<h5><a class="toc-backref" href="#id985">Example:</a><a class="headerlink" href="#id36" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><pre>indirectbr i8* %Addr, [ label %bb1, label %bb2, label %bb3 ]</pre>
+</div>
+</div>
+</div>
+<div class="section" id="invoke-instruction">
+<span id="i-invoke"></span><h4><a class="toc-backref" href="#id986">‘<tt class="docutils literal"><span class="pre">invoke</span></tt>‘ Instruction</a><a class="headerlink" href="#invoke-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id37">
+<h5><a class="toc-backref" href="#id987">Syntax:</a><a class="headerlink" href="#id37" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = invoke [cconv] [ret attrs] <ty>|<fnty> <fnptrval>(<function args>) [fn attrs]
+              [operand bundles] to label <normal label> unwind label <exception label></pre>
+</div>
+</div>
+<div class="section" id="id38">
+<h5><a class="toc-backref" href="#id988">Overview:</a><a class="headerlink" href="#id38" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">invoke</span></tt>‘ instruction causes control to transfer to a specified
+function, with the possibility of control flow transfer to either the
+‘<tt class="docutils literal"><span class="pre">normal</span></tt>‘ label or the ‘<tt class="docutils literal"><span class="pre">exception</span></tt>‘ label. If the callee function
+returns with the “<tt class="docutils literal"><span class="pre">ret</span></tt>” instruction, control flow will return to the
+“normal” label. If the callee (or any indirect callees) returns via the
+“<a class="reference internal" href="#i-resume"><em>resume</em></a>” instruction or other exception handling
+mechanism, control is interrupted and continued at the dynamically
+nearest “exception” label.</p>
+<p>The ‘<tt class="docutils literal"><span class="pre">exception</span></tt>‘ label is a <a class="reference external" href="ExceptionHandling.html#overview">landing
+pad</a> for the exception. As such,
+‘<tt class="docutils literal"><span class="pre">exception</span></tt>‘ label is required to have the
+“<a class="reference internal" href="#i-landingpad"><em>landingpad</em></a>” instruction, which contains the
+information about the behavior of the program after unwinding happens,
+as its first non-PHI instruction. The restrictions on the
+“<tt class="docutils literal"><span class="pre">landingpad</span></tt>” instruction’s tightly couples it to the “<tt class="docutils literal"><span class="pre">invoke</span></tt>”
+instruction, so that the important information contained within the
+“<tt class="docutils literal"><span class="pre">landingpad</span></tt>” instruction can’t be lost through normal code motion.</p>
+</div>
+<div class="section" id="id39">
+<h5><a class="toc-backref" href="#id989">Arguments:</a><a class="headerlink" href="#id39" title="Permalink to this headline">¶</a></h5>
+<p>This instruction requires several arguments:</p>
+<ol class="arabic simple">
+<li>The optional “cconv” marker indicates which <a class="reference internal" href="#callingconv"><em>calling
+convention</em></a> the call should use. If none is
+specified, the call defaults to using C calling conventions.</li>
+<li>The optional <a class="reference internal" href="#paramattrs"><em>Parameter Attributes</em></a> list for return
+values. Only ‘<tt class="docutils literal"><span class="pre">zeroext</span></tt>‘, ‘<tt class="docutils literal"><span class="pre">signext</span></tt>‘, and ‘<tt class="docutils literal"><span class="pre">inreg</span></tt>‘ attributes
+are valid here.</li>
+<li>‘<tt class="docutils literal"><span class="pre">ty</span></tt>‘: the type of the call instruction itself which is also the
+type of the return value. Functions that return no value are marked
+<tt class="docutils literal"><span class="pre">void</span></tt>.</li>
+<li>‘<tt class="docutils literal"><span class="pre">fnty</span></tt>‘: shall be the signature of the function being invoked. The
+argument types must match the types implied by this signature. This
+type can be omitted if the function is not varargs.</li>
+<li>‘<tt class="docutils literal"><span class="pre">fnptrval</span></tt>‘: An LLVM value containing a pointer to a function to
+be invoked. In most cases, this is a direct function invocation, but
+indirect <tt class="docutils literal"><span class="pre">invoke</span></tt>‘s are just as possible, calling an arbitrary pointer
+to function value.</li>
+<li>‘<tt class="docutils literal"><span class="pre">function</span> <span class="pre">args</span></tt>‘: argument list whose types match the function
+signature argument types and parameter attributes. All arguments must
+be of <a class="reference internal" href="#t-firstclass"><em>first class</em></a> type. If the function signature
+indicates the function accepts a variable number of arguments, the
+extra arguments can be specified.</li>
+<li>‘<tt class="docutils literal"><span class="pre">normal</span> <span class="pre">label</span></tt>‘: the label reached when the called function
+executes a ‘<tt class="docutils literal"><span class="pre">ret</span></tt>‘ instruction.</li>
+<li>‘<tt class="docutils literal"><span class="pre">exception</span> <span class="pre">label</span></tt>‘: the label reached when a callee returns via
+the <a class="reference internal" href="#i-resume"><em>resume</em></a> instruction or other exception handling
+mechanism.</li>
+<li>The optional <a class="reference internal" href="#fnattrs"><em>function attributes</em></a> list.</li>
+<li>The optional <a class="reference internal" href="#opbundles"><em>operand bundles</em></a> list.</li>
+</ol>
+</div>
+<div class="section" id="id40">
+<h5><a class="toc-backref" href="#id990">Semantics:</a><a class="headerlink" href="#id40" title="Permalink to this headline">¶</a></h5>
+<p>This instruction is designed to operate as a standard ‘<tt class="docutils literal"><span class="pre">call</span></tt>‘
+instruction in most regards. The primary difference is that it
+establishes an association with a label, which is used by the runtime
+library to unwind the stack.</p>
+<p>This instruction is used in languages with destructors to ensure that
+proper cleanup is performed in the case of either a <tt class="docutils literal"><span class="pre">longjmp</span></tt> or a
+thrown exception. Additionally, this is important for implementation of
+‘<tt class="docutils literal"><span class="pre">catch</span></tt>‘ clauses in high-level languages that support them.</p>
+<p>For the purposes of the SSA form, the definition of the value returned
+by the ‘<tt class="docutils literal"><span class="pre">invoke</span></tt>‘ instruction is deemed to occur on the edge from the
+current block to the “normal” label. If the callee unwinds then no
+return value is available.</p>
+</div>
+<div class="section" id="id41">
+<h5><a class="toc-backref" href="#id991">Example:</a><a class="headerlink" href="#id41" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%retval</span> <span class="p">=</span> <span class="k">invoke</span> <span class="k">i32</span> <span class="vg">@Test</span><span class="p">(</span><span class="k">i32</span> <span class="m">15</span><span class="p">)</span> <span class="k">to</span> <span class="kt">label</span> <span class="nv">%Continue</span>
+            <span class="k">unwind</span> <span class="kt">label</span> <span class="nv">%TestCleanup</span>              <span class="c">; i32:retval set</span>
+<span class="nv">%retval</span> <span class="p">=</span> <span class="k">invoke</span> <span class="k">coldcc</span> <span class="k">i32</span> <span class="nv">%Testfnptr</span><span class="p">(</span><span class="k">i32</span> <span class="m">15</span><span class="p">)</span> <span class="k">to</span> <span class="kt">label</span> <span class="nv">%Continue</span>
+            <span class="k">unwind</span> <span class="kt">label</span> <span class="nv">%TestCleanup</span>              <span class="c">; i32:retval set</span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="resume-instruction">
+<span id="i-resume"></span><h4><a class="toc-backref" href="#id992">‘<tt class="docutils literal"><span class="pre">resume</span></tt>‘ Instruction</a><a class="headerlink" href="#resume-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id42">
+<h5><a class="toc-backref" href="#id993">Syntax:</a><a class="headerlink" href="#id42" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>resume <type> <value></pre>
+</div>
+</div>
+<div class="section" id="id43">
+<h5><a class="toc-backref" href="#id994">Overview:</a><a class="headerlink" href="#id43" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">resume</span></tt>‘ instruction is a terminator instruction that has no
+successors.</p>
+</div>
+<div class="section" id="id44">
+<h5><a class="toc-backref" href="#id995">Arguments:</a><a class="headerlink" href="#id44" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">resume</span></tt>‘ instruction requires one argument, which must have the
+same type as the result of any ‘<tt class="docutils literal"><span class="pre">landingpad</span></tt>‘ instruction in the same
+function.</p>
+</div>
+<div class="section" id="id45">
+<h5><a class="toc-backref" href="#id996">Semantics:</a><a class="headerlink" href="#id45" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">resume</span></tt>‘ instruction resumes propagation of an existing
+(in-flight) exception whose unwinding was interrupted with a
+<a class="reference internal" href="#i-landingpad"><em>landingpad</em></a> instruction.</p>
+</div>
+<div class="section" id="id46">
+<h5><a class="toc-backref" href="#id997">Example:</a><a class="headerlink" href="#id46" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><pre>resume { i8*, i32 } %exn</pre>
+</div>
+</div>
+</div>
+<div class="section" id="catchswitch-instruction">
+<span id="i-catchswitch"></span><h4><a class="toc-backref" href="#id998">‘<tt class="docutils literal"><span class="pre">catchswitch</span></tt>‘ Instruction</a><a class="headerlink" href="#catchswitch-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id47">
+<h5><a class="toc-backref" href="#id999">Syntax:</a><a class="headerlink" href="#id47" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><resultval> = catchswitch within <parent> [ label <handler1>, label <handler2>, ... ] unwind to caller
+<resultval> = catchswitch within <parent> [ label <handler1>, label <handler2>, ... ] unwind label <default></pre>
+</div>
+</div>
+<div class="section" id="id48">
+<h5><a class="toc-backref" href="#id1000">Overview:</a><a class="headerlink" href="#id48" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">catchswitch</span></tt>‘ instruction is used by <a class="reference external" href="ExceptionHandling.html#overview">LLVM’s exception handling system</a> to describe the set of possible catch handlers
+that may be executed by the <a class="reference internal" href="#personalityfn"><em>EH personality routine</em></a>.</p>
+</div>
+<div class="section" id="id49">
+<h5><a class="toc-backref" href="#id1001">Arguments:</a><a class="headerlink" href="#id49" title="Permalink to this headline">¶</a></h5>
+<p>The <tt class="docutils literal"><span class="pre">parent</span></tt> argument is the token of the funclet that contains the
+<tt class="docutils literal"><span class="pre">catchswitch</span></tt> instruction. If the <tt class="docutils literal"><span class="pre">catchswitch</span></tt> is not inside a funclet,
+this operand may be the token <tt class="docutils literal"><span class="pre">none</span></tt>.</p>
+<p>The <tt class="docutils literal"><span class="pre">default</span></tt> argument is the label of another basic block beginning with
+either a <tt class="docutils literal"><span class="pre">cleanuppad</span></tt> or <tt class="docutils literal"><span class="pre">catchswitch</span></tt> instruction.  This unwind destination
+must be a legal target with respect to the <tt class="docutils literal"><span class="pre">parent</span></tt> links, as described in
+the <a class="reference external" href="ExceptionHandling.html#wineh-constraints">exception handling documentation</a>.</p>
+<p>The <tt class="docutils literal"><span class="pre">handlers</span></tt> are a nonempty list of successor blocks that each begin with a
+<a class="reference internal" href="#i-catchpad"><em>catchpad</em></a> instruction.</p>
+</div>
+<div class="section" id="id50">
+<h5><a class="toc-backref" href="#id1002">Semantics:</a><a class="headerlink" href="#id50" title="Permalink to this headline">¶</a></h5>
+<p>Executing this instruction transfers control to one of the successors in
+<tt class="docutils literal"><span class="pre">handlers</span></tt>, if appropriate, or continues to unwind via the unwind label if
+present.</p>
+<p>The <tt class="docutils literal"><span class="pre">catchswitch</span></tt> is both a terminator and a “pad” instruction, meaning that
+it must be both the first non-phi instruction and last instruction in the basic
+block. Therefore, it must be the only non-phi instruction in the block.</p>
+</div>
+<div class="section" id="id51">
+<h5><a class="toc-backref" href="#id1003">Example:</a><a class="headerlink" href="#id51" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre>dispatch1:
+  %cs1 = catchswitch within none [label %handler0, label %handler1] unwind to caller
+dispatch2:
+  %cs2 = catchswitch within %parenthandler [label %handler0] unwind label %cleanup
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="catchret-instruction">
+<span id="i-catchret"></span><h4><a class="toc-backref" href="#id1004">‘<tt class="docutils literal"><span class="pre">catchret</span></tt>‘ Instruction</a><a class="headerlink" href="#catchret-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id52">
+<h5><a class="toc-backref" href="#id1005">Syntax:</a><a class="headerlink" href="#id52" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>catchret from <token> to label <normal></pre>
+</div>
+</div>
+<div class="section" id="id53">
+<h5><a class="toc-backref" href="#id1006">Overview:</a><a class="headerlink" href="#id53" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">catchret</span></tt>‘ instruction is a terminator instruction that has a
+single successor.</p>
+</div>
+<div class="section" id="id54">
+<h5><a class="toc-backref" href="#id1007">Arguments:</a><a class="headerlink" href="#id54" title="Permalink to this headline">¶</a></h5>
+<p>The first argument to a ‘<tt class="docutils literal"><span class="pre">catchret</span></tt>‘ indicates which <tt class="docutils literal"><span class="pre">catchpad</span></tt> it
+exits.  It must be a <a class="reference internal" href="#i-catchpad"><em>catchpad</em></a>.
+The second argument to a ‘<tt class="docutils literal"><span class="pre">catchret</span></tt>‘ specifies where control will
+transfer to next.</p>
+</div>
+<div class="section" id="id55">
+<h5><a class="toc-backref" href="#id1008">Semantics:</a><a class="headerlink" href="#id55" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">catchret</span></tt>‘ instruction ends an existing (in-flight) exception whose
+unwinding was interrupted with a <a class="reference internal" href="#i-catchpad"><em>catchpad</em></a> instruction.  The
+<a class="reference internal" href="#personalityfn"><em>personality function</em></a> gets a chance to execute arbitrary
+code to, for example, destroy the active exception.  Control then transfers to
+<tt class="docutils literal"><span class="pre">normal</span></tt>.</p>
+<p>The <tt class="docutils literal"><span class="pre">token</span></tt> argument must be a token produced by a <tt class="docutils literal"><span class="pre">catchpad</span></tt> instruction.
+If the specified <tt class="docutils literal"><span class="pre">catchpad</span></tt> is not the most-recently-entered not-yet-exited
+funclet pad (as described in the <a class="reference external" href="ExceptionHandling.html#wineh-constraints">EH documentation</a>),
+the <tt class="docutils literal"><span class="pre">catchret</span></tt>‘s behavior is undefined.</p>
+</div>
+<div class="section" id="id56">
+<h5><a class="toc-backref" href="#id1009">Example:</a><a class="headerlink" href="#id56" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre>catchret from %catch label %continue
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="cleanupret-instruction">
+<span id="i-cleanupret"></span><h4><a class="toc-backref" href="#id1010">‘<tt class="docutils literal"><span class="pre">cleanupret</span></tt>‘ Instruction</a><a class="headerlink" href="#cleanupret-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id57">
+<h5><a class="toc-backref" href="#id1011">Syntax:</a><a class="headerlink" href="#id57" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>cleanupret from <value> unwind label <continue>
+cleanupret from <value> unwind to caller</pre>
+</div>
+</div>
+<div class="section" id="id58">
+<h5><a class="toc-backref" href="#id1012">Overview:</a><a class="headerlink" href="#id58" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">cleanupret</span></tt>‘ instruction is a terminator instruction that has
+an optional successor.</p>
+</div>
+<div class="section" id="id59">
+<h5><a class="toc-backref" href="#id1013">Arguments:</a><a class="headerlink" href="#id59" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">cleanupret</span></tt>‘ instruction requires one argument, which indicates
+which <tt class="docutils literal"><span class="pre">cleanuppad</span></tt> it exits, and must be a <a class="reference internal" href="#i-cleanuppad"><em>cleanuppad</em></a>.
+If the specified <tt class="docutils literal"><span class="pre">cleanuppad</span></tt> is not the most-recently-entered not-yet-exited
+funclet pad (as described in the <a class="reference external" href="ExceptionHandling.html#wineh-constraints">EH documentation</a>),
+the <tt class="docutils literal"><span class="pre">cleanupret</span></tt>‘s behavior is undefined.</p>
+<p>The ‘<tt class="docutils literal"><span class="pre">cleanupret</span></tt>‘ instruction also has an optional successor, <tt class="docutils literal"><span class="pre">continue</span></tt>,
+which must be the label of another basic block beginning with either a
+<tt class="docutils literal"><span class="pre">cleanuppad</span></tt> or <tt class="docutils literal"><span class="pre">catchswitch</span></tt> instruction.  This unwind destination must
+be a legal target with respect to the <tt class="docutils literal"><span class="pre">parent</span></tt> links, as described in the
+<a class="reference external" href="ExceptionHandling.html#wineh-constraints">exception handling documentation</a>.</p>
+</div>
+<div class="section" id="id62">
+<h5><a class="toc-backref" href="#id1014">Semantics:</a><a class="headerlink" href="#id62" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">cleanupret</span></tt>‘ instruction indicates to the
+<a class="reference internal" href="#personalityfn"><em>personality function</em></a> that one
+<a class="reference internal" href="#i-cleanuppad"><em>cleanuppad</em></a> it transferred control to has ended.
+It transfers control to <tt class="docutils literal"><span class="pre">continue</span></tt> or unwinds out of the function.</p>
+</div>
+<div class="section" id="id63">
+<h5><a class="toc-backref" href="#id1015">Example:</a><a class="headerlink" href="#id63" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre>cleanupret from %cleanup unwind to caller
+cleanupret from %cleanup unwind label %continue
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="unreachable-instruction">
+<span id="i-unreachable"></span><h4><a class="toc-backref" href="#id1016">‘<tt class="docutils literal"><span class="pre">unreachable</span></tt>‘ Instruction</a><a class="headerlink" href="#unreachable-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id64">
+<h5><a class="toc-backref" href="#id1017">Syntax:</a><a class="headerlink" href="#id64" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><span class="n">unreachable</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="id65">
+<h5><a class="toc-backref" href="#id1018">Overview:</a><a class="headerlink" href="#id65" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">unreachable</span></tt>‘ instruction has no defined semantics. This
+instruction is used to inform the optimizer that a particular portion of
+the code is not reachable. This can be used to indicate that the code
+after a no-return function cannot be reached, and other facts.</p>
+</div>
+<div class="section" id="id66">
+<h5><a class="toc-backref" href="#id1019">Semantics:</a><a class="headerlink" href="#id66" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">unreachable</span></tt>‘ instruction has no defined semantics.</p>
+</div>
+</div>
+</div>
+<div class="section" id="binary-operations">
+<span id="binaryops"></span><h3><a class="toc-backref" href="#id1020">Binary Operations</a><a class="headerlink" href="#binary-operations" title="Permalink to this headline">¶</a></h3>
+<p>Binary operators are used to do most of the computation in a program.
+They require two operands of the same type, execute an operation on
+them, and produce a single value. The operands might represent multiple
+data, as is the case with the <a class="reference internal" href="#t-vector"><em>vector</em></a> data type. The
+result value has the same type as its operands.</p>
+<p>There are several different binary operators:</p>
+<div class="section" id="add-instruction">
+<span id="i-add"></span><h4><a class="toc-backref" href="#id1021">‘<tt class="docutils literal"><span class="pre">add</span></tt>‘ Instruction</a><a class="headerlink" href="#add-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id67">
+<h5><a class="toc-backref" href="#id1022">Syntax:</a><a class="headerlink" href="#id67" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = add <ty> <op1>, <op2>          ; yields ty:result
+<result> = add nuw <ty> <op1>, <op2>      ; yields ty:result
+<result> = add nsw <ty> <op1>, <op2>      ; yields ty:result
+<result> = add nuw nsw <ty> <op1>, <op2>  ; yields ty:result</pre>
+</div>
+</div>
+<div class="section" id="id68">
+<h5><a class="toc-backref" href="#id1023">Overview:</a><a class="headerlink" href="#id68" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">add</span></tt>‘ instruction returns the sum of its two operands.</p>
+</div>
+<div class="section" id="id69">
+<h5><a class="toc-backref" href="#id1024">Arguments:</a><a class="headerlink" href="#id69" title="Permalink to this headline">¶</a></h5>
+<p>The two arguments to the ‘<tt class="docutils literal"><span class="pre">add</span></tt>‘ instruction must be
+<a class="reference internal" href="#t-integer"><em>integer</em></a> or <a class="reference internal" href="#t-vector"><em>vector</em></a> of integer values. Both
+arguments must have identical types.</p>
+</div>
+<div class="section" id="id70">
+<h5><a class="toc-backref" href="#id1025">Semantics:</a><a class="headerlink" href="#id70" title="Permalink to this headline">¶</a></h5>
+<p>The value produced is the integer sum of the two operands.</p>
+<p>If the sum has unsigned overflow, the result returned is the
+mathematical result modulo 2<sup>n</sup>, where n is the bit width of
+the result.</p>
+<p>Because LLVM integers use a two’s complement representation, this
+instruction is appropriate for both signed and unsigned integers.</p>
+<p><tt class="docutils literal"><span class="pre">nuw</span></tt> and <tt class="docutils literal"><span class="pre">nsw</span></tt> stand for “No Unsigned Wrap” and “No Signed Wrap”,
+respectively. If the <tt class="docutils literal"><span class="pre">nuw</span></tt> and/or <tt class="docutils literal"><span class="pre">nsw</span></tt> keywords are present, the
+result value of the <tt class="docutils literal"><span class="pre">add</span></tt> is a <a class="reference internal" href="#poisonvalues"><em>poison value</em></a> if
+unsigned and/or signed overflow, respectively, occurs.</p>
+</div>
+<div class="section" id="id71">
+<h5><a class="toc-backref" href="#id1026">Example:</a><a class="headerlink" href="#id71" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre><result> = add i32 4, %var          ; yields i32:result = 4 + %var
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="fadd-instruction">
+<span id="i-fadd"></span><h4><a class="toc-backref" href="#id1027">‘<tt class="docutils literal"><span class="pre">fadd</span></tt>‘ Instruction</a><a class="headerlink" href="#fadd-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id72">
+<h5><a class="toc-backref" href="#id1028">Syntax:</a><a class="headerlink" href="#id72" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = fadd [fast-math flags]* <ty> <op1>, <op2>   ; yields ty:result</pre>
+</div>
+</div>
+<div class="section" id="id73">
+<h5><a class="toc-backref" href="#id1029">Overview:</a><a class="headerlink" href="#id73" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">fadd</span></tt>‘ instruction returns the sum of its two operands.</p>
+</div>
+<div class="section" id="id74">
+<h5><a class="toc-backref" href="#id1030">Arguments:</a><a class="headerlink" href="#id74" title="Permalink to this headline">¶</a></h5>
+<p>The two arguments to the ‘<tt class="docutils literal"><span class="pre">fadd</span></tt>‘ instruction must be <a class="reference internal" href="#t-floating"><em>floating
+point</em></a> or <a class="reference internal" href="#t-vector"><em>vector</em></a> of floating point values.
+Both arguments must have identical types.</p>
+</div>
+<div class="section" id="id75">
+<h5><a class="toc-backref" href="#id1031">Semantics:</a><a class="headerlink" href="#id75" title="Permalink to this headline">¶</a></h5>
+<p>The value produced is the floating point sum of the two operands. This
+instruction can also take any number of <a class="reference internal" href="#fastmath"><em>fast-math flags</em></a>,
+which are optimization hints to enable otherwise unsafe floating point
+optimizations:</p>
+</div>
+<div class="section" id="id76">
+<h5><a class="toc-backref" href="#id1032">Example:</a><a class="headerlink" href="#id76" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre><result> = fadd float 4.0, %var          ; yields float:result = 4.0 + %var
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="sub-instruction">
+<h4><a class="toc-backref" href="#id1033">‘<tt class="docutils literal"><span class="pre">sub</span></tt>‘ Instruction</a><a class="headerlink" href="#sub-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id77">
+<h5><a class="toc-backref" href="#id1034">Syntax:</a><a class="headerlink" href="#id77" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = sub <ty> <op1>, <op2>          ; yields ty:result
+<result> = sub nuw <ty> <op1>, <op2>      ; yields ty:result
+<result> = sub nsw <ty> <op1>, <op2>      ; yields ty:result
+<result> = sub nuw nsw <ty> <op1>, <op2>  ; yields ty:result</pre>
+</div>
+</div>
+<div class="section" id="id78">
+<h5><a class="toc-backref" href="#id1035">Overview:</a><a class="headerlink" href="#id78" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">sub</span></tt>‘ instruction returns the difference of its two operands.</p>
+<p>Note that the ‘<tt class="docutils literal"><span class="pre">sub</span></tt>‘ instruction is used to represent the ‘<tt class="docutils literal"><span class="pre">neg</span></tt>‘
+instruction present in most other intermediate representations.</p>
+</div>
+<div class="section" id="id79">
+<h5><a class="toc-backref" href="#id1036">Arguments:</a><a class="headerlink" href="#id79" title="Permalink to this headline">¶</a></h5>
+<p>The two arguments to the ‘<tt class="docutils literal"><span class="pre">sub</span></tt>‘ instruction must be
+<a class="reference internal" href="#t-integer"><em>integer</em></a> or <a class="reference internal" href="#t-vector"><em>vector</em></a> of integer values. Both
+arguments must have identical types.</p>
+</div>
+<div class="section" id="id80">
+<h5><a class="toc-backref" href="#id1037">Semantics:</a><a class="headerlink" href="#id80" title="Permalink to this headline">¶</a></h5>
+<p>The value produced is the integer difference of the two operands.</p>
+<p>If the difference has unsigned overflow, the result returned is the
+mathematical result modulo 2<sup>n</sup>, where n is the bit width of
+the result.</p>
+<p>Because LLVM integers use a two’s complement representation, this
+instruction is appropriate for both signed and unsigned integers.</p>
+<p><tt class="docutils literal"><span class="pre">nuw</span></tt> and <tt class="docutils literal"><span class="pre">nsw</span></tt> stand for “No Unsigned Wrap” and “No Signed Wrap”,
+respectively. If the <tt class="docutils literal"><span class="pre">nuw</span></tt> and/or <tt class="docutils literal"><span class="pre">nsw</span></tt> keywords are present, the
+result value of the <tt class="docutils literal"><span class="pre">sub</span></tt> is a <a class="reference internal" href="#poisonvalues"><em>poison value</em></a> if
+unsigned and/or signed overflow, respectively, occurs.</p>
+</div>
+<div class="section" id="id81">
+<h5><a class="toc-backref" href="#id1038">Example:</a><a class="headerlink" href="#id81" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre><result> = sub i32 4, %var          ; yields i32:result = 4 - %var
+<result> = sub i32 0, %val          ; yields i32:result = -%var
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="fsub-instruction">
+<span id="i-fsub"></span><h4><a class="toc-backref" href="#id1039">‘<tt class="docutils literal"><span class="pre">fsub</span></tt>‘ Instruction</a><a class="headerlink" href="#fsub-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id82">
+<h5><a class="toc-backref" href="#id1040">Syntax:</a><a class="headerlink" href="#id82" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = fsub [fast-math flags]* <ty> <op1>, <op2>   ; yields ty:result</pre>
+</div>
+</div>
+<div class="section" id="id83">
+<h5><a class="toc-backref" href="#id1041">Overview:</a><a class="headerlink" href="#id83" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">fsub</span></tt>‘ instruction returns the difference of its two operands.</p>
+<p>Note that the ‘<tt class="docutils literal"><span class="pre">fsub</span></tt>‘ instruction is used to represent the ‘<tt class="docutils literal"><span class="pre">fneg</span></tt>‘
+instruction present in most other intermediate representations.</p>
+</div>
+<div class="section" id="id84">
+<h5><a class="toc-backref" href="#id1042">Arguments:</a><a class="headerlink" href="#id84" title="Permalink to this headline">¶</a></h5>
+<p>The two arguments to the ‘<tt class="docutils literal"><span class="pre">fsub</span></tt>‘ instruction must be <a class="reference internal" href="#t-floating"><em>floating
+point</em></a> or <a class="reference internal" href="#t-vector"><em>vector</em></a> of floating point values.
+Both arguments must have identical types.</p>
+</div>
+<div class="section" id="id85">
+<h5><a class="toc-backref" href="#id1043">Semantics:</a><a class="headerlink" href="#id85" title="Permalink to this headline">¶</a></h5>
+<p>The value produced is the floating point difference of the two operands.
+This instruction can also take any number of <a class="reference internal" href="#fastmath"><em>fast-math
+flags</em></a>, which are optimization hints to enable otherwise
+unsafe floating point optimizations:</p>
+</div>
+<div class="section" id="id86">
+<h5><a class="toc-backref" href="#id1044">Example:</a><a class="headerlink" href="#id86" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre><result> = fsub float 4.0, %var           ; yields float:result = 4.0 - %var
+<result> = fsub float -0.0, %val          ; yields float:result = -%var
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="mul-instruction">
+<h4><a class="toc-backref" href="#id1045">‘<tt class="docutils literal"><span class="pre">mul</span></tt>‘ Instruction</a><a class="headerlink" href="#mul-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id87">
+<h5><a class="toc-backref" href="#id1046">Syntax:</a><a class="headerlink" href="#id87" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = mul <ty> <op1>, <op2>          ; yields ty:result
+<result> = mul nuw <ty> <op1>, <op2>      ; yields ty:result
+<result> = mul nsw <ty> <op1>, <op2>      ; yields ty:result
+<result> = mul nuw nsw <ty> <op1>, <op2>  ; yields ty:result</pre>
+</div>
+</div>
+<div class="section" id="id88">
+<h5><a class="toc-backref" href="#id1047">Overview:</a><a class="headerlink" href="#id88" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">mul</span></tt>‘ instruction returns the product of its two operands.</p>
+</div>
+<div class="section" id="id89">
+<h5><a class="toc-backref" href="#id1048">Arguments:</a><a class="headerlink" href="#id89" title="Permalink to this headline">¶</a></h5>
+<p>The two arguments to the ‘<tt class="docutils literal"><span class="pre">mul</span></tt>‘ instruction must be
+<a class="reference internal" href="#t-integer"><em>integer</em></a> or <a class="reference internal" href="#t-vector"><em>vector</em></a> of integer values. Both
+arguments must have identical types.</p>
+</div>
+<div class="section" id="id90">
+<h5><a class="toc-backref" href="#id1049">Semantics:</a><a class="headerlink" href="#id90" title="Permalink to this headline">¶</a></h5>
+<p>The value produced is the integer product of the two operands.</p>
+<p>If the result of the multiplication has unsigned overflow, the result
+returned is the mathematical result modulo 2<sup>n</sup>, where n is the
+bit width of the result.</p>
+<p>Because LLVM integers use a two’s complement representation, and the
+result is the same width as the operands, this instruction returns the
+correct result for both signed and unsigned integers. If a full product
+(e.g. <tt class="docutils literal"><span class="pre">i32</span></tt> * <tt class="docutils literal"><span class="pre">i32</span></tt> -> <tt class="docutils literal"><span class="pre">i64</span></tt>) is needed, the operands should be
+sign-extended or zero-extended as appropriate to the width of the full
+product.</p>
+<p><tt class="docutils literal"><span class="pre">nuw</span></tt> and <tt class="docutils literal"><span class="pre">nsw</span></tt> stand for “No Unsigned Wrap” and “No Signed Wrap”,
+respectively. If the <tt class="docutils literal"><span class="pre">nuw</span></tt> and/or <tt class="docutils literal"><span class="pre">nsw</span></tt> keywords are present, the
+result value of the <tt class="docutils literal"><span class="pre">mul</span></tt> is a <a class="reference internal" href="#poisonvalues"><em>poison value</em></a> if
+unsigned and/or signed overflow, respectively, occurs.</p>
+</div>
+<div class="section" id="id91">
+<h5><a class="toc-backref" href="#id1050">Example:</a><a class="headerlink" href="#id91" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre><result> = mul i32 4, %var          ; yields i32:result = 4 * %var
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="fmul-instruction">
+<span id="i-fmul"></span><h4><a class="toc-backref" href="#id1051">‘<tt class="docutils literal"><span class="pre">fmul</span></tt>‘ Instruction</a><a class="headerlink" href="#fmul-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id92">
+<h5><a class="toc-backref" href="#id1052">Syntax:</a><a class="headerlink" href="#id92" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = fmul [fast-math flags]* <ty> <op1>, <op2>   ; yields ty:result</pre>
+</div>
+</div>
+<div class="section" id="id93">
+<h5><a class="toc-backref" href="#id1053">Overview:</a><a class="headerlink" href="#id93" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">fmul</span></tt>‘ instruction returns the product of its two operands.</p>
+</div>
+<div class="section" id="id94">
+<h5><a class="toc-backref" href="#id1054">Arguments:</a><a class="headerlink" href="#id94" title="Permalink to this headline">¶</a></h5>
+<p>The two arguments to the ‘<tt class="docutils literal"><span class="pre">fmul</span></tt>‘ instruction must be <a class="reference internal" href="#t-floating"><em>floating
+point</em></a> or <a class="reference internal" href="#t-vector"><em>vector</em></a> of floating point values.
+Both arguments must have identical types.</p>
+</div>
+<div class="section" id="id95">
+<h5><a class="toc-backref" href="#id1055">Semantics:</a><a class="headerlink" href="#id95" title="Permalink to this headline">¶</a></h5>
+<p>The value produced is the floating point product of the two operands.
+This instruction can also take any number of <a class="reference internal" href="#fastmath"><em>fast-math
+flags</em></a>, which are optimization hints to enable otherwise
+unsafe floating point optimizations:</p>
+</div>
+<div class="section" id="id96">
+<h5><a class="toc-backref" href="#id1056">Example:</a><a class="headerlink" href="#id96" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre><result> = fmul float 4.0, %var          ; yields float:result = 4.0 * %var
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="udiv-instruction">
+<h4><a class="toc-backref" href="#id1057">‘<tt class="docutils literal"><span class="pre">udiv</span></tt>‘ Instruction</a><a class="headerlink" href="#udiv-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id97">
+<h5><a class="toc-backref" href="#id1058">Syntax:</a><a class="headerlink" href="#id97" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = udiv <ty> <op1>, <op2>         ; yields ty:result
+<result> = udiv exact <ty> <op1>, <op2>   ; yields ty:result</pre>
+</div>
+</div>
+<div class="section" id="id98">
+<h5><a class="toc-backref" href="#id1059">Overview:</a><a class="headerlink" href="#id98" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">udiv</span></tt>‘ instruction returns the quotient of its two operands.</p>
+</div>
+<div class="section" id="id99">
+<h5><a class="toc-backref" href="#id1060">Arguments:</a><a class="headerlink" href="#id99" title="Permalink to this headline">¶</a></h5>
+<p>The two arguments to the ‘<tt class="docutils literal"><span class="pre">udiv</span></tt>‘ instruction must be
+<a class="reference internal" href="#t-integer"><em>integer</em></a> or <a class="reference internal" href="#t-vector"><em>vector</em></a> of integer values. Both
+arguments must have identical types.</p>
+</div>
+<div class="section" id="id100">
+<h5><a class="toc-backref" href="#id1061">Semantics:</a><a class="headerlink" href="#id100" title="Permalink to this headline">¶</a></h5>
+<p>The value produced is the unsigned integer quotient of the two operands.</p>
+<p>Note that unsigned integer division and signed integer division are
+distinct operations; for signed integer division, use ‘<tt class="docutils literal"><span class="pre">sdiv</span></tt>‘.</p>
+<p>Division by zero is undefined behavior. For vectors, if any element
+of the divisor is zero, the operation has undefined behavior.</p>
+<p>If the <tt class="docutils literal"><span class="pre">exact</span></tt> keyword is present, the result value of the <tt class="docutils literal"><span class="pre">udiv</span></tt> is
+a <a class="reference internal" href="#poisonvalues"><em>poison value</em></a> if %op1 is not a multiple of %op2 (as
+such, “((a udiv exact b) mul b) == a”).</p>
+</div>
+<div class="section" id="id101">
+<h5><a class="toc-backref" href="#id1062">Example:</a><a class="headerlink" href="#id101" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre><result> = udiv i32 4, %var          ; yields i32:result = 4 / %var
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="sdiv-instruction">
+<h4><a class="toc-backref" href="#id1063">‘<tt class="docutils literal"><span class="pre">sdiv</span></tt>‘ Instruction</a><a class="headerlink" href="#sdiv-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id102">
+<h5><a class="toc-backref" href="#id1064">Syntax:</a><a class="headerlink" href="#id102" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = sdiv <ty> <op1>, <op2>         ; yields ty:result
+<result> = sdiv exact <ty> <op1>, <op2>   ; yields ty:result</pre>
+</div>
+</div>
+<div class="section" id="id103">
+<h5><a class="toc-backref" href="#id1065">Overview:</a><a class="headerlink" href="#id103" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">sdiv</span></tt>‘ instruction returns the quotient of its two operands.</p>
+</div>
+<div class="section" id="id104">
+<h5><a class="toc-backref" href="#id1066">Arguments:</a><a class="headerlink" href="#id104" title="Permalink to this headline">¶</a></h5>
+<p>The two arguments to the ‘<tt class="docutils literal"><span class="pre">sdiv</span></tt>‘ instruction must be
+<a class="reference internal" href="#t-integer"><em>integer</em></a> or <a class="reference internal" href="#t-vector"><em>vector</em></a> of integer values. Both
+arguments must have identical types.</p>
+</div>
+<div class="section" id="id105">
+<h5><a class="toc-backref" href="#id1067">Semantics:</a><a class="headerlink" href="#id105" title="Permalink to this headline">¶</a></h5>
+<p>The value produced is the signed integer quotient of the two operands
+rounded towards zero.</p>
+<p>Note that signed integer division and unsigned integer division are
+distinct operations; for unsigned integer division, use ‘<tt class="docutils literal"><span class="pre">udiv</span></tt>‘.</p>
+<p>Division by zero is undefined behavior. For vectors, if any element
+of the divisor is zero, the operation has undefined behavior.
+Overflow also leads to undefined behavior; this is a rare case, but can
+occur, for example, by doing a 32-bit division of -2147483648 by -1.</p>
+<p>If the <tt class="docutils literal"><span class="pre">exact</span></tt> keyword is present, the result value of the <tt class="docutils literal"><span class="pre">sdiv</span></tt> is
+a <a class="reference internal" href="#poisonvalues"><em>poison value</em></a> if the result would be rounded.</p>
+</div>
+<div class="section" id="id106">
+<h5><a class="toc-backref" href="#id1068">Example:</a><a class="headerlink" href="#id106" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre><result> = sdiv i32 4, %var          ; yields i32:result = 4 / %var
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="fdiv-instruction">
+<span id="i-fdiv"></span><h4><a class="toc-backref" href="#id1069">‘<tt class="docutils literal"><span class="pre">fdiv</span></tt>‘ Instruction</a><a class="headerlink" href="#fdiv-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id107">
+<h5><a class="toc-backref" href="#id1070">Syntax:</a><a class="headerlink" href="#id107" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = fdiv [fast-math flags]* <ty> <op1>, <op2>   ; yields ty:result</pre>
+</div>
+</div>
+<div class="section" id="id108">
+<h5><a class="toc-backref" href="#id1071">Overview:</a><a class="headerlink" href="#id108" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">fdiv</span></tt>‘ instruction returns the quotient of its two operands.</p>
+</div>
+<div class="section" id="id109">
+<h5><a class="toc-backref" href="#id1072">Arguments:</a><a class="headerlink" href="#id109" title="Permalink to this headline">¶</a></h5>
+<p>The two arguments to the ‘<tt class="docutils literal"><span class="pre">fdiv</span></tt>‘ instruction must be <a class="reference internal" href="#t-floating"><em>floating
+point</em></a> or <a class="reference internal" href="#t-vector"><em>vector</em></a> of floating point values.
+Both arguments must have identical types.</p>
+</div>
+<div class="section" id="id110">
+<h5><a class="toc-backref" href="#id1073">Semantics:</a><a class="headerlink" href="#id110" title="Permalink to this headline">¶</a></h5>
+<p>The value produced is the floating point quotient of the two operands.
+This instruction can also take any number of <a class="reference internal" href="#fastmath"><em>fast-math
+flags</em></a>, which are optimization hints to enable otherwise
+unsafe floating point optimizations:</p>
+</div>
+<div class="section" id="id111">
+<h5><a class="toc-backref" href="#id1074">Example:</a><a class="headerlink" href="#id111" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre><result> = fdiv float 4.0, %var          ; yields float:result = 4.0 / %var
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="urem-instruction">
+<h4><a class="toc-backref" href="#id1075">‘<tt class="docutils literal"><span class="pre">urem</span></tt>‘ Instruction</a><a class="headerlink" href="#urem-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id112">
+<h5><a class="toc-backref" href="#id1076">Syntax:</a><a class="headerlink" href="#id112" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = urem <ty> <op1>, <op2>   ; yields ty:result</pre>
+</div>
+</div>
+<div class="section" id="id113">
+<h5><a class="toc-backref" href="#id1077">Overview:</a><a class="headerlink" href="#id113" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">urem</span></tt>‘ instruction returns the remainder from the unsigned
+division of its two arguments.</p>
+</div>
+<div class="section" id="id114">
+<h5><a class="toc-backref" href="#id1078">Arguments:</a><a class="headerlink" href="#id114" title="Permalink to this headline">¶</a></h5>
+<p>The two arguments to the ‘<tt class="docutils literal"><span class="pre">urem</span></tt>‘ instruction must be
+<a class="reference internal" href="#t-integer"><em>integer</em></a> or <a class="reference internal" href="#t-vector"><em>vector</em></a> of integer values. Both
+arguments must have identical types.</p>
+</div>
+<div class="section" id="id115">
+<h5><a class="toc-backref" href="#id1079">Semantics:</a><a class="headerlink" href="#id115" title="Permalink to this headline">¶</a></h5>
+<p>This instruction returns the unsigned integer <em>remainder</em> of a division.
+This instruction always performs an unsigned division to get the
+remainder.</p>
+<p>Note that unsigned integer remainder and signed integer remainder are
+distinct operations; for signed integer remainder, use ‘<tt class="docutils literal"><span class="pre">srem</span></tt>‘.</p>
+<p>Taking the remainder of a division by zero is undefined behavior.
+For vectors, if any element of the divisor is zero, the operation has
+undefined behavior.</p>
+</div>
+<div class="section" id="id116">
+<h5><a class="toc-backref" href="#id1080">Example:</a><a class="headerlink" href="#id116" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre><result> = urem i32 4, %var          ; yields i32:result = 4 % %var
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="srem-instruction">
+<h4><a class="toc-backref" href="#id1081">‘<tt class="docutils literal"><span class="pre">srem</span></tt>‘ Instruction</a><a class="headerlink" href="#srem-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id117">
+<h5><a class="toc-backref" href="#id1082">Syntax:</a><a class="headerlink" href="#id117" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = srem <ty> <op1>, <op2>   ; yields ty:result</pre>
+</div>
+</div>
+<div class="section" id="id118">
+<h5><a class="toc-backref" href="#id1083">Overview:</a><a class="headerlink" href="#id118" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">srem</span></tt>‘ instruction returns the remainder from the signed
+division of its two operands. This instruction can also take
+<a class="reference internal" href="#t-vector"><em>vector</em></a> versions of the values in which case the elements
+must be integers.</p>
+</div>
+<div class="section" id="id119">
+<h5><a class="toc-backref" href="#id1084">Arguments:</a><a class="headerlink" href="#id119" title="Permalink to this headline">¶</a></h5>
+<p>The two arguments to the ‘<tt class="docutils literal"><span class="pre">srem</span></tt>‘ instruction must be
+<a class="reference internal" href="#t-integer"><em>integer</em></a> or <a class="reference internal" href="#t-vector"><em>vector</em></a> of integer values. Both
+arguments must have identical types.</p>
+</div>
+<div class="section" id="id120">
+<h5><a class="toc-backref" href="#id1085">Semantics:</a><a class="headerlink" href="#id120" title="Permalink to this headline">¶</a></h5>
+<p>This instruction returns the <em>remainder</em> of a division (where the result
+is either zero or has the same sign as the dividend, <tt class="docutils literal"><span class="pre">op1</span></tt>), not the
+<em>modulo</em> operator (where the result is either zero or has the same sign
+as the divisor, <tt class="docutils literal"><span class="pre">op2</span></tt>) of a value. For more information about the
+difference, see <a class="reference external" href="http://mathforum.org/dr.math/problems/anne.4.28.99.html">The Math
+Forum</a>. For a
+table of how this is implemented in various languages, please see
+<a class="reference external" href="http://en.wikipedia.org/wiki/Modulo_operation">Wikipedia: modulo
+operation</a>.</p>
+<p>Note that signed integer remainder and unsigned integer remainder are
+distinct operations; for unsigned integer remainder, use ‘<tt class="docutils literal"><span class="pre">urem</span></tt>‘.</p>
+<p>Taking the remainder of a division by zero is undefined behavior.
+For vectors, if any element of the divisor is zero, the operation has
+undefined behavior.
+Overflow also leads to undefined behavior; this is a rare case, but can
+occur, for example, by taking the remainder of a 32-bit division of
+-2147483648 by -1. (The remainder doesn’t actually overflow, but this
+rule lets srem be implemented using instructions that return both the
+result of the division and the remainder.)</p>
+</div>
+<div class="section" id="id121">
+<h5><a class="toc-backref" href="#id1086">Example:</a><a class="headerlink" href="#id121" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre><result> = srem i32 4, %var          ; yields i32:result = 4 % %var
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="frem-instruction">
+<span id="i-frem"></span><h4><a class="toc-backref" href="#id1087">‘<tt class="docutils literal"><span class="pre">frem</span></tt>‘ Instruction</a><a class="headerlink" href="#frem-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id122">
+<h5><a class="toc-backref" href="#id1088">Syntax:</a><a class="headerlink" href="#id122" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = frem [fast-math flags]* <ty> <op1>, <op2>   ; yields ty:result</pre>
+</div>
+</div>
+<div class="section" id="id123">
+<h5><a class="toc-backref" href="#id1089">Overview:</a><a class="headerlink" href="#id123" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">frem</span></tt>‘ instruction returns the remainder from the division of
+its two operands.</p>
+</div>
+<div class="section" id="id124">
+<h5><a class="toc-backref" href="#id1090">Arguments:</a><a class="headerlink" href="#id124" title="Permalink to this headline">¶</a></h5>
+<p>The two arguments to the ‘<tt class="docutils literal"><span class="pre">frem</span></tt>‘ instruction must be <a class="reference internal" href="#t-floating"><em>floating
+point</em></a> or <a class="reference internal" href="#t-vector"><em>vector</em></a> of floating point values.
+Both arguments must have identical types.</p>
+</div>
+<div class="section" id="id125">
+<h5><a class="toc-backref" href="#id1091">Semantics:</a><a class="headerlink" href="#id125" title="Permalink to this headline">¶</a></h5>
+<p>Return the same value as a libm ‘<tt class="docutils literal"><span class="pre">fmod</span></tt>‘ function but without trapping or
+setting <tt class="docutils literal"><span class="pre">errno</span></tt>.</p>
+<p>The remainder has the same sign as the dividend. This instruction can also
+take any number of <a class="reference internal" href="#fastmath"><em>fast-math flags</em></a>, which are optimization
+hints to enable otherwise unsafe floating-point optimizations:</p>
+</div>
+<div class="section" id="id126">
+<h5><a class="toc-backref" href="#id1092">Example:</a><a class="headerlink" href="#id126" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre><result> = frem float 4.0, %var          ; yields float:result = 4.0 % %var
+</pre></div>
+</div>
+</div>
+</div>
+</div>
+<div class="section" id="bitwise-binary-operations">
+<span id="bitwiseops"></span><h3><a class="toc-backref" href="#id1093">Bitwise Binary Operations</a><a class="headerlink" href="#bitwise-binary-operations" title="Permalink to this headline">¶</a></h3>
+<p>Bitwise binary operators are used to do various forms of bit-twiddling
+in a program. They are generally very efficient instructions and can
+commonly be strength reduced from other instructions. They require two
+operands of the same type, execute an operation on them, and produce a
+single value. The resulting value is the same type as its operands.</p>
+<div class="section" id="shl-instruction">
+<h4><a class="toc-backref" href="#id1094">‘<tt class="docutils literal"><span class="pre">shl</span></tt>‘ Instruction</a><a class="headerlink" href="#shl-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id127">
+<h5><a class="toc-backref" href="#id1095">Syntax:</a><a class="headerlink" href="#id127" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = shl <ty> <op1>, <op2>           ; yields ty:result
+<result> = shl nuw <ty> <op1>, <op2>       ; yields ty:result
+<result> = shl nsw <ty> <op1>, <op2>       ; yields ty:result
+<result> = shl nuw nsw <ty> <op1>, <op2>   ; yields ty:result</pre>
+</div>
+</div>
+<div class="section" id="id128">
+<h5><a class="toc-backref" href="#id1096">Overview:</a><a class="headerlink" href="#id128" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">shl</span></tt>‘ instruction returns the first operand shifted to the left
+a specified number of bits.</p>
+</div>
+<div class="section" id="id129">
+<h5><a class="toc-backref" href="#id1097">Arguments:</a><a class="headerlink" href="#id129" title="Permalink to this headline">¶</a></h5>
+<p>Both arguments to the ‘<tt class="docutils literal"><span class="pre">shl</span></tt>‘ instruction must be the same
+<a class="reference internal" href="#t-integer"><em>integer</em></a> or <a class="reference internal" href="#t-vector"><em>vector</em></a> of integer type.
+‘<tt class="docutils literal"><span class="pre">op2</span></tt>‘ is treated as an unsigned value.</p>
+</div>
+<div class="section" id="id130">
+<h5><a class="toc-backref" href="#id1098">Semantics:</a><a class="headerlink" href="#id130" title="Permalink to this headline">¶</a></h5>
+<p>The value produced is <tt class="docutils literal"><span class="pre">op1</span></tt> * 2<sup>op2</sup> mod 2<sup>n</sup>,
+where <tt class="docutils literal"><span class="pre">n</span></tt> is the width of the result. If <tt class="docutils literal"><span class="pre">op2</span></tt> is (statically or
+dynamically) equal to or larger than the number of bits in
+<tt class="docutils literal"><span class="pre">op1</span></tt>, this instruction returns a <a class="reference internal" href="#poisonvalues"><em>poison value</em></a>.
+If the arguments are vectors, each vector element of <tt class="docutils literal"><span class="pre">op1</span></tt> is shifted
+by the corresponding shift amount in <tt class="docutils literal"><span class="pre">op2</span></tt>.</p>
+<p>If the <tt class="docutils literal"><span class="pre">nuw</span></tt> keyword is present, then the shift produces a poison
+value if it shifts out any non-zero bits.
+If the <tt class="docutils literal"><span class="pre">nsw</span></tt> keyword is present, then the shift produces a poison
+value it shifts out any bits that disagree with the resultant sign bit.</p>
+</div>
+<div class="section" id="id131">
+<h5><a class="toc-backref" href="#id1099">Example:</a><a class="headerlink" href="#id131" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre><result> = shl i32 4, %var   ; yields i32: 4 << %var
+<result> = shl i32 4, 2      ; yields i32: 16
+<result> = shl i32 1, 10     ; yields i32: 1024
+<result> = shl i32 1, 32     ; undefined
+<result> = shl <2 x i32> < i32 1, i32 1>, < i32 1, i32 2>   ; yields: result=<2 x i32> < i32 2, i32 4>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="lshr-instruction">
+<h4><a class="toc-backref" href="#id1100">‘<tt class="docutils literal"><span class="pre">lshr</span></tt>‘ Instruction</a><a class="headerlink" href="#lshr-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id132">
+<h5><a class="toc-backref" href="#id1101">Syntax:</a><a class="headerlink" href="#id132" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = lshr <ty> <op1>, <op2>         ; yields ty:result
+<result> = lshr exact <ty> <op1>, <op2>   ; yields ty:result</pre>
+</div>
+</div>
+<div class="section" id="id133">
+<h5><a class="toc-backref" href="#id1102">Overview:</a><a class="headerlink" href="#id133" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">lshr</span></tt>‘ instruction (logical shift right) returns the first
+operand shifted to the right a specified number of bits with zero fill.</p>
+</div>
+<div class="section" id="id134">
+<h5><a class="toc-backref" href="#id1103">Arguments:</a><a class="headerlink" href="#id134" title="Permalink to this headline">¶</a></h5>
+<p>Both arguments to the ‘<tt class="docutils literal"><span class="pre">lshr</span></tt>‘ instruction must be the same
+<a class="reference internal" href="#t-integer"><em>integer</em></a> or <a class="reference internal" href="#t-vector"><em>vector</em></a> of integer type.
+‘<tt class="docutils literal"><span class="pre">op2</span></tt>‘ is treated as an unsigned value.</p>
+</div>
+<div class="section" id="id135">
+<h5><a class="toc-backref" href="#id1104">Semantics:</a><a class="headerlink" href="#id135" title="Permalink to this headline">¶</a></h5>
+<p>This instruction always performs a logical shift right operation. The
+most significant bits of the result will be filled with zero bits after
+the shift. If <tt class="docutils literal"><span class="pre">op2</span></tt> is (statically or dynamically) equal to or larger
+than the number of bits in <tt class="docutils literal"><span class="pre">op1</span></tt>, this instruction returns a <a class="reference internal" href="#poisonvalues"><em>poison
+value</em></a>. If the arguments are vectors, each vector element
+of <tt class="docutils literal"><span class="pre">op1</span></tt> is shifted by the corresponding shift amount in <tt class="docutils literal"><span class="pre">op2</span></tt>.</p>
+<p>If the <tt class="docutils literal"><span class="pre">exact</span></tt> keyword is present, the result value of the <tt class="docutils literal"><span class="pre">lshr</span></tt> is
+a poison value if any of the bits shifted out are non-zero.</p>
+</div>
+<div class="section" id="id136">
+<h5><a class="toc-backref" href="#id1105">Example:</a><a class="headerlink" href="#id136" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre><result> = lshr i32 4, 1   ; yields i32:result = 2
+<result> = lshr i32 4, 2   ; yields i32:result = 1
+<result> = lshr i8  4, 3   ; yields i8:result = 0
+<result> = lshr i8 -2, 1   ; yields i8:result = 0x7F
+<result> = lshr i32 1, 32  ; undefined
+<result> = lshr <2 x i32> < i32 -2, i32 4>, < i32 1, i32 2>   ; yields: result=<2 x i32> < i32 0x7FFFFFFF, i32 1>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="ashr-instruction">
+<h4><a class="toc-backref" href="#id1106">‘<tt class="docutils literal"><span class="pre">ashr</span></tt>‘ Instruction</a><a class="headerlink" href="#ashr-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id137">
+<h5><a class="toc-backref" href="#id1107">Syntax:</a><a class="headerlink" href="#id137" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = ashr <ty> <op1>, <op2>         ; yields ty:result
+<result> = ashr exact <ty> <op1>, <op2>   ; yields ty:result</pre>
+</div>
+</div>
+<div class="section" id="id138">
+<h5><a class="toc-backref" href="#id1108">Overview:</a><a class="headerlink" href="#id138" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">ashr</span></tt>‘ instruction (arithmetic shift right) returns the first
+operand shifted to the right a specified number of bits with sign
+extension.</p>
+</div>
+<div class="section" id="id139">
+<h5><a class="toc-backref" href="#id1109">Arguments:</a><a class="headerlink" href="#id139" title="Permalink to this headline">¶</a></h5>
+<p>Both arguments to the ‘<tt class="docutils literal"><span class="pre">ashr</span></tt>‘ instruction must be the same
+<a class="reference internal" href="#t-integer"><em>integer</em></a> or <a class="reference internal" href="#t-vector"><em>vector</em></a> of integer type.
+‘<tt class="docutils literal"><span class="pre">op2</span></tt>‘ is treated as an unsigned value.</p>
+</div>
+<div class="section" id="id140">
+<h5><a class="toc-backref" href="#id1110">Semantics:</a><a class="headerlink" href="#id140" title="Permalink to this headline">¶</a></h5>
+<p>This instruction always performs an arithmetic shift right operation,
+The most significant bits of the result will be filled with the sign bit
+of <tt class="docutils literal"><span class="pre">op1</span></tt>. If <tt class="docutils literal"><span class="pre">op2</span></tt> is (statically or dynamically) equal to or larger
+than the number of bits in <tt class="docutils literal"><span class="pre">op1</span></tt>, this instruction returns a <a class="reference internal" href="#poisonvalues"><em>poison
+value</em></a>. If the arguments are vectors, each vector element
+of <tt class="docutils literal"><span class="pre">op1</span></tt> is shifted by the corresponding shift amount in <tt class="docutils literal"><span class="pre">op2</span></tt>.</p>
+<p>If the <tt class="docutils literal"><span class="pre">exact</span></tt> keyword is present, the result value of the <tt class="docutils literal"><span class="pre">ashr</span></tt> is
+a poison value if any of the bits shifted out are non-zero.</p>
+</div>
+<div class="section" id="id141">
+<h5><a class="toc-backref" href="#id1111">Example:</a><a class="headerlink" href="#id141" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre><result> = ashr i32 4, 1   ; yields i32:result = 2
+<result> = ashr i32 4, 2   ; yields i32:result = 1
+<result> = ashr i8  4, 3   ; yields i8:result = 0
+<result> = ashr i8 -2, 1   ; yields i8:result = -1
+<result> = ashr i32 1, 32  ; undefined
+<result> = ashr <2 x i32> < i32 -2, i32 4>, < i32 1, i32 3>   ; yields: result=<2 x i32> < i32 -1, i32 0>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="and-instruction">
+<h4><a class="toc-backref" href="#id1112">‘<tt class="docutils literal"><span class="pre">and</span></tt>‘ Instruction</a><a class="headerlink" href="#and-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id142">
+<h5><a class="toc-backref" href="#id1113">Syntax:</a><a class="headerlink" href="#id142" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = and <ty> <op1>, <op2>   ; yields ty:result</pre>
+</div>
+</div>
+<div class="section" id="id143">
+<h5><a class="toc-backref" href="#id1114">Overview:</a><a class="headerlink" href="#id143" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">and</span></tt>‘ instruction returns the bitwise logical and of its two
+operands.</p>
+</div>
+<div class="section" id="id144">
+<h5><a class="toc-backref" href="#id1115">Arguments:</a><a class="headerlink" href="#id144" title="Permalink to this headline">¶</a></h5>
+<p>The two arguments to the ‘<tt class="docutils literal"><span class="pre">and</span></tt>‘ instruction must be
+<a class="reference internal" href="#t-integer"><em>integer</em></a> or <a class="reference internal" href="#t-vector"><em>vector</em></a> of integer values. Both
+arguments must have identical types.</p>
+</div>
+<div class="section" id="id145">
+<h5><a class="toc-backref" href="#id1116">Semantics:</a><a class="headerlink" href="#id145" title="Permalink to this headline">¶</a></h5>
+<p>The truth table used for the ‘<tt class="docutils literal"><span class="pre">and</span></tt>‘ instruction is:</p>
+<table border="1" class="docutils">
+<colgroup>
+<col width="33%" />
+<col width="33%" />
+<col width="33%" />
+</colgroup>
+<tbody valign="top">
+<tr class="row-odd"><td>In0</td>
+<td>In1</td>
+<td>Out</td>
+</tr>
+<tr class="row-even"><td>0</td>
+<td>0</td>
+<td>0</td>
+</tr>
+<tr class="row-odd"><td>0</td>
+<td>1</td>
+<td>0</td>
+</tr>
+<tr class="row-even"><td>1</td>
+<td>0</td>
+<td>0</td>
+</tr>
+<tr class="row-odd"><td>1</td>
+<td>1</td>
+<td>1</td>
+</tr>
+</tbody>
+</table>
+</div>
+<div class="section" id="id146">
+<h5><a class="toc-backref" href="#id1117">Example:</a><a class="headerlink" href="#id146" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre><result> = and i32 4, %var         ; yields i32:result = 4 & %var
+<result> = and i32 15, 40          ; yields i32:result = 8
+<result> = and i32 4, 8            ; yields i32:result = 0
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="or-instruction">
+<h4><a class="toc-backref" href="#id1118">‘<tt class="docutils literal"><span class="pre">or</span></tt>‘ Instruction</a><a class="headerlink" href="#or-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id147">
+<h5><a class="toc-backref" href="#id1119">Syntax:</a><a class="headerlink" href="#id147" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = or <ty> <op1>, <op2>   ; yields ty:result</pre>
+</div>
+</div>
+<div class="section" id="id148">
+<h5><a class="toc-backref" href="#id1120">Overview:</a><a class="headerlink" href="#id148" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">or</span></tt>‘ instruction returns the bitwise logical inclusive or of its
+two operands.</p>
+</div>
+<div class="section" id="id149">
+<h5><a class="toc-backref" href="#id1121">Arguments:</a><a class="headerlink" href="#id149" title="Permalink to this headline">¶</a></h5>
+<p>The two arguments to the ‘<tt class="docutils literal"><span class="pre">or</span></tt>‘ instruction must be
+<a class="reference internal" href="#t-integer"><em>integer</em></a> or <a class="reference internal" href="#t-vector"><em>vector</em></a> of integer values. Both
+arguments must have identical types.</p>
+</div>
+<div class="section" id="id150">
+<h5><a class="toc-backref" href="#id1122">Semantics:</a><a class="headerlink" href="#id150" title="Permalink to this headline">¶</a></h5>
+<p>The truth table used for the ‘<tt class="docutils literal"><span class="pre">or</span></tt>‘ instruction is:</p>
+<table border="1" class="docutils">
+<colgroup>
+<col width="33%" />
+<col width="33%" />
+<col width="33%" />
+</colgroup>
+<tbody valign="top">
+<tr class="row-odd"><td>In0</td>
+<td>In1</td>
+<td>Out</td>
+</tr>
+<tr class="row-even"><td>0</td>
+<td>0</td>
+<td>0</td>
+</tr>
+<tr class="row-odd"><td>0</td>
+<td>1</td>
+<td>1</td>
+</tr>
+<tr class="row-even"><td>1</td>
+<td>0</td>
+<td>1</td>
+</tr>
+<tr class="row-odd"><td>1</td>
+<td>1</td>
+<td>1</td>
+</tr>
+</tbody>
+</table>
+</div>
+<div class="section" id="id151">
+<h5><a class="toc-backref" href="#id1123">Example:</a><a class="headerlink" href="#id151" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = or i32 4, %var         ; yields i32:result = 4 | %var
+<result> = or i32 15, 40          ; yields i32:result = 47
+<result> = or i32 4, 8            ; yields i32:result = 12</pre>
+</div>
+</div>
+</div>
+<div class="section" id="xor-instruction">
+<h4><a class="toc-backref" href="#id1124">‘<tt class="docutils literal"><span class="pre">xor</span></tt>‘ Instruction</a><a class="headerlink" href="#xor-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id152">
+<h5><a class="toc-backref" href="#id1125">Syntax:</a><a class="headerlink" href="#id152" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = xor <ty> <op1>, <op2>   ; yields ty:result</pre>
+</div>
+</div>
+<div class="section" id="id153">
+<h5><a class="toc-backref" href="#id1126">Overview:</a><a class="headerlink" href="#id153" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">xor</span></tt>‘ instruction returns the bitwise logical exclusive or of
+its two operands. The <tt class="docutils literal"><span class="pre">xor</span></tt> is used to implement the “one’s
+complement” operation, which is the “~” operator in C.</p>
+</div>
+<div class="section" id="id154">
+<h5><a class="toc-backref" href="#id1127">Arguments:</a><a class="headerlink" href="#id154" title="Permalink to this headline">¶</a></h5>
+<p>The two arguments to the ‘<tt class="docutils literal"><span class="pre">xor</span></tt>‘ instruction must be
+<a class="reference internal" href="#t-integer"><em>integer</em></a> or <a class="reference internal" href="#t-vector"><em>vector</em></a> of integer values. Both
+arguments must have identical types.</p>
+</div>
+<div class="section" id="id155">
+<h5><a class="toc-backref" href="#id1128">Semantics:</a><a class="headerlink" href="#id155" title="Permalink to this headline">¶</a></h5>
+<p>The truth table used for the ‘<tt class="docutils literal"><span class="pre">xor</span></tt>‘ instruction is:</p>
+<table border="1" class="docutils">
+<colgroup>
+<col width="33%" />
+<col width="33%" />
+<col width="33%" />
+</colgroup>
+<tbody valign="top">
+<tr class="row-odd"><td>In0</td>
+<td>In1</td>
+<td>Out</td>
+</tr>
+<tr class="row-even"><td>0</td>
+<td>0</td>
+<td>0</td>
+</tr>
+<tr class="row-odd"><td>0</td>
+<td>1</td>
+<td>1</td>
+</tr>
+<tr class="row-even"><td>1</td>
+<td>0</td>
+<td>1</td>
+</tr>
+<tr class="row-odd"><td>1</td>
+<td>1</td>
+<td>0</td>
+</tr>
+</tbody>
+</table>
+</div>
+<div class="section" id="id156">
+<h5><a class="toc-backref" href="#id1129">Example:</a><a class="headerlink" href="#id156" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre><result> = xor i32 4, %var         ; yields i32:result = 4 ^ %var
+<result> = xor i32 15, 40          ; yields i32:result = 39
+<result> = xor i32 4, 8            ; yields i32:result = 12
+<result> = xor i32 %V, -1          ; yields i32:result = ~%V
+</pre></div>
+</div>
+</div>
+</div>
+</div>
+<div class="section" id="vector-operations">
+<h3><a class="toc-backref" href="#id1130">Vector Operations</a><a class="headerlink" href="#vector-operations" title="Permalink to this headline">¶</a></h3>
+<p>LLVM supports several instructions to represent vector operations in a
+target-independent manner. These instructions cover the element-access
+and vector-specific operations needed to process vectors effectively.
+While LLVM does directly support these vector operations, many
+sophisticated algorithms will want to use target-specific intrinsics to
+take full advantage of a specific target.</p>
+<div class="section" id="extractelement-instruction">
+<span id="i-extractelement"></span><h4><a class="toc-backref" href="#id1131">‘<tt class="docutils literal"><span class="pre">extractelement</span></tt>‘ Instruction</a><a class="headerlink" href="#extractelement-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id157">
+<h5><a class="toc-backref" href="#id1132">Syntax:</a><a class="headerlink" href="#id157" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = extractelement <n x <ty>> <val>, <ty2> <idx>  ; yields <ty></pre>
+</div>
+</div>
+<div class="section" id="id158">
+<h5><a class="toc-backref" href="#id1133">Overview:</a><a class="headerlink" href="#id158" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">extractelement</span></tt>‘ instruction extracts a single scalar element
+from a vector at a specified index.</p>
+</div>
+<div class="section" id="id159">
+<h5><a class="toc-backref" href="#id1134">Arguments:</a><a class="headerlink" href="#id159" title="Permalink to this headline">¶</a></h5>
+<p>The first operand of an ‘<tt class="docutils literal"><span class="pre">extractelement</span></tt>‘ instruction is a value of
+<a class="reference internal" href="#t-vector"><em>vector</em></a> type. The second operand is an index indicating
+the position from which to extract the element. The index may be a
+variable of any integer type.</p>
+</div>
+<div class="section" id="id160">
+<h5><a class="toc-backref" href="#id1135">Semantics:</a><a class="headerlink" href="#id160" title="Permalink to this headline">¶</a></h5>
+<p>The result is a scalar of the same type as the element type of <tt class="docutils literal"><span class="pre">val</span></tt>.
+Its value is the value at position <tt class="docutils literal"><span class="pre">idx</span></tt> of <tt class="docutils literal"><span class="pre">val</span></tt>. If <tt class="docutils literal"><span class="pre">idx</span></tt>
+exceeds the length of <tt class="docutils literal"><span class="pre">val</span></tt>, the results are undefined.</p>
+</div>
+<div class="section" id="id161">
+<h5><a class="toc-backref" href="#id1136">Example:</a><a class="headerlink" href="#id161" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre><result> = extractelement <4 x i32> %vec, i32 0    ; yields i32
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="insertelement-instruction">
+<span id="i-insertelement"></span><h4><a class="toc-backref" href="#id1137">‘<tt class="docutils literal"><span class="pre">insertelement</span></tt>‘ Instruction</a><a class="headerlink" href="#insertelement-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id162">
+<h5><a class="toc-backref" href="#id1138">Syntax:</a><a class="headerlink" href="#id162" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = insertelement <n x <ty>> <val>, <ty> <elt>, <ty2> <idx>    ; yields <n x <ty>></pre>
+</div>
+</div>
+<div class="section" id="id163">
+<h5><a class="toc-backref" href="#id1139">Overview:</a><a class="headerlink" href="#id163" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">insertelement</span></tt>‘ instruction inserts a scalar element into a
+vector at a specified index.</p>
+</div>
+<div class="section" id="id164">
+<h5><a class="toc-backref" href="#id1140">Arguments:</a><a class="headerlink" href="#id164" title="Permalink to this headline">¶</a></h5>
+<p>The first operand of an ‘<tt class="docutils literal"><span class="pre">insertelement</span></tt>‘ instruction is a value of
+<a class="reference internal" href="#t-vector"><em>vector</em></a> type. The second operand is a scalar value whose
+type must equal the element type of the first operand. The third operand
+is an index indicating the position at which to insert the value. The
+index may be a variable of any integer type.</p>
+</div>
+<div class="section" id="id165">
+<h5><a class="toc-backref" href="#id1141">Semantics:</a><a class="headerlink" href="#id165" title="Permalink to this headline">¶</a></h5>
+<p>The result is a vector of the same type as <tt class="docutils literal"><span class="pre">val</span></tt>. Its element values
+are those of <tt class="docutils literal"><span class="pre">val</span></tt> except at position <tt class="docutils literal"><span class="pre">idx</span></tt>, where it gets the value
+<tt class="docutils literal"><span class="pre">elt</span></tt>. If <tt class="docutils literal"><span class="pre">idx</span></tt> exceeds the length of <tt class="docutils literal"><span class="pre">val</span></tt>, the results are
+undefined.</p>
+</div>
+<div class="section" id="id166">
+<h5><a class="toc-backref" href="#id1142">Example:</a><a class="headerlink" href="#id166" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre><result> = insertelement <4 x i32> %vec, i32 1, i32 0    ; yields <4 x i32>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="shufflevector-instruction">
+<span id="i-shufflevector"></span><h4><a class="toc-backref" href="#id1143">‘<tt class="docutils literal"><span class="pre">shufflevector</span></tt>‘ Instruction</a><a class="headerlink" href="#shufflevector-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id167">
+<h5><a class="toc-backref" href="#id1144">Syntax:</a><a class="headerlink" href="#id167" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = shufflevector <n x <ty>> <v1>, <n x <ty>> <v2>, <m x i32> <mask>    ; yields <m x <ty>></pre>
+</div>
+</div>
+<div class="section" id="id168">
+<h5><a class="toc-backref" href="#id1145">Overview:</a><a class="headerlink" href="#id168" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">shufflevector</span></tt>‘ instruction constructs a permutation of elements
+from two input vectors, returning a vector with the same element type as
+the input and length that is the same as the shuffle mask.</p>
+</div>
+<div class="section" id="id169">
+<h5><a class="toc-backref" href="#id1146">Arguments:</a><a class="headerlink" href="#id169" title="Permalink to this headline">¶</a></h5>
+<p>The first two operands of a ‘<tt class="docutils literal"><span class="pre">shufflevector</span></tt>‘ instruction are vectors
+with the same type. The third argument is a shuffle mask whose element
+type is always ‘i32’. The result of the instruction is a vector whose
+length is the same as the shuffle mask and whose element type is the
+same as the element type of the first two operands.</p>
+<p>The shuffle mask operand is required to be a constant vector with either
+constant integer or undef values.</p>
+</div>
+<div class="section" id="id170">
+<h5><a class="toc-backref" href="#id1147">Semantics:</a><a class="headerlink" href="#id170" title="Permalink to this headline">¶</a></h5>
+<p>The elements of the two input vectors are numbered from left to right
+across both of the vectors. The shuffle mask operand specifies, for each
+element of the result vector, which element of the two input vectors the
+result element gets. If the shuffle mask is undef, the result vector is
+undef. If any element of the mask operand is undef, that element of the
+result is undef. If the shuffle mask selects an undef element from one
+of the input vectors, the resulting element is undef.</p>
+</div>
+<div class="section" id="id171">
+<h5><a class="toc-backref" href="#id1148">Example:</a><a class="headerlink" href="#id171" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre><result> = shufflevector <4 x i32> %v1, <4 x i32> %v2,
+                        <4 x i32> <i32 0, i32 4, i32 1, i32 5>  ; yields <4 x i32>
+<result> = shufflevector <4 x i32> %v1, <4 x i32> undef,
+                        <4 x i32> <i32 0, i32 1, i32 2, i32 3>  ; yields <4 x i32> - Identity shuffle.
+<result> = shufflevector <8 x i32> %v1, <8 x i32> undef,
+                        <4 x i32> <i32 0, i32 1, i32 2, i32 3>  ; yields <4 x i32>
+<result> = shufflevector <4 x i32> %v1, <4 x i32> %v2,
+                        <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7 >  ; yields <8 x i32>
+</pre></div>
+</div>
+</div>
+</div>
+</div>
+<div class="section" id="aggregate-operations">
+<h3><a class="toc-backref" href="#id1149">Aggregate Operations</a><a class="headerlink" href="#aggregate-operations" title="Permalink to this headline">¶</a></h3>
+<p>LLVM supports several instructions for working with
+<a class="reference internal" href="#t-aggregate"><em>aggregate</em></a> values.</p>
+<div class="section" id="extractvalue-instruction">
+<span id="i-extractvalue"></span><h4><a class="toc-backref" href="#id1150">‘<tt class="docutils literal"><span class="pre">extractvalue</span></tt>‘ Instruction</a><a class="headerlink" href="#extractvalue-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id172">
+<h5><a class="toc-backref" href="#id1151">Syntax:</a><a class="headerlink" href="#id172" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = extractvalue <aggregate type> <val>, <idx>{, <idx>}*</pre>
+</div>
+</div>
+<div class="section" id="id173">
+<h5><a class="toc-backref" href="#id1152">Overview:</a><a class="headerlink" href="#id173" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">extractvalue</span></tt>‘ instruction extracts the value of a member field
+from an <a class="reference internal" href="#t-aggregate"><em>aggregate</em></a> value.</p>
+</div>
+<div class="section" id="id174">
+<h5><a class="toc-backref" href="#id1153">Arguments:</a><a class="headerlink" href="#id174" title="Permalink to this headline">¶</a></h5>
+<p>The first operand of an ‘<tt class="docutils literal"><span class="pre">extractvalue</span></tt>‘ instruction is a value of
+<a class="reference internal" href="#t-struct"><em>struct</em></a> or <a class="reference internal" href="#t-array"><em>array</em></a> type. The other operands are
+constant indices to specify which value to extract in a similar manner
+as indices in a ‘<tt class="docutils literal"><span class="pre">getelementptr</span></tt>‘ instruction.</p>
+<p>The major differences to <tt class="docutils literal"><span class="pre">getelementptr</span></tt> indexing are:</p>
+<ul class="simple">
+<li>Since the value being indexed is not a pointer, the first index is
+omitted and assumed to be zero.</li>
+<li>At least one index must be specified.</li>
+<li>Not only struct indices but also array indices must be in bounds.</li>
+</ul>
+</div>
+<div class="section" id="id175">
+<h5><a class="toc-backref" href="#id1154">Semantics:</a><a class="headerlink" href="#id175" title="Permalink to this headline">¶</a></h5>
+<p>The result is the value at the position in the aggregate specified by
+the index operands.</p>
+</div>
+<div class="section" id="id176">
+<h5><a class="toc-backref" href="#id1155">Example:</a><a class="headerlink" href="#id176" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre><result> = extractvalue {i32, float} %agg, 0    ; yields i32
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="insertvalue-instruction">
+<span id="i-insertvalue"></span><h4><a class="toc-backref" href="#id1156">‘<tt class="docutils literal"><span class="pre">insertvalue</span></tt>‘ Instruction</a><a class="headerlink" href="#insertvalue-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id177">
+<h5><a class="toc-backref" href="#id1157">Syntax:</a><a class="headerlink" href="#id177" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = insertvalue <aggregate type> <val>, <ty> <elt>, <idx>{, <idx>}*    ; yields <aggregate type></pre>
+</div>
+</div>
+<div class="section" id="id178">
+<h5><a class="toc-backref" href="#id1158">Overview:</a><a class="headerlink" href="#id178" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">insertvalue</span></tt>‘ instruction inserts a value into a member field in
+an <a class="reference internal" href="#t-aggregate"><em>aggregate</em></a> value.</p>
+</div>
+<div class="section" id="id179">
+<h5><a class="toc-backref" href="#id1159">Arguments:</a><a class="headerlink" href="#id179" title="Permalink to this headline">¶</a></h5>
+<p>The first operand of an ‘<tt class="docutils literal"><span class="pre">insertvalue</span></tt>‘ instruction is a value of
+<a class="reference internal" href="#t-struct"><em>struct</em></a> or <a class="reference internal" href="#t-array"><em>array</em></a> type. The second operand is
+a first-class value to insert. The following operands are constant
+indices indicating the position at which to insert the value in a
+similar manner as indices in a ‘<tt class="docutils literal"><span class="pre">extractvalue</span></tt>‘ instruction. The value
+to insert must have the same type as the value identified by the
+indices.</p>
+</div>
+<div class="section" id="id180">
+<h5><a class="toc-backref" href="#id1160">Semantics:</a><a class="headerlink" href="#id180" title="Permalink to this headline">¶</a></h5>
+<p>The result is an aggregate of the same type as <tt class="docutils literal"><span class="pre">val</span></tt>. Its value is
+that of <tt class="docutils literal"><span class="pre">val</span></tt> except that the value at the position specified by the
+indices is that of <tt class="docutils literal"><span class="pre">elt</span></tt>.</p>
+</div>
+<div class="section" id="id181">
+<h5><a class="toc-backref" href="#id1161">Example:</a><a class="headerlink" href="#id181" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%agg1</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="kt">float</span><span class="p">}</span> <span class="k">undef</span><span class="p">,</span> <span class="k">i32</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span>              <span class="c">; yields {i32 1, float undef}</span>
+<span class="nv">%agg2</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="kt">float</span><span class="p">}</span> <span class="nv">%agg1</span><span class="p">,</span> <span class="kt">float</span> <span class="nv">%val</span><span class="p">,</span> <span class="m">1</span>         <span class="c">; yields {i32 1, float %val}</span>
+<span class="nv">%agg3</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="p">{</span><span class="kt">float</span><span class="p">}}</span> <span class="k">undef</span><span class="p">,</span> <span class="kt">float</span> <span class="nv">%val</span><span class="p">,</span> <span class="m">1</span><span class="p">,</span> <span class="m">0</span>    <span class="c">; yields {i32 undef, {float %val}}</span>
+</pre></div>
+</div>
+</div>
+</div>
+</div>
+<div class="section" id="memory-access-and-addressing-operations">
+<span id="memoryops"></span><h3><a class="toc-backref" href="#id1162">Memory Access and Addressing Operations</a><a class="headerlink" href="#memory-access-and-addressing-operations" title="Permalink to this headline">¶</a></h3>
+<p>A key design point of an SSA-based representation is how it represents
+memory. In LLVM, no memory locations are in SSA form, which makes things
+very simple. This section describes how to read, write, and allocate
+memory in LLVM.</p>
+<div class="section" id="alloca-instruction">
+<span id="i-alloca"></span><h4><a class="toc-backref" href="#id1163">‘<tt class="docutils literal"><span class="pre">alloca</span></tt>‘ Instruction</a><a class="headerlink" href="#alloca-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id182">
+<h5><a class="toc-backref" href="#id1164">Syntax:</a><a class="headerlink" href="#id182" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = alloca [inalloca] <type> [, <ty> <NumElements>] [, align <alignment>] [, addrspace(<num>)]     ; yields type addrspace(num)*:result</pre>
+</div>
+</div>
+<div class="section" id="id183">
+<h5><a class="toc-backref" href="#id1165">Overview:</a><a class="headerlink" href="#id183" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">alloca</span></tt>‘ instruction allocates memory on the stack frame of the
+currently executing function, to be automatically released when this
+function returns to its caller. The object is always allocated in the
+address space for allocas indicated in the datalayout.</p>
+</div>
+<div class="section" id="id184">
+<h5><a class="toc-backref" href="#id1166">Arguments:</a><a class="headerlink" href="#id184" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">alloca</span></tt>‘ instruction allocates <tt class="docutils literal"><span class="pre">sizeof(<type>)*NumElements</span></tt>
+bytes of memory on the runtime stack, returning a pointer of the
+appropriate type to the program. If “NumElements” is specified, it is
+the number of elements allocated, otherwise “NumElements” is defaulted
+to be one. If a constant alignment is specified, the value result of the
+allocation is guaranteed to be aligned to at least that boundary. The
+alignment may not be greater than <tt class="docutils literal"><span class="pre">1</span> <span class="pre"><<</span> <span class="pre">29</span></tt>. If not specified, or if
+zero, the target can choose to align the allocation on any convenient
+boundary compatible with the type.</p>
+<p>‘<tt class="docutils literal"><span class="pre">type</span></tt>‘ may be any sized type.</p>
+</div>
+<div class="section" id="id185">
+<h5><a class="toc-backref" href="#id1167">Semantics:</a><a class="headerlink" href="#id185" title="Permalink to this headline">¶</a></h5>
+<p>Memory is allocated; a pointer is returned. The operation is undefined
+if there is insufficient stack space for the allocation. ‘<tt class="docutils literal"><span class="pre">alloca</span></tt>‘d
+memory is automatically released when the function returns. The
+‘<tt class="docutils literal"><span class="pre">alloca</span></tt>‘ instruction is commonly used to represent automatic
+variables that must have an address available. When the function returns
+(either with the <tt class="docutils literal"><span class="pre">ret</span></tt> or <tt class="docutils literal"><span class="pre">resume</span></tt> instructions), the memory is
+reclaimed. Allocating zero bytes is legal, but the result is undefined.
+The order in which memory is allocated (ie., which way the stack grows)
+is not specified.</p>
+</div>
+<div class="section" id="id186">
+<h5><a class="toc-backref" href="#id1168">Example:</a><a class="headerlink" href="#id186" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%ptr</span> <span class="p">=</span> <span class="k">alloca</span> <span class="k">i32</span>                             <span class="c">; yields i32*:ptr</span>
+<span class="nv">%ptr</span> <span class="p">=</span> <span class="k">alloca</span> <span class="k">i32</span><span class="p">,</span> <span class="k">i32</span> <span class="m">4</span>                      <span class="c">; yields i32*:ptr</span>
+<span class="nv">%ptr</span> <span class="p">=</span> <span class="k">alloca</span> <span class="k">i32</span><span class="p">,</span> <span class="k">i32</span> <span class="m">4</span><span class="p">,</span> <span class="k">align</span> <span class="m">1024</span>          <span class="c">; yields i32*:ptr</span>
+<span class="nv">%ptr</span> <span class="p">=</span> <span class="k">alloca</span> <span class="k">i32</span><span class="p">,</span> <span class="k">align</span> <span class="m">1024</span>                 <span class="c">; yields i32*:ptr</span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="load-instruction">
+<span id="i-load"></span><h4><a class="toc-backref" href="#id1169">‘<tt class="docutils literal"><span class="pre">load</span></tt>‘ Instruction</a><a class="headerlink" href="#load-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id187">
+<h5><a class="toc-backref" href="#id1170">Syntax:</a><a class="headerlink" href="#id187" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = load [volatile] <ty>, <ty>* <pointer>[, align <alignment>][, !nontemporal !<index>][, !invariant.load !<index>][, !invariant.group !<index>][, !nonnull !<index>][, !dereferenceable !<deref_bytes_node>][, !dereferenceable_or_null !<deref_bytes_node>][, !align !<align_node>]
+<result> = load atomic [volatile] <ty>, <ty>* <pointer> [syncscope("<target-scope>")] <ordering>, align <alignment> [, !invariant.group !<index>]
+!<index> = !{ i32 1 }
+!<deref_bytes_node> = !{i64 <dereferenceable_bytes>}
+!<align_node> = !{ i64 <value_alignment> }</pre>
+</div>
+</div>
+<div class="section" id="id188">
+<h5><a class="toc-backref" href="#id1171">Overview:</a><a class="headerlink" href="#id188" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">load</span></tt>‘ instruction is used to read from memory.</p>
+</div>
+<div class="section" id="id189">
+<h5><a class="toc-backref" href="#id1172">Arguments:</a><a class="headerlink" href="#id189" title="Permalink to this headline">¶</a></h5>
+<p>The argument to the <tt class="docutils literal"><span class="pre">load</span></tt> instruction specifies the memory address from which
+to load. The type specified must be a <a class="reference internal" href="#t-firstclass"><em>first class</em></a> type of
+known size (i.e. not containing an <a class="reference internal" href="#t-opaque"><em>opaque structural type</em></a>). If
+the <tt class="docutils literal"><span class="pre">load</span></tt> is marked as <tt class="docutils literal"><span class="pre">volatile</span></tt>, then the optimizer is not allowed to
+modify the number or order of execution of this <tt class="docutils literal"><span class="pre">load</span></tt> with other
+<a class="reference internal" href="#volatile"><em>volatile operations</em></a>.</p>
+<p>If the <tt class="docutils literal"><span class="pre">load</span></tt> is marked as <tt class="docutils literal"><span class="pre">atomic</span></tt>, it takes an extra <a class="reference internal" href="#ordering"><em>ordering</em></a> and optional <tt class="docutils literal"><span class="pre">syncscope("<target-scope>")</span></tt> argument. The
+<tt class="docutils literal"><span class="pre">release</span></tt> and <tt class="docutils literal"><span class="pre">acq_rel</span></tt> orderings are not valid on <tt class="docutils literal"><span class="pre">load</span></tt> instructions.
+Atomic loads produce <a class="reference internal" href="#memmodel"><em>defined</em></a> results when they may see
+multiple atomic stores. The type of the pointee must be an integer, pointer, or
+floating-point type whose bit width is a power of two greater than or equal to
+eight and less than or equal to a target-specific size limit.  <tt class="docutils literal"><span class="pre">align</span></tt> must be
+explicitly specified on atomic loads, and the load has undefined behavior if the
+alignment is not set to a value which is at least the size in bytes of the
+pointee. <tt class="docutils literal"><span class="pre">!nontemporal</span></tt> does not have any defined semantics for atomic loads.</p>
+<p>The optional constant <tt class="docutils literal"><span class="pre">align</span></tt> argument specifies the alignment of the
+operation (that is, the alignment of the memory address). A value of 0
+or an omitted <tt class="docutils literal"><span class="pre">align</span></tt> argument means that the operation has the ABI
+alignment for the target. It is the responsibility of the code emitter
+to ensure that the alignment information is correct. Overestimating the
+alignment results in undefined behavior. Underestimating the alignment
+may produce less efficient code. An alignment of 1 is always safe. The
+maximum possible alignment is <tt class="docutils literal"><span class="pre">1</span> <span class="pre"><<</span> <span class="pre">29</span></tt>. An alignment value higher
+than the size of the loaded type implies memory up to the alignment
+value bytes can be safely loaded without trapping in the default
+address space. Access of the high bytes can interfere with debugging
+tools, so should not be accessed if the function has the
+<tt class="docutils literal"><span class="pre">sanitize_thread</span></tt> or <tt class="docutils literal"><span class="pre">sanitize_address</span></tt> attributes.</p>
+<p>The optional <tt class="docutils literal"><span class="pre">!nontemporal</span></tt> metadata must reference a single
+metadata name <tt class="docutils literal"><span class="pre"><index></span></tt> corresponding to a metadata node with one
+<tt class="docutils literal"><span class="pre">i32</span></tt> entry of value 1. The existence of the <tt class="docutils literal"><span class="pre">!nontemporal</span></tt>
+metadata on the instruction tells the optimizer and code generator
+that this load is not expected to be reused in the cache. The code
+generator may select special instructions to save cache bandwidth, such
+as the <tt class="docutils literal"><span class="pre">MOVNT</span></tt> instruction on x86.</p>
+<p>The optional <tt class="docutils literal"><span class="pre">!invariant.load</span></tt> metadata must reference a single
+metadata name <tt class="docutils literal"><span class="pre"><index></span></tt> corresponding to a metadata node with no
+entries. If a load instruction tagged with the <tt class="docutils literal"><span class="pre">!invariant.load</span></tt>
+metadata is executed, the optimizer may assume the memory location
+referenced by the load contains the same value at all points in the
+program where the memory location is known to be dereferenceable.</p>
+<dl class="docutils">
+<dt>The optional <tt class="docutils literal"><span class="pre">!invariant.group</span></tt> metadata must reference a single metadata name</dt>
+<dd><tt class="docutils literal"><span class="pre"><index></span></tt> corresponding to a metadata node. See <tt class="docutils literal"><span class="pre">invariant.group</span></tt> metadata.</dd>
+</dl>
+<p>The optional <tt class="docutils literal"><span class="pre">!nonnull</span></tt> metadata must reference a single
+metadata name <tt class="docutils literal"><span class="pre"><index></span></tt> corresponding to a metadata node with no
+entries. The existence of the <tt class="docutils literal"><span class="pre">!nonnull</span></tt> metadata on the
+instruction tells the optimizer that the value loaded is known to
+never be null. This is analogous to the <tt class="docutils literal"><span class="pre">nonnull</span></tt> attribute
+on parameters and return values. This metadata can only be applied
+to loads of a pointer type.</p>
+<p>The optional <tt class="docutils literal"><span class="pre">!dereferenceable</span></tt> metadata must reference a single metadata
+name <tt class="docutils literal"><span class="pre"><deref_bytes_node></span></tt> corresponding to a metadata node with one <tt class="docutils literal"><span class="pre">i64</span></tt>
+entry. The existence of the <tt class="docutils literal"><span class="pre">!dereferenceable</span></tt> metadata on the instruction
+tells the optimizer that the value loaded is known to be dereferenceable.
+The number of bytes known to be dereferenceable is specified by the integer
+value in the metadata node. This is analogous to the ‘’dereferenceable’’
+attribute on parameters and return values. This metadata can only be applied
+to loads of a pointer type.</p>
+<p>The optional <tt class="docutils literal"><span class="pre">!dereferenceable_or_null</span></tt> metadata must reference a single
+metadata name <tt class="docutils literal"><span class="pre"><deref_bytes_node></span></tt> corresponding to a metadata node with one
+<tt class="docutils literal"><span class="pre">i64</span></tt> entry. The existence of the <tt class="docutils literal"><span class="pre">!dereferenceable_or_null</span></tt> metadata on the
+instruction tells the optimizer that the value loaded is known to be either
+dereferenceable or null.
+The number of bytes known to be dereferenceable is specified by the integer
+value in the metadata node. This is analogous to the ‘’dereferenceable_or_null’’
+attribute on parameters and return values. This metadata can only be applied
+to loads of a pointer type.</p>
+<p>The optional <tt class="docutils literal"><span class="pre">!align</span></tt> metadata must reference a single metadata name
+<tt class="docutils literal"><span class="pre"><align_node></span></tt> corresponding to a metadata node with one <tt class="docutils literal"><span class="pre">i64</span></tt> entry.
+The existence of the <tt class="docutils literal"><span class="pre">!align</span></tt> metadata on the instruction tells the
+optimizer that the value loaded is known to be aligned to a boundary specified
+by the integer value in the metadata node. The alignment must be a power of 2.
+This is analogous to the ‘’align’’ attribute on parameters and return values.
+This metadata can only be applied to loads of a pointer type.</p>
+</div>
+<div class="section" id="id190">
+<h5><a class="toc-backref" href="#id1173">Semantics:</a><a class="headerlink" href="#id190" title="Permalink to this headline">¶</a></h5>
+<p>The location of memory pointed to is loaded. If the value being loaded
+is of scalar type then the number of bytes read does not exceed the
+minimum number of bytes needed to hold all bits of the type. For
+example, loading an <tt class="docutils literal"><span class="pre">i24</span></tt> reads at most three bytes. When loading a
+value of a type like <tt class="docutils literal"><span class="pre">i20</span></tt> with a size that is not an integral number
+of bytes, the result is undefined if the value was not originally
+written using a store of the same type.</p>
+</div>
+<div class="section" id="id191">
+<h5><a class="toc-backref" href="#id1174">Examples:</a><a class="headerlink" href="#id191" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%ptr</span> <span class="p">=</span> <span class="k">alloca</span> <span class="k">i32</span>                               <span class="c">; yields i32*:ptr</span>
+<span class="k">store</span> <span class="k">i32</span> <span class="m">3</span><span class="p">,</span> <span class="k">i32</span><span class="p">*</span> <span class="nv">%ptr</span>                          <span class="c">; yields void</span>
+<span class="nv">%val</span> <span class="p">=</span> <span class="k">load</span> <span class="k">i32</span><span class="p">,</span> <span class="k">i32</span><span class="p">*</span> <span class="nv">%ptr</span>                      <span class="c">; yields i32:val = i32 3</span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="store-instruction">
+<span id="i-store"></span><h4><a class="toc-backref" href="#id1175">‘<tt class="docutils literal"><span class="pre">store</span></tt>‘ Instruction</a><a class="headerlink" href="#store-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id192">
+<h5><a class="toc-backref" href="#id1176">Syntax:</a><a class="headerlink" href="#id192" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>store [volatile] <ty> <value>, <ty>* <pointer>[, align <alignment>][, !nontemporal !<index>][, !invariant.group !<index>]        ; yields void
+store atomic [volatile] <ty> <value>, <ty>* <pointer> [syncscope("<target-scope>")] <ordering>, align <alignment> [, !invariant.group !<index>] ; yields void</pre>
+</div>
+</div>
+<div class="section" id="id193">
+<h5><a class="toc-backref" href="#id1177">Overview:</a><a class="headerlink" href="#id193" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">store</span></tt>‘ instruction is used to write to memory.</p>
+</div>
+<div class="section" id="id194">
+<h5><a class="toc-backref" href="#id1178">Arguments:</a><a class="headerlink" href="#id194" title="Permalink to this headline">¶</a></h5>
+<p>There are two arguments to the <tt class="docutils literal"><span class="pre">store</span></tt> instruction: a value to store and an
+address at which to store it. The type of the <tt class="docutils literal"><span class="pre"><pointer></span></tt> operand must be a
+pointer to the <a class="reference internal" href="#t-firstclass"><em>first class</em></a> type of the <tt class="docutils literal"><span class="pre"><value></span></tt>
+operand. If the <tt class="docutils literal"><span class="pre">store</span></tt> is marked as <tt class="docutils literal"><span class="pre">volatile</span></tt>, then the optimizer is not
+allowed to modify the number or order of execution of this <tt class="docutils literal"><span class="pre">store</span></tt> with other
+<a class="reference internal" href="#volatile"><em>volatile operations</em></a>.  Only values of <a class="reference internal" href="#t-firstclass"><em>first class</em></a> types of known size (i.e. not containing an <a class="reference internal" href="#t-opaque"><em>opaque
+structural type</em></a>) can be stored.</p>
+<p>If the <tt class="docutils literal"><span class="pre">store</span></tt> is marked as <tt class="docutils literal"><span class="pre">atomic</span></tt>, it takes an extra <a class="reference internal" href="#ordering"><em>ordering</em></a> and optional <tt class="docutils literal"><span class="pre">syncscope("<target-scope>")</span></tt> argument. The
+<tt class="docutils literal"><span class="pre">acquire</span></tt> and <tt class="docutils literal"><span class="pre">acq_rel</span></tt> orderings aren’t valid on <tt class="docutils literal"><span class="pre">store</span></tt> instructions.
+Atomic loads produce <a class="reference internal" href="#memmodel"><em>defined</em></a> results when they may see
+multiple atomic stores. The type of the pointee must be an integer, pointer, or
+floating-point type whose bit width is a power of two greater than or equal to
+eight and less than or equal to a target-specific size limit.  <tt class="docutils literal"><span class="pre">align</span></tt> must be
+explicitly specified on atomic stores, and the store has undefined behavior if
+the alignment is not set to a value which is at least the size in bytes of the
+pointee. <tt class="docutils literal"><span class="pre">!nontemporal</span></tt> does not have any defined semantics for atomic stores.</p>
+<p>The optional constant <tt class="docutils literal"><span class="pre">align</span></tt> argument specifies the alignment of the
+operation (that is, the alignment of the memory address). A value of 0
+or an omitted <tt class="docutils literal"><span class="pre">align</span></tt> argument means that the operation has the ABI
+alignment for the target. It is the responsibility of the code emitter
+to ensure that the alignment information is correct. Overestimating the
+alignment results in undefined behavior. Underestimating the
+alignment may produce less efficient code. An alignment of 1 is always
+safe. The maximum possible alignment is <tt class="docutils literal"><span class="pre">1</span> <span class="pre"><<</span> <span class="pre">29</span></tt>. An alignment
+value higher than the size of the stored type implies memory up to the
+alignment value bytes can be stored to without trapping in the default
+address space. Storing to the higher bytes however may result in data
+races if another thread can access the same address. Introducing a
+data race is not allowed. Storing to the extra bytes is not allowed
+even in situations where a data race is known to not exist if the
+function has the <tt class="docutils literal"><span class="pre">sanitize_address</span></tt> attribute.</p>
+<p>The optional <tt class="docutils literal"><span class="pre">!nontemporal</span></tt> metadata must reference a single metadata
+name <tt class="docutils literal"><span class="pre"><index></span></tt> corresponding to a metadata node with one <tt class="docutils literal"><span class="pre">i32</span></tt> entry of
+value 1. The existence of the <tt class="docutils literal"><span class="pre">!nontemporal</span></tt> metadata on the instruction
+tells the optimizer and code generator that this load is not expected to
+be reused in the cache. The code generator may select special
+instructions to save cache bandwidth, such as the <tt class="docutils literal"><span class="pre">MOVNT</span></tt> instruction on
+x86.</p>
+<p>The optional <tt class="docutils literal"><span class="pre">!invariant.group</span></tt> metadata must reference a
+single metadata name <tt class="docutils literal"><span class="pre"><index></span></tt>. See <tt class="docutils literal"><span class="pre">invariant.group</span></tt> metadata.</p>
+</div>
+<div class="section" id="id195">
+<h5><a class="toc-backref" href="#id1179">Semantics:</a><a class="headerlink" href="#id195" title="Permalink to this headline">¶</a></h5>
+<p>The contents of memory are updated to contain <tt class="docutils literal"><span class="pre"><value></span></tt> at the
+location specified by the <tt class="docutils literal"><span class="pre"><pointer></span></tt> operand. If <tt class="docutils literal"><span class="pre"><value></span></tt> is
+of scalar type then the number of bytes written does not exceed the
+minimum number of bytes needed to hold all bits of the type. For
+example, storing an <tt class="docutils literal"><span class="pre">i24</span></tt> writes at most three bytes. When writing a
+value of a type like <tt class="docutils literal"><span class="pre">i20</span></tt> with a size that is not an integral number
+of bytes, it is unspecified what happens to the extra bits that do not
+belong to the type, but they will typically be overwritten.</p>
+</div>
+<div class="section" id="id196">
+<h5><a class="toc-backref" href="#id1180">Example:</a><a class="headerlink" href="#id196" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%ptr</span> <span class="p">=</span> <span class="k">alloca</span> <span class="k">i32</span>                               <span class="c">; yields i32*:ptr</span>
+<span class="k">store</span> <span class="k">i32</span> <span class="m">3</span><span class="p">,</span> <span class="k">i32</span><span class="p">*</span> <span class="nv">%ptr</span>                          <span class="c">; yields void</span>
+<span class="nv">%val</span> <span class="p">=</span> <span class="k">load</span> <span class="k">i32</span><span class="p">,</span> <span class="k">i32</span><span class="p">*</span> <span class="nv">%ptr</span>                      <span class="c">; yields i32:val = i32 3</span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="fence-instruction">
+<span id="i-fence"></span><h4><a class="toc-backref" href="#id1181">‘<tt class="docutils literal"><span class="pre">fence</span></tt>‘ Instruction</a><a class="headerlink" href="#fence-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id197">
+<h5><a class="toc-backref" href="#id1182">Syntax:</a><a class="headerlink" href="#id197" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>fence [syncscope("<target-scope>")] <ordering>  ; yields void</pre>
+</div>
+</div>
+<div class="section" id="id198">
+<h5><a class="toc-backref" href="#id1183">Overview:</a><a class="headerlink" href="#id198" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">fence</span></tt>‘ instruction is used to introduce happens-before edges
+between operations.</p>
+</div>
+<div class="section" id="id199">
+<h5><a class="toc-backref" href="#id1184">Arguments:</a><a class="headerlink" href="#id199" title="Permalink to this headline">¶</a></h5>
+<p>‘<tt class="docutils literal"><span class="pre">fence</span></tt>‘ instructions take an <a class="reference internal" href="#ordering"><em>ordering</em></a> argument which
+defines what <em>synchronizes-with</em> edges they add. They can only be given
+<tt class="docutils literal"><span class="pre">acquire</span></tt>, <tt class="docutils literal"><span class="pre">release</span></tt>, <tt class="docutils literal"><span class="pre">acq_rel</span></tt>, and <tt class="docutils literal"><span class="pre">seq_cst</span></tt> orderings.</p>
+</div>
+<div class="section" id="id200">
+<h5><a class="toc-backref" href="#id1185">Semantics:</a><a class="headerlink" href="#id200" title="Permalink to this headline">¶</a></h5>
+<p>A fence A which has (at least) <tt class="docutils literal"><span class="pre">release</span></tt> ordering semantics
+<em>synchronizes with</em> a fence B with (at least) <tt class="docutils literal"><span class="pre">acquire</span></tt> ordering
+semantics if and only if there exist atomic operations X and Y, both
+operating on some atomic object M, such that A is sequenced before X, X
+modifies M (either directly or through some side effect of a sequence
+headed by X), Y is sequenced before B, and Y observes M. This provides a
+<em>happens-before</em> dependency between A and B. Rather than an explicit
+<tt class="docutils literal"><span class="pre">fence</span></tt>, one (but not both) of the atomic operations X or Y might
+provide a <tt class="docutils literal"><span class="pre">release</span></tt> or <tt class="docutils literal"><span class="pre">acquire</span></tt> (resp.) ordering constraint and
+still <em>synchronize-with</em> the explicit <tt class="docutils literal"><span class="pre">fence</span></tt> and establish the
+<em>happens-before</em> edge.</p>
+<p>A <tt class="docutils literal"><span class="pre">fence</span></tt> which has <tt class="docutils literal"><span class="pre">seq_cst</span></tt> ordering, in addition to having both
+<tt class="docutils literal"><span class="pre">acquire</span></tt> and <tt class="docutils literal"><span class="pre">release</span></tt> semantics specified above, participates in
+the global program order of other <tt class="docutils literal"><span class="pre">seq_cst</span></tt> operations and/or fences.</p>
+<p>A <tt class="docutils literal"><span class="pre">fence</span></tt> instruction can also take an optional
+“<a class="reference internal" href="#syncscope"><em>syncscope</em></a>” argument.</p>
+</div>
+<div class="section" id="id201">
+<h5><a class="toc-backref" href="#id1186">Example:</a><a class="headerlink" href="#id201" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre>fence acquire                                        ; yields void
+fence syncscope("singlethread") seq_cst              ; yields void
+fence syncscope("agent") seq_cst                     ; yields void
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="cmpxchg-instruction">
+<span id="i-cmpxchg"></span><h4><a class="toc-backref" href="#id1187">‘<tt class="docutils literal"><span class="pre">cmpxchg</span></tt>‘ Instruction</a><a class="headerlink" href="#cmpxchg-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id202">
+<h5><a class="toc-backref" href="#id1188">Syntax:</a><a class="headerlink" href="#id202" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>cmpxchg [weak] [volatile] <ty>* <pointer>, <ty> <cmp>, <ty> <new> [syncscope("<target-scope>")] <success ordering> <failure ordering> ; yields  { ty, i1 }</pre>
+</div>
+</div>
+<div class="section" id="id203">
+<h5><a class="toc-backref" href="#id1189">Overview:</a><a class="headerlink" href="#id203" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">cmpxchg</span></tt>‘ instruction is used to atomically modify memory. It
+loads a value in memory and compares it to a given value. If they are
+equal, it tries to store a new value into the memory.</p>
+</div>
+<div class="section" id="id204">
+<h5><a class="toc-backref" href="#id1190">Arguments:</a><a class="headerlink" href="#id204" title="Permalink to this headline">¶</a></h5>
+<p>There are three arguments to the ‘<tt class="docutils literal"><span class="pre">cmpxchg</span></tt>‘ instruction: an address
+to operate on, a value to compare to the value currently be at that
+address, and a new value to place at that address if the compared values
+are equal. The type of ‘<cmp>’ must be an integer or pointer type whose
+bit width is a power of two greater than or equal to eight and less
+than or equal to a target-specific size limit. ‘<cmp>’ and ‘<new>’ must
+have the same type, and the type of ‘<pointer>’ must be a pointer to
+that type. If the <tt class="docutils literal"><span class="pre">cmpxchg</span></tt> is marked as <tt class="docutils literal"><span class="pre">volatile</span></tt>, then the
+optimizer is not allowed to modify the number or order of execution of
+this <tt class="docutils literal"><span class="pre">cmpxchg</span></tt> with other <a class="reference internal" href="#volatile"><em>volatile operations</em></a>.</p>
+<p>The success and failure <a class="reference internal" href="#ordering"><em>ordering</em></a> arguments specify how this
+<tt class="docutils literal"><span class="pre">cmpxchg</span></tt> synchronizes with other atomic operations. Both ordering parameters
+must be at least <tt class="docutils literal"><span class="pre">monotonic</span></tt>, the ordering constraint on failure must be no
+stronger than that on success, and the failure ordering cannot be either
+<tt class="docutils literal"><span class="pre">release</span></tt> or <tt class="docutils literal"><span class="pre">acq_rel</span></tt>.</p>
+<p>A <tt class="docutils literal"><span class="pre">cmpxchg</span></tt> instruction can also take an optional
+“<a class="reference internal" href="#syncscope"><em>syncscope</em></a>” argument.</p>
+<p>The pointer passed into cmpxchg must have alignment greater than or
+equal to the size in memory of the operand.</p>
+</div>
+<div class="section" id="id205">
+<h5><a class="toc-backref" href="#id1191">Semantics:</a><a class="headerlink" href="#id205" title="Permalink to this headline">¶</a></h5>
+<p>The contents of memory at the location specified by the ‘<tt class="docutils literal"><span class="pre"><pointer></span></tt>‘ operand
+is read and compared to ‘<tt class="docutils literal"><span class="pre"><cmp></span></tt>‘; if the values are equal, ‘<tt class="docutils literal"><span class="pre"><new></span></tt>‘ is
+written to the location. The original value at the location is returned,
+together with a flag indicating success (true) or failure (false).</p>
+<p>If the cmpxchg operation is marked as <tt class="docutils literal"><span class="pre">weak</span></tt> then a spurious failure is
+permitted: the operation may not write <tt class="docutils literal"><span class="pre"><new></span></tt> even if the comparison
+matched.</p>
+<p>If the cmpxchg operation is strong (the default), the i1 value is 1 if and only
+if the value loaded equals <tt class="docutils literal"><span class="pre">cmp</span></tt>.</p>
+<p>A successful <tt class="docutils literal"><span class="pre">cmpxchg</span></tt> is a read-modify-write instruction for the purpose of
+identifying release sequences. A failed <tt class="docutils literal"><span class="pre">cmpxchg</span></tt> is equivalent to an atomic
+load with an ordering parameter determined the second ordering parameter.</p>
+</div>
+<div class="section" id="id206">
+<h5><a class="toc-backref" href="#id1192">Example:</a><a class="headerlink" href="#id206" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><pre>entry:
+  %orig = load atomic i32, i32* %ptr unordered, align 4                      ; yields i32
+  br label %loop
+
+loop:
+  %cmp = phi i32 [ %orig, %entry ], [%value_loaded, %loop]
+  %squared = mul i32 %cmp, %cmp
+  %val_success = cmpxchg i32* %ptr, i32 %cmp, i32 %squared acq_rel monotonic ; yields  { i32, i1 }
+  %value_loaded = extractvalue { i32, i1 } %val_success, 0
+  %success = extractvalue { i32, i1 } %val_success, 1
+  br i1 %success, label %done, label %loop
+
+done:
+  ...</pre>
+</div>
+</div>
+</div>
+<div class="section" id="atomicrmw-instruction">
+<span id="i-atomicrmw"></span><h4><a class="toc-backref" href="#id1193">‘<tt class="docutils literal"><span class="pre">atomicrmw</span></tt>‘ Instruction</a><a class="headerlink" href="#atomicrmw-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id207">
+<h5><a class="toc-backref" href="#id1194">Syntax:</a><a class="headerlink" href="#id207" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>atomicrmw [volatile] <operation> <ty>* <pointer>, <ty> <value> [syncscope("<target-scope>")] <ordering>                   ; yields ty</pre>
+</div>
+</div>
+<div class="section" id="id208">
+<h5><a class="toc-backref" href="#id1195">Overview:</a><a class="headerlink" href="#id208" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">atomicrmw</span></tt>‘ instruction is used to atomically modify memory.</p>
+</div>
+<div class="section" id="id209">
+<h5><a class="toc-backref" href="#id1196">Arguments:</a><a class="headerlink" href="#id209" title="Permalink to this headline">¶</a></h5>
+<p>There are three arguments to the ‘<tt class="docutils literal"><span class="pre">atomicrmw</span></tt>‘ instruction: an
+operation to apply, an address whose value to modify, an argument to the
+operation. The operation must be one of the following keywords:</p>
+<ul class="simple">
+<li>xchg</li>
+<li>add</li>
+<li>sub</li>
+<li>and</li>
+<li>nand</li>
+<li>or</li>
+<li>xor</li>
+<li>max</li>
+<li>min</li>
+<li>umax</li>
+<li>umin</li>
+</ul>
+<p>The type of ‘<value>’ must be an integer type whose bit width is a power
+of two greater than or equal to eight and less than or equal to a
+target-specific size limit. The type of the ‘<tt class="docutils literal"><span class="pre"><pointer></span></tt>‘ operand must
+be a pointer to that type. If the <tt class="docutils literal"><span class="pre">atomicrmw</span></tt> is marked as
+<tt class="docutils literal"><span class="pre">volatile</span></tt>, then the optimizer is not allowed to modify the number or
+order of execution of this <tt class="docutils literal"><span class="pre">atomicrmw</span></tt> with other <a class="reference internal" href="#volatile"><em>volatile
+operations</em></a>.</p>
+<p>A <tt class="docutils literal"><span class="pre">atomicrmw</span></tt> instruction can also take an optional
+“<a class="reference internal" href="#syncscope"><em>syncscope</em></a>” argument.</p>
+</div>
+<div class="section" id="id210">
+<h5><a class="toc-backref" href="#id1197">Semantics:</a><a class="headerlink" href="#id210" title="Permalink to this headline">¶</a></h5>
+<p>The contents of memory at the location specified by the ‘<tt class="docutils literal"><span class="pre"><pointer></span></tt>‘
+operand are atomically read, modified, and written back. The original
+value at the location is returned. The modification is specified by the
+operation argument:</p>
+<ul class="simple">
+<li>xchg: <tt class="docutils literal"><span class="pre">*ptr</span> <span class="pre">=</span> <span class="pre">val</span></tt></li>
+<li>add: <tt class="docutils literal"><span class="pre">*ptr</span> <span class="pre">=</span> <span class="pre">*ptr</span> <span class="pre">+</span> <span class="pre">val</span></tt></li>
+<li>sub: <tt class="docutils literal"><span class="pre">*ptr</span> <span class="pre">=</span> <span class="pre">*ptr</span> <span class="pre">-</span> <span class="pre">val</span></tt></li>
+<li>and: <tt class="docutils literal"><span class="pre">*ptr</span> <span class="pre">=</span> <span class="pre">*ptr</span> <span class="pre">&</span> <span class="pre">val</span></tt></li>
+<li>nand: <tt class="docutils literal"><span class="pre">*ptr</span> <span class="pre">=</span> <span class="pre">~(*ptr</span> <span class="pre">&</span> <span class="pre">val)</span></tt></li>
+<li>or: <tt class="docutils literal"><span class="pre">*ptr</span> <span class="pre">=</span> <span class="pre">*ptr</span> <span class="pre">|</span> <span class="pre">val</span></tt></li>
+<li>xor: <tt class="docutils literal"><span class="pre">*ptr</span> <span class="pre">=</span> <span class="pre">*ptr</span> <span class="pre">^</span> <span class="pre">val</span></tt></li>
+<li>max: <tt class="docutils literal"><span class="pre">*ptr</span> <span class="pre">=</span> <span class="pre">*ptr</span> <span class="pre">></span> <span class="pre">val</span> <span class="pre">?</span> <span class="pre">*ptr</span> <span class="pre">:</span> <span class="pre">val</span></tt> (using a signed comparison)</li>
+<li>min: <tt class="docutils literal"><span class="pre">*ptr</span> <span class="pre">=</span> <span class="pre">*ptr</span> <span class="pre"><</span> <span class="pre">val</span> <span class="pre">?</span> <span class="pre">*ptr</span> <span class="pre">:</span> <span class="pre">val</span></tt> (using a signed comparison)</li>
+<li>umax: <tt class="docutils literal"><span class="pre">*ptr</span> <span class="pre">=</span> <span class="pre">*ptr</span> <span class="pre">></span> <span class="pre">val</span> <span class="pre">?</span> <span class="pre">*ptr</span> <span class="pre">:</span> <span class="pre">val</span></tt> (using an unsigned
+comparison)</li>
+<li>umin: <tt class="docutils literal"><span class="pre">*ptr</span> <span class="pre">=</span> <span class="pre">*ptr</span> <span class="pre"><</span> <span class="pre">val</span> <span class="pre">?</span> <span class="pre">*ptr</span> <span class="pre">:</span> <span class="pre">val</span></tt> (using an unsigned
+comparison)</li>
+</ul>
+</div>
+<div class="section" id="id211">
+<h5><a class="toc-backref" href="#id1198">Example:</a><a class="headerlink" href="#id211" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><pre>%old = atomicrmw add i32* %ptr, i32 1 acquire                        ; yields i32</pre>
+</div>
+</div>
+</div>
+<div class="section" id="getelementptr-instruction">
+<span id="i-getelementptr"></span><h4><a class="toc-backref" href="#id1199">‘<tt class="docutils literal"><span class="pre">getelementptr</span></tt>‘ Instruction</a><a class="headerlink" href="#getelementptr-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id212">
+<h5><a class="toc-backref" href="#id1200">Syntax:</a><a class="headerlink" href="#id212" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = getelementptr <ty>, <ty>* <ptrval>{, [inrange] <ty> <idx>}*
+<result> = getelementptr inbounds <ty>, <ty>* <ptrval>{, [inrange] <ty> <idx>}*
+<result> = getelementptr <ty>, <ptr vector> <ptrval>, [inrange] <vector index type> <idx></pre>
+</div>
+</div>
+<div class="section" id="id213">
+<h5><a class="toc-backref" href="#id1201">Overview:</a><a class="headerlink" href="#id213" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">getelementptr</span></tt>‘ instruction is used to get the address of a
+subelement of an <a class="reference internal" href="#t-aggregate"><em>aggregate</em></a> data structure. It performs
+address calculation only and does not access memory. The instruction can also
+be used to calculate a vector of such addresses.</p>
+</div>
+<div class="section" id="id214">
+<h5><a class="toc-backref" href="#id1202">Arguments:</a><a class="headerlink" href="#id214" title="Permalink to this headline">¶</a></h5>
+<p>The first argument is always a type used as the basis for the calculations.
+The second argument is always a pointer or a vector of pointers, and is the
+base address to start from. The remaining arguments are indices
+that indicate which of the elements of the aggregate object are indexed.
+The interpretation of each index is dependent on the type being indexed
+into. The first index always indexes the pointer value given as the
+second argument, the second index indexes a value of the type pointed to
+(not necessarily the value directly pointed to, since the first index
+can be non-zero), etc. The first type indexed into must be a pointer
+value, subsequent types can be arrays, vectors, and structs. Note that
+subsequent types being indexed into can never be pointers, since that
+would require loading the pointer before continuing calculation.</p>
+<p>The type of each index argument depends on the type it is indexing into.
+When indexing into a (optionally packed) structure, only <tt class="docutils literal"><span class="pre">i32</span></tt> integer
+<strong>constants</strong> are allowed (when using a vector of indices they must all
+be the <strong>same</strong> <tt class="docutils literal"><span class="pre">i32</span></tt> integer constant). When indexing into an array,
+pointer or vector, integers of any width are allowed, and they are not
+required to be constant. These integers are treated as signed values
+where relevant.</p>
+<p>For example, let’s consider a C code fragment and how it gets compiled
+to LLVM:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="k">struct</span> <span class="n">RT</span> <span class="p">{</span>
+  <span class="kt">char</span> <span class="n">A</span><span class="p">;</span>
+  <span class="kt">int</span> <span class="n">B</span><span class="p">[</span><span class="mi">10</span><span class="p">][</span><span class="mi">20</span><span class="p">];</span>
+  <span class="kt">char</span> <span class="n">C</span><span class="p">;</span>
+<span class="p">};</span>
+<span class="k">struct</span> <span class="n">ST</span> <span class="p">{</span>
+  <span class="kt">int</span> <span class="n">X</span><span class="p">;</span>
+  <span class="kt">double</span> <span class="n">Y</span><span class="p">;</span>
+  <span class="k">struct</span> <span class="n">RT</span> <span class="n">Z</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="kt">int</span> <span class="o">*</span><span class="nf">foo</span><span class="p">(</span><span class="k">struct</span> <span class="n">ST</span> <span class="o">*</span><span class="n">s</span><span class="p">)</span> <span class="p">{</span>
+  <span class="k">return</span> <span class="o">&</span><span class="n">s</span><span class="p">[</span><span class="mi">1</span><span class="p">].</span><span class="n">Z</span><span class="p">.</span><span class="n">B</span><span class="p">[</span><span class="mi">5</span><span class="p">][</span><span class="mi">13</span><span class="p">];</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>The LLVM code generated by Clang is:</p>
+<div class="highlight-llvm"><pre>%struct.RT = type { i8, [10 x [20 x i32]], i8 }
+%struct.ST = type { i32, double, %struct.RT }
+
+define i32* @foo(%struct.ST* %s) nounwind uwtable readnone optsize ssp {
+entry:
+  %arrayidx = getelementptr inbounds %struct.ST, %struct.ST* %s, i64 1, i32 2, i32 1, i64 5, i64 13
+  ret i32* %arrayidx
+}</pre>
+</div>
+</div>
+<div class="section" id="id215">
+<h5><a class="toc-backref" href="#id1203">Semantics:</a><a class="headerlink" href="#id215" title="Permalink to this headline">¶</a></h5>
+<p>In the example above, the first index is indexing into the
+‘<tt class="docutils literal"><span class="pre">%struct.ST*</span></tt>‘ type, which is a pointer, yielding a ‘<tt class="docutils literal"><span class="pre">%struct.ST</span></tt>‘
+= ‘<tt class="docutils literal"><span class="pre">{</span> <span class="pre">i32,</span> <span class="pre">double,</span> <span class="pre">%struct.RT</span> <span class="pre">}</span></tt>‘ type, a structure. The second index
+indexes into the third element of the structure, yielding a
+‘<tt class="docutils literal"><span class="pre">%struct.RT</span></tt>‘ = ‘<tt class="docutils literal"><span class="pre">{</span> <span class="pre">i8</span> <span class="pre">,</span> <span class="pre">[10</span> <span class="pre">x</span> <span class="pre">[20</span> <span class="pre">x</span> <span class="pre">i32]],</span> <span class="pre">i8</span> <span class="pre">}</span></tt>‘ type, another
+structure. The third index indexes into the second element of the
+structure, yielding a ‘<tt class="docutils literal"><span class="pre">[10</span> <span class="pre">x</span> <span class="pre">[20</span> <span class="pre">x</span> <span class="pre">i32]]</span></tt>‘ type, an array. The two
+dimensions of the array are subscripted into, yielding an ‘<tt class="docutils literal"><span class="pre">i32</span></tt>‘
+type. The ‘<tt class="docutils literal"><span class="pre">getelementptr</span></tt>‘ instruction returns a pointer to this
+element, thus computing a value of ‘<tt class="docutils literal"><span class="pre">i32*</span></tt>‘ type.</p>
+<p>Note that it is perfectly legal to index partially through a structure,
+returning a pointer to an inner element. Because of this, the LLVM code
+for the given testcase is equivalent to:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="k">define</span> <span class="k">i32</span><span class="p">*</span> <span class="vg">@foo</span><span class="p">(</span><span class="nv">%struct.ST</span><span class="p">*</span> <span class="nv">%s</span><span class="p">)</span> <span class="p">{</span>
+  <span class="nv">%t1</span> <span class="p">=</span> <span class="k">getelementptr</span> <span class="nv">%struct.ST</span><span class="p">,</span> <span class="nv">%struct.ST</span><span class="p">*</span> <span class="nv">%s</span><span class="p">,</span> <span class="k">i32</span> <span class="m">1</span>                        <span class="c">; yields %struct.ST*:%t1</span>
+  <span class="nv">%t2</span> <span class="p">=</span> <span class="k">getelementptr</span> <span class="nv">%struct.ST</span><span class="p">,</span> <span class="nv">%struct.ST</span><span class="p">*</span> <span class="nv">%t1</span><span class="p">,</span> <span class="k">i32</span> <span class="m">0</span><span class="p">,</span> <span class="k">i32</span> <span class="m">2</span>                <span class="c">; yields %struct.RT*:%t2</span>
+  <span class="nv">%t3</span> <span class="p">=</span> <span class="k">getelementptr</span> <span class="nv">%struct.RT</span><span class="p">,</span> <span class="nv">%struct.RT</span><span class="p">*</span> <span class="nv">%t2</span><span class="p">,</span> <span class="k">i32</span> <span class="m">0</span><span class="p">,</span> <span class="k">i32</span> <span class="m">1</span>                <span class="c">; yields [10 x [20 x i32]]*:%t3</span>
+  <span class="nv">%t4</span> <span class="p">=</span> <span class="k">getelementptr</span> <span class="p">[</span><span class="m">10</span> <span class="k">x</span> <span class="p">[</span><span class="m">20</span> <span class="k">x</span> <span class="k">i32</span><span class="p">]],</span> <span class="p">[</span><span class="m">10</span> <span class="k">x</span> <span class="p">[</span><span class="m">20</span> <span class="k">x</span> <span class="k">i32</span><span class="p">]]*</span> <span class="nv">%t3</span><span class="p">,</span> <span class="k">i32</span> <span class="m">0</span><span class="p">,</span> <span class="k">i32</span> <span class="m">5</span>  <span class="c">; yields [20 x i32]*:%t4</span>
+  <span class="nv">%t5</span> <span class="p">=</span> <span class="k">getelementptr</span> <span class="p">[</span><span class="m">20</span> <span class="k">x</span> <span class="k">i32</span><span class="p">],</span> <span class="p">[</span><span class="m">20</span> <span class="k">x</span> <span class="k">i32</span><span class="p">]*</span> <span class="nv">%t4</span><span class="p">,</span> <span class="k">i32</span> <span class="m">0</span><span class="p">,</span> <span class="k">i32</span> <span class="m">13</span>               <span class="c">; yields i32*:%t5</span>
+  <span class="k">ret</span> <span class="k">i32</span><span class="p">*</span> <span class="nv">%t5</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>If the <tt class="docutils literal"><span class="pre">inbounds</span></tt> keyword is present, the result value of the
+<tt class="docutils literal"><span class="pre">getelementptr</span></tt> is a <a class="reference internal" href="#poisonvalues"><em>poison value</em></a> if the base
+pointer is not an <em>in bounds</em> address of an allocated object, or if any
+of the addresses that would be formed by successive addition of the
+offsets implied by the indices to the base address with infinitely
+precise signed arithmetic are not an <em>in bounds</em> address of that
+allocated object. The <em>in bounds</em> addresses for an allocated object are
+all the addresses that point into the object, plus the address one byte
+past the end. The only <em>in bounds</em> address for a null pointer in the
+default address-space is the null pointer itself. In cases where the
+base is a vector of pointers the <tt class="docutils literal"><span class="pre">inbounds</span></tt> keyword applies to each
+of the computations element-wise.</p>
+<p>If the <tt class="docutils literal"><span class="pre">inbounds</span></tt> keyword is not present, the offsets are added to the
+base address with silently-wrapping two’s complement arithmetic. If the
+offsets have a different width from the pointer, they are sign-extended
+or truncated to the width of the pointer. The result value of the
+<tt class="docutils literal"><span class="pre">getelementptr</span></tt> may be outside the object pointed to by the base
+pointer. The result value may not necessarily be used to access memory
+though, even if it happens to point into allocated storage. See the
+<a class="reference internal" href="#pointeraliasing"><em>Pointer Aliasing Rules</em></a> section for more
+information.</p>
+<p>If the <tt class="docutils literal"><span class="pre">inrange</span></tt> keyword is present before any index, loading from or
+storing to any pointer derived from the <tt class="docutils literal"><span class="pre">getelementptr</span></tt> has undefined
+behavior if the load or store would access memory outside of the bounds of
+the element selected by the index marked as <tt class="docutils literal"><span class="pre">inrange</span></tt>. The result of a
+pointer comparison or <tt class="docutils literal"><span class="pre">ptrtoint</span></tt> (including <tt class="docutils literal"><span class="pre">ptrtoint</span></tt>-like operations
+involving memory) involving a pointer derived from a <tt class="docutils literal"><span class="pre">getelementptr</span></tt> with
+the <tt class="docutils literal"><span class="pre">inrange</span></tt> keyword is undefined, with the exception of comparisons
+in the case where both operands are in the range of the element selected
+by the <tt class="docutils literal"><span class="pre">inrange</span></tt> keyword, inclusive of the address one past the end of
+that element. Note that the <tt class="docutils literal"><span class="pre">inrange</span></tt> keyword is currently only allowed
+in constant <tt class="docutils literal"><span class="pre">getelementptr</span></tt> expressions.</p>
+<p>The getelementptr instruction is often confusing. For some more insight
+into how it works, see <a class="reference internal" href="GetElementPtr.html"><em>the getelementptr FAQ</em></a>.</p>
+</div>
+<div class="section" id="id216">
+<h5><a class="toc-backref" href="#id1204">Example:</a><a class="headerlink" href="#id216" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="c">; yields [12 x i8]*:aptr</span>
+<span class="nv">%aptr</span> <span class="p">=</span> <span class="k">getelementptr</span> <span class="p">{</span><span class="k">i32</span><span class="p">,</span> <span class="p">[</span><span class="m">12</span> <span class="k">x</span> <span class="k">i8</span><span class="p">]},</span> <span class="p">{</span><span class="k">i32</span><span class="p">,</span> <span class="p">[</span><span class="m">12</span> <span class="k">x</span> <span class="k">i8</span><span class="p">]}*</span> <span class="nv">%saptr</span><span class="p">,</span> <span class="k">i64</span> <span class="m">0</span><span class="p">,</span> <span class="k">i32</span> <span class="m">1</span>
+<span class="c">; yields i8*:vptr</span>
+<span class="nv">%vptr</span> <span class="p">=</span> <span class="k">getelementptr</span> <span class="p">{</span><span class="k">i32</span><span class="p">,</span> <span class="p"><</span><span class="m">2</span> <span class="k">x</span> <span class="k">i8</span><span class="p">>},</span> <span class="p">{</span><span class="k">i32</span><span class="p">,</span> <span class="p"><</span><span class="m">2</span> <span class="k">x</span> <span class="k">i8</span><span class="p">>}*</span> <span class="nv">%svptr</span><span class="p">,</span> <span class="k">i64</span> <span class="m">0</span><span class="p">,</span> <span class="k">i32</span> <span class="m">1</span><span class="p">,</span> <span class="k">i32</span> <span class="m">1</span>
+<span class="c">; yields i8*:eptr</span>
+<span class="nv">%eptr</span> <span class="p">=</span> <span class="k">getelementptr</span> <span class="p">[</span><span class="m">12</span> <span class="k">x</span> <span class="k">i8</span><span class="p">],</span> <span class="p">[</span><span class="m">12</span> <span class="k">x</span> <span class="k">i8</span><span class="p">]*</span> <span class="nv">%aptr</span><span class="p">,</span> <span class="k">i64</span> <span class="m">0</span><span class="p">,</span> <span class="k">i32</span> <span class="m">1</span>
+<span class="c">; yields i32*:iptr</span>
+<span class="nv">%iptr</span> <span class="p">=</span> <span class="k">getelementptr</span> <span class="p">[</span><span class="m">10</span> <span class="k">x</span> <span class="k">i32</span><span class="p">],</span> <span class="p">[</span><span class="m">10</span> <span class="k">x</span> <span class="k">i32</span><span class="p">]*</span> <span class="vg">@arr</span><span class="p">,</span> <span class="k">i16</span> <span class="m">0</span><span class="p">,</span> <span class="k">i16</span> <span class="m">0</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="vector-of-pointers">
+<h5><a class="toc-backref" href="#id1205">Vector of pointers:</a><a class="headerlink" href="#vector-of-pointers" title="Permalink to this headline">¶</a></h5>
+<p>The <tt class="docutils literal"><span class="pre">getelementptr</span></tt> returns a vector of pointers, instead of a single address,
+when one or more of its arguments is a vector. In such cases, all vector
+arguments should have the same number of elements, and every scalar argument
+will be effectively broadcast into a vector during address calculation.</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="c">; All arguments are vectors:</span>
+<span class="c">;   A[i] = ptrs[i] + offsets[i]*sizeof(i8)</span>
+<span class="nv">%A</span> <span class="p">=</span> <span class="k">getelementptr</span> <span class="k">i8</span><span class="p">,</span> <span class="p"><</span><span class="m">4</span> <span class="k">x</span> <span class="k">i8</span><span class="p">*></span> <span class="nv">%ptrs</span><span class="p">,</span> <span class="p"><</span><span class="m">4</span> <span class="k">x</span> <span class="k">i64</span><span class="p">></span> <span class="nv">%offsets</span>
+
+<span class="c">; Add the same scalar offset to each pointer of a vector:</span>
+<span class="c">;   A[i] = ptrs[i] + offset*sizeof(i8)</span>
+<span class="nv">%A</span> <span class="p">=</span> <span class="k">getelementptr</span> <span class="k">i8</span><span class="p">,</span> <span class="p"><</span><span class="m">4</span> <span class="k">x</span> <span class="k">i8</span><span class="p">*></span> <span class="nv">%ptrs</span><span class="p">,</span> <span class="k">i64</span> <span class="nv">%offset</span>
+
+<span class="c">; Add distinct offsets to the same pointer:</span>
+<span class="c">;   A[i] = ptr + offsets[i]*sizeof(i8)</span>
+<span class="nv">%A</span> <span class="p">=</span> <span class="k">getelementptr</span> <span class="k">i8</span><span class="p">,</span> <span class="k">i8</span><span class="p">*</span> <span class="nv">%ptr</span><span class="p">,</span> <span class="p"><</span><span class="m">4</span> <span class="k">x</span> <span class="k">i64</span><span class="p">></span> <span class="nv">%offsets</span>
+
+<span class="c">; In all cases described above the type of the result is <4 x i8*></span>
+</pre></div>
+</div>
+<p>The two following instructions are equivalent:</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="k">getelementptr</span>  <span class="nv">%struct.ST</span><span class="p">,</span> <span class="p"><</span><span class="m">4</span> <span class="k">x</span> <span class="nv">%struct.ST</span><span class="p">*></span> <span class="nv">%s</span><span class="p">,</span> <span class="p"><</span><span class="m">4</span> <span class="k">x</span> <span class="k">i64</span><span class="p">></span> <span class="nv">%ind1</span><span class="p">,</span>
+  <span class="p"><</span><span class="m">4</span> <span class="k">x</span> <span class="k">i32</span><span class="p">></span> <span class="p"><</span><span class="k">i32</span> <span class="m">2</span><span class="p">,</span> <span class="k">i32</span> <span class="m">2</span><span class="p">,</span> <span class="k">i32</span> <span class="m">2</span><span class="p">,</span> <span class="k">i32</span> <span class="m">2</span><span class="p">>,</span>
+  <span class="p"><</span><span class="m">4</span> <span class="k">x</span> <span class="k">i32</span><span class="p">></span> <span class="p"><</span><span class="k">i32</span> <span class="m">1</span><span class="p">,</span> <span class="k">i32</span> <span class="m">1</span><span class="p">,</span> <span class="k">i32</span> <span class="m">1</span><span class="p">,</span> <span class="k">i32</span> <span class="m">1</span><span class="p">>,</span>
+  <span class="p"><</span><span class="m">4</span> <span class="k">x</span> <span class="k">i32</span><span class="p">></span> <span class="nv">%ind4</span><span class="p">,</span>
+  <span class="p"><</span><span class="m">4</span> <span class="k">x</span> <span class="k">i64</span><span class="p">></span> <span class="p"><</span><span class="k">i64</span> <span class="m">13</span><span class="p">,</span> <span class="k">i64</span> <span class="m">13</span><span class="p">,</span> <span class="k">i64</span> <span class="m">13</span><span class="p">,</span> <span class="k">i64</span> <span class="m">13</span><span class="p">></span>
+
+<span class="k">getelementptr</span>  <span class="nv">%struct.ST</span><span class="p">,</span> <span class="p"><</span><span class="m">4</span> <span class="k">x</span> <span class="nv">%struct.ST</span><span class="p">*></span> <span class="nv">%s</span><span class="p">,</span> <span class="p"><</span><span class="m">4</span> <span class="k">x</span> <span class="k">i64</span><span class="p">></span> <span class="nv">%ind1</span><span class="p">,</span>
+  <span class="k">i32</span> <span class="m">2</span><span class="p">,</span> <span class="k">i32</span> <span class="m">1</span><span class="p">,</span> <span class="p"><</span><span class="m">4</span> <span class="k">x</span> <span class="k">i32</span><span class="p">></span> <span class="nv">%ind4</span><span class="p">,</span> <span class="k">i64</span> <span class="m">13</span>
+</pre></div>
+</div>
+<p>Let’s look at the C code, where the vector version of <tt class="docutils literal"><span class="pre">getelementptr</span></tt>
+makes sense:</p>
+<div class="highlight-c"><div class="highlight"><pre><span class="c1">// Let's assume that we vectorize the following loop:</span>
+<span class="kt">double</span> <span class="o">*</span><span class="n">A</span><span class="p">,</span> <span class="o">*</span><span class="n">B</span><span class="p">;</span> <span class="kt">int</span> <span class="o">*</span><span class="n">C</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="n">size</span><span class="p">;</span> <span class="o">++</span><span class="n">i</span><span class="p">)</span> <span class="p">{</span>
+  <span class="n">A</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="n">B</span><span class="p">[</span><span class="n">C</span><span class="p">[</span><span class="n">i</span><span class="p">]];</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="c">; get pointers for 8 elements from array B</span>
+<span class="nv">%ptrs</span> <span class="p">=</span> <span class="k">getelementptr</span> <span class="kt">double</span><span class="p">,</span> <span class="kt">double</span><span class="p">*</span> <span class="nv">%B</span><span class="p">,</span> <span class="p"><</span><span class="m">8</span> <span class="k">x</span> <span class="k">i32</span><span class="p">></span> <span class="nv">%C</span>
+<span class="c">; load 8 elements from array B into A</span>
+<span class="nv">%A</span> <span class="p">=</span> <span class="k">call</span> <span class="p"><</span><span class="m">8</span> <span class="k">x</span> <span class="kt">double</span><span class="p">></span> <span class="vg">@llvm.masked.gather.v8f64.v8p0f64</span><span class="p">(<</span><span class="m">8</span> <span class="k">x</span> <span class="kt">double</span><span class="p">*></span> <span class="nv">%ptrs</span><span class="p">,</span>
+     <span class="k">i32</span> <span class="m">8</span><span class="p">,</span> <span class="p"><</span><span class="m">8</span> <span class="k">x</span> <span class="k">i1</span><span class="p">></span> <span class="nv">%mask</span><span class="p">,</span> <span class="p"><</span><span class="m">8</span> <span class="k">x</span> <span class="kt">double</span><span class="p">></span> <span class="nv">%passthru</span><span class="p">)</span>
+</pre></div>
+</div>
+</div>
+</div>
+</div>
+<div class="section" id="conversion-operations">
+<h3><a class="toc-backref" href="#id1206">Conversion Operations</a><a class="headerlink" href="#conversion-operations" title="Permalink to this headline">¶</a></h3>
+<p>The instructions in this category are the conversion instructions
+(casting) which all take a single operand and a type. They perform
+various bit conversions on the operand.</p>
+<div class="section" id="trunc-to-instruction">
+<span id="i-trunc"></span><h4><a class="toc-backref" href="#id1207">‘<tt class="docutils literal"><span class="pre">trunc</span> <span class="pre">..</span> <span class="pre">to</span></tt>‘ Instruction</a><a class="headerlink" href="#trunc-to-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id217">
+<h5><a class="toc-backref" href="#id1208">Syntax:</a><a class="headerlink" href="#id217" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = trunc <ty> <value> to <ty2>             ; yields ty2</pre>
+</div>
+</div>
+<div class="section" id="id218">
+<h5><a class="toc-backref" href="#id1209">Overview:</a><a class="headerlink" href="#id218" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">trunc</span></tt>‘ instruction truncates its operand to the type <tt class="docutils literal"><span class="pre">ty2</span></tt>.</p>
+</div>
+<div class="section" id="id219">
+<h5><a class="toc-backref" href="#id1210">Arguments:</a><a class="headerlink" href="#id219" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">trunc</span></tt>‘ instruction takes a value to trunc, and a type to trunc
+it to. Both types must be of <a class="reference internal" href="#t-integer"><em>integer</em></a> types, or vectors
+of the same number of integers. The bit size of the <tt class="docutils literal"><span class="pre">value</span></tt> must be
+larger than the bit size of the destination type, <tt class="docutils literal"><span class="pre">ty2</span></tt>. Equal sized
+types are not allowed.</p>
+</div>
+<div class="section" id="id220">
+<h5><a class="toc-backref" href="#id1211">Semantics:</a><a class="headerlink" href="#id220" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">trunc</span></tt>‘ instruction truncates the high order bits in <tt class="docutils literal"><span class="pre">value</span></tt>
+and converts the remaining bits to <tt class="docutils literal"><span class="pre">ty2</span></tt>. Since the source size must
+be larger than the destination size, <tt class="docutils literal"><span class="pre">trunc</span></tt> cannot be a <em>no-op cast</em>.
+It will always truncate bits.</p>
+</div>
+<div class="section" id="id221">
+<h5><a class="toc-backref" href="#id1212">Example:</a><a class="headerlink" href="#id221" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%X</span> <span class="p">=</span> <span class="k">trunc</span> <span class="k">i32</span> <span class="m">257</span> <span class="k">to</span> <span class="k">i8</span>                        <span class="c">; yields i8:1</span>
+<span class="nv">%Y</span> <span class="p">=</span> <span class="k">trunc</span> <span class="k">i32</span> <span class="m">123</span> <span class="k">to</span> <span class="k">i1</span>                        <span class="c">; yields i1:true</span>
+<span class="nv">%Z</span> <span class="p">=</span> <span class="k">trunc</span> <span class="k">i32</span> <span class="m">122</span> <span class="k">to</span> <span class="k">i1</span>                        <span class="c">; yields i1:false</span>
+<span class="nv">%W</span> <span class="p">=</span> <span class="k">trunc</span> <span class="p"><</span><span class="m">2</span> <span class="k">x</span> <span class="k">i16</span><span class="p">></span> <span class="p"><</span><span class="k">i16</span> <span class="m">8</span><span class="p">,</span> <span class="k">i16</span> <span class="m">7</span><span class="p">></span> <span class="k">to</span> <span class="p"><</span><span class="m">2</span> <span class="k">x</span> <span class="k">i8</span><span class="p">></span> <span class="c">; yields <i8 8, i8 7></span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="zext-to-instruction">
+<span id="i-zext"></span><h4><a class="toc-backref" href="#id1213">‘<tt class="docutils literal"><span class="pre">zext</span> <span class="pre">..</span> <span class="pre">to</span></tt>‘ Instruction</a><a class="headerlink" href="#zext-to-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id222">
+<h5><a class="toc-backref" href="#id1214">Syntax:</a><a class="headerlink" href="#id222" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = zext <ty> <value> to <ty2>             ; yields ty2</pre>
+</div>
+</div>
+<div class="section" id="id223">
+<h5><a class="toc-backref" href="#id1215">Overview:</a><a class="headerlink" href="#id223" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">zext</span></tt>‘ instruction zero extends its operand to type <tt class="docutils literal"><span class="pre">ty2</span></tt>.</p>
+</div>
+<div class="section" id="id224">
+<h5><a class="toc-backref" href="#id1216">Arguments:</a><a class="headerlink" href="#id224" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">zext</span></tt>‘ instruction takes a value to cast, and a type to cast it
+to. Both types must be of <a class="reference internal" href="#t-integer"><em>integer</em></a> types, or vectors of
+the same number of integers. The bit size of the <tt class="docutils literal"><span class="pre">value</span></tt> must be
+smaller than the bit size of the destination type, <tt class="docutils literal"><span class="pre">ty2</span></tt>.</p>
+</div>
+<div class="section" id="id225">
+<h5><a class="toc-backref" href="#id1217">Semantics:</a><a class="headerlink" href="#id225" title="Permalink to this headline">¶</a></h5>
+<p>The <tt class="docutils literal"><span class="pre">zext</span></tt> fills the high order bits of the <tt class="docutils literal"><span class="pre">value</span></tt> with zero bits
+until it reaches the size of the destination type, <tt class="docutils literal"><span class="pre">ty2</span></tt>.</p>
+<p>When zero extending from i1, the result will always be either 0 or 1.</p>
+</div>
+<div class="section" id="id226">
+<h5><a class="toc-backref" href="#id1218">Example:</a><a class="headerlink" href="#id226" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%X</span> <span class="p">=</span> <span class="k">zext</span> <span class="k">i32</span> <span class="m">257</span> <span class="k">to</span> <span class="k">i64</span>              <span class="c">; yields i64:257</span>
+<span class="nv">%Y</span> <span class="p">=</span> <span class="k">zext</span> <span class="k">i1</span> <span class="k">true</span> <span class="k">to</span> <span class="k">i32</span>              <span class="c">; yields i32:1</span>
+<span class="nv">%Z</span> <span class="p">=</span> <span class="k">zext</span> <span class="p"><</span><span class="m">2</span> <span class="k">x</span> <span class="k">i16</span><span class="p">></span> <span class="p"><</span><span class="k">i16</span> <span class="m">8</span><span class="p">,</span> <span class="k">i16</span> <span class="m">7</span><span class="p">></span> <span class="k">to</span> <span class="p"><</span><span class="m">2</span> <span class="k">x</span> <span class="k">i32</span><span class="p">></span> <span class="c">; yields <i32 8, i32 7></span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="sext-to-instruction">
+<span id="i-sext"></span><h4><a class="toc-backref" href="#id1219">‘<tt class="docutils literal"><span class="pre">sext</span> <span class="pre">..</span> <span class="pre">to</span></tt>‘ Instruction</a><a class="headerlink" href="#sext-to-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id227">
+<h5><a class="toc-backref" href="#id1220">Syntax:</a><a class="headerlink" href="#id227" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = sext <ty> <value> to <ty2>             ; yields ty2</pre>
+</div>
+</div>
+<div class="section" id="id228">
+<h5><a class="toc-backref" href="#id1221">Overview:</a><a class="headerlink" href="#id228" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">sext</span></tt>‘ sign extends <tt class="docutils literal"><span class="pre">value</span></tt> to the type <tt class="docutils literal"><span class="pre">ty2</span></tt>.</p>
+</div>
+<div class="section" id="id229">
+<h5><a class="toc-backref" href="#id1222">Arguments:</a><a class="headerlink" href="#id229" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">sext</span></tt>‘ instruction takes a value to cast, and a type to cast it
+to. Both types must be of <a class="reference internal" href="#t-integer"><em>integer</em></a> types, or vectors of
+the same number of integers. The bit size of the <tt class="docutils literal"><span class="pre">value</span></tt> must be
+smaller than the bit size of the destination type, <tt class="docutils literal"><span class="pre">ty2</span></tt>.</p>
+</div>
+<div class="section" id="id230">
+<h5><a class="toc-backref" href="#id1223">Semantics:</a><a class="headerlink" href="#id230" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">sext</span></tt>‘ instruction performs a sign extension by copying the sign
+bit (highest order bit) of the <tt class="docutils literal"><span class="pre">value</span></tt> until it reaches the bit size
+of the type <tt class="docutils literal"><span class="pre">ty2</span></tt>.</p>
+<p>When sign extending from i1, the extension always results in -1 or 0.</p>
+</div>
+<div class="section" id="id231">
+<h5><a class="toc-backref" href="#id1224">Example:</a><a class="headerlink" href="#id231" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%X</span> <span class="p">=</span> <span class="k">sext</span> <span class="k">i8</span>  <span class="m">-1</span> <span class="k">to</span> <span class="k">i16</span>              <span class="c">; yields i16   :65535</span>
+<span class="nv">%Y</span> <span class="p">=</span> <span class="k">sext</span> <span class="k">i1</span> <span class="k">true</span> <span class="k">to</span> <span class="k">i32</span>             <span class="c">; yields i32:-1</span>
+<span class="nv">%Z</span> <span class="p">=</span> <span class="k">sext</span> <span class="p"><</span><span class="m">2</span> <span class="k">x</span> <span class="k">i16</span><span class="p">></span> <span class="p"><</span><span class="k">i16</span> <span class="m">8</span><span class="p">,</span> <span class="k">i16</span> <span class="m">7</span><span class="p">></span> <span class="k">to</span> <span class="p"><</span><span class="m">2</span> <span class="k">x</span> <span class="k">i32</span><span class="p">></span> <span class="c">; yields <i32 8, i32 7></span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="fptrunc-to-instruction">
+<h4><a class="toc-backref" href="#id1225">‘<tt class="docutils literal"><span class="pre">fptrunc</span> <span class="pre">..</span> <span class="pre">to</span></tt>‘ Instruction</a><a class="headerlink" href="#fptrunc-to-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id232">
+<h5><a class="toc-backref" href="#id1226">Syntax:</a><a class="headerlink" href="#id232" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = fptrunc <ty> <value> to <ty2>             ; yields ty2</pre>
+</div>
+</div>
+<div class="section" id="id233">
+<h5><a class="toc-backref" href="#id1227">Overview:</a><a class="headerlink" href="#id233" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">fptrunc</span></tt>‘ instruction truncates <tt class="docutils literal"><span class="pre">value</span></tt> to type <tt class="docutils literal"><span class="pre">ty2</span></tt>.</p>
+</div>
+<div class="section" id="id234">
+<h5><a class="toc-backref" href="#id1228">Arguments:</a><a class="headerlink" href="#id234" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">fptrunc</span></tt>‘ instruction takes a <a class="reference internal" href="#t-floating"><em>floating point</em></a>
+value to cast and a <a class="reference internal" href="#t-floating"><em>floating point</em></a> type to cast it to.
+The size of <tt class="docutils literal"><span class="pre">value</span></tt> must be larger than the size of <tt class="docutils literal"><span class="pre">ty2</span></tt>. This
+implies that <tt class="docutils literal"><span class="pre">fptrunc</span></tt> cannot be used to make a <em>no-op cast</em>.</p>
+</div>
+<div class="section" id="id235">
+<h5><a class="toc-backref" href="#id1229">Semantics:</a><a class="headerlink" href="#id235" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">fptrunc</span></tt>‘ instruction casts a <tt class="docutils literal"><span class="pre">value</span></tt> from a larger
+<a class="reference internal" href="#t-floating"><em>floating point</em></a> type to a smaller <a class="reference internal" href="#t-floating"><em>floating
+point</em></a> type. If the value cannot fit (i.e. overflows) within the
+destination type, <tt class="docutils literal"><span class="pre">ty2</span></tt>, then the results are undefined. If the cast produces
+an inexact result, how rounding is performed (e.g. truncation, also known as
+round to zero) is undefined.</p>
+</div>
+<div class="section" id="id236">
+<h5><a class="toc-backref" href="#id1230">Example:</a><a class="headerlink" href="#id236" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%X</span> <span class="p">=</span> <span class="k">fptrunc</span> <span class="kt">double</span> <span class="m">123.0</span> <span class="k">to</span> <span class="kt">float</span>         <span class="c">; yields float:123.0</span>
+<span class="nv">%Y</span> <span class="p">=</span> <span class="k">fptrunc</span> <span class="kt">double</span> <span class="m">1.0E+300</span> <span class="k">to</span> <span class="kt">float</span>      <span class="c">; yields undefined</span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="fpext-to-instruction">
+<h4><a class="toc-backref" href="#id1231">‘<tt class="docutils literal"><span class="pre">fpext</span> <span class="pre">..</span> <span class="pre">to</span></tt>‘ Instruction</a><a class="headerlink" href="#fpext-to-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id237">
+<h5><a class="toc-backref" href="#id1232">Syntax:</a><a class="headerlink" href="#id237" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = fpext <ty> <value> to <ty2>             ; yields ty2</pre>
+</div>
+</div>
+<div class="section" id="id238">
+<h5><a class="toc-backref" href="#id1233">Overview:</a><a class="headerlink" href="#id238" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">fpext</span></tt>‘ extends a floating point <tt class="docutils literal"><span class="pre">value</span></tt> to a larger floating
+point value.</p>
+</div>
+<div class="section" id="id239">
+<h5><a class="toc-backref" href="#id1234">Arguments:</a><a class="headerlink" href="#id239" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">fpext</span></tt>‘ instruction takes a <a class="reference internal" href="#t-floating"><em>floating point</em></a>
+<tt class="docutils literal"><span class="pre">value</span></tt> to cast, and a <a class="reference internal" href="#t-floating"><em>floating point</em></a> type to cast it
+to. The source type must be smaller than the destination type.</p>
+</div>
+<div class="section" id="id240">
+<h5><a class="toc-backref" href="#id1235">Semantics:</a><a class="headerlink" href="#id240" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">fpext</span></tt>‘ instruction extends the <tt class="docutils literal"><span class="pre">value</span></tt> from a smaller
+<a class="reference internal" href="#t-floating"><em>floating point</em></a> type to a larger <a class="reference internal" href="#t-floating"><em>floating
+point</em></a> type. The <tt class="docutils literal"><span class="pre">fpext</span></tt> cannot be used to make a
+<em>no-op cast</em> because it always changes bits. Use <tt class="docutils literal"><span class="pre">bitcast</span></tt> to make a
+<em>no-op cast</em> for a floating point cast.</p>
+</div>
+<div class="section" id="id241">
+<h5><a class="toc-backref" href="#id1236">Example:</a><a class="headerlink" href="#id241" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%X</span> <span class="p">=</span> <span class="k">fpext</span> <span class="kt">float</span> <span class="m">3.125</span> <span class="k">to</span> <span class="kt">double</span>         <span class="c">; yields double:3.125000e+00</span>
+<span class="nv">%Y</span> <span class="p">=</span> <span class="k">fpext</span> <span class="kt">double</span> <span class="nv">%X</span> <span class="k">to</span> <span class="kt">fp128</span>            <span class="c">; yields fp128:0xL00000000000000004000900000000000</span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="fptoui-to-instruction">
+<h4><a class="toc-backref" href="#id1237">‘<tt class="docutils literal"><span class="pre">fptoui</span> <span class="pre">..</span> <span class="pre">to</span></tt>‘ Instruction</a><a class="headerlink" href="#fptoui-to-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id242">
+<h5><a class="toc-backref" href="#id1238">Syntax:</a><a class="headerlink" href="#id242" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = fptoui <ty> <value> to <ty2>             ; yields ty2</pre>
+</div>
+</div>
+<div class="section" id="id243">
+<h5><a class="toc-backref" href="#id1239">Overview:</a><a class="headerlink" href="#id243" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">fptoui</span></tt>‘ converts a floating point <tt class="docutils literal"><span class="pre">value</span></tt> to its unsigned
+integer equivalent of type <tt class="docutils literal"><span class="pre">ty2</span></tt>.</p>
+</div>
+<div class="section" id="id244">
+<h5><a class="toc-backref" href="#id1240">Arguments:</a><a class="headerlink" href="#id244" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">fptoui</span></tt>‘ instruction takes a value to cast, which must be a
+scalar or vector <a class="reference internal" href="#t-floating"><em>floating point</em></a> value, and a type to
+cast it to <tt class="docutils literal"><span class="pre">ty2</span></tt>, which must be an <a class="reference internal" href="#t-integer"><em>integer</em></a> type. If
+<tt class="docutils literal"><span class="pre">ty</span></tt> is a vector floating point type, <tt class="docutils literal"><span class="pre">ty2</span></tt> must be a vector integer
+type with the same number of elements as <tt class="docutils literal"><span class="pre">ty</span></tt></p>
+</div>
+<div class="section" id="id245">
+<h5><a class="toc-backref" href="#id1241">Semantics:</a><a class="headerlink" href="#id245" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">fptoui</span></tt>‘ instruction converts its <a class="reference internal" href="#t-floating"><em>floating
+point</em></a> operand into the nearest (rounding towards zero)
+unsigned integer value. If the value cannot fit in <tt class="docutils literal"><span class="pre">ty2</span></tt>, the results
+are undefined.</p>
+</div>
+<div class="section" id="id246">
+<h5><a class="toc-backref" href="#id1242">Example:</a><a class="headerlink" href="#id246" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><pre>%X = fptoui double 123.0 to i32      ; yields i32:123
+%Y = fptoui float 1.0E+300 to i1     ; yields undefined:1
+%Z = fptoui float 1.04E+17 to i8     ; yields undefined:1</pre>
+</div>
+</div>
+</div>
+<div class="section" id="fptosi-to-instruction">
+<h4><a class="toc-backref" href="#id1243">‘<tt class="docutils literal"><span class="pre">fptosi</span> <span class="pre">..</span> <span class="pre">to</span></tt>‘ Instruction</a><a class="headerlink" href="#fptosi-to-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id247">
+<h5><a class="toc-backref" href="#id1244">Syntax:</a><a class="headerlink" href="#id247" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = fptosi <ty> <value> to <ty2>             ; yields ty2</pre>
+</div>
+</div>
+<div class="section" id="id248">
+<h5><a class="toc-backref" href="#id1245">Overview:</a><a class="headerlink" href="#id248" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">fptosi</span></tt>‘ instruction converts <a class="reference internal" href="#t-floating"><em>floating point</em></a>
+<tt class="docutils literal"><span class="pre">value</span></tt> to type <tt class="docutils literal"><span class="pre">ty2</span></tt>.</p>
+</div>
+<div class="section" id="id249">
+<h5><a class="toc-backref" href="#id1246">Arguments:</a><a class="headerlink" href="#id249" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">fptosi</span></tt>‘ instruction takes a value to cast, which must be a
+scalar or vector <a class="reference internal" href="#t-floating"><em>floating point</em></a> value, and a type to
+cast it to <tt class="docutils literal"><span class="pre">ty2</span></tt>, which must be an <a class="reference internal" href="#t-integer"><em>integer</em></a> type. If
+<tt class="docutils literal"><span class="pre">ty</span></tt> is a vector floating point type, <tt class="docutils literal"><span class="pre">ty2</span></tt> must be a vector integer
+type with the same number of elements as <tt class="docutils literal"><span class="pre">ty</span></tt></p>
+</div>
+<div class="section" id="id250">
+<h5><a class="toc-backref" href="#id1247">Semantics:</a><a class="headerlink" href="#id250" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">fptosi</span></tt>‘ instruction converts its <a class="reference internal" href="#t-floating"><em>floating
+point</em></a> operand into the nearest (rounding towards zero)
+signed integer value. If the value cannot fit in <tt class="docutils literal"><span class="pre">ty2</span></tt>, the results
+are undefined.</p>
+</div>
+<div class="section" id="id251">
+<h5><a class="toc-backref" href="#id1248">Example:</a><a class="headerlink" href="#id251" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><pre>%X = fptosi double -123.0 to i32      ; yields i32:-123
+%Y = fptosi float 1.0E-247 to i1      ; yields undefined:1
+%Z = fptosi float 1.04E+17 to i8      ; yields undefined:1</pre>
+</div>
+</div>
+</div>
+<div class="section" id="uitofp-to-instruction">
+<h4><a class="toc-backref" href="#id1249">‘<tt class="docutils literal"><span class="pre">uitofp</span> <span class="pre">..</span> <span class="pre">to</span></tt>‘ Instruction</a><a class="headerlink" href="#uitofp-to-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id252">
+<h5><a class="toc-backref" href="#id1250">Syntax:</a><a class="headerlink" href="#id252" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = uitofp <ty> <value> to <ty2>             ; yields ty2</pre>
+</div>
+</div>
+<div class="section" id="id253">
+<h5><a class="toc-backref" href="#id1251">Overview:</a><a class="headerlink" href="#id253" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">uitofp</span></tt>‘ instruction regards <tt class="docutils literal"><span class="pre">value</span></tt> as an unsigned integer
+and converts that value to the <tt class="docutils literal"><span class="pre">ty2</span></tt> type.</p>
+</div>
+<div class="section" id="id254">
+<h5><a class="toc-backref" href="#id1252">Arguments:</a><a class="headerlink" href="#id254" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">uitofp</span></tt>‘ instruction takes a value to cast, which must be a
+scalar or vector <a class="reference internal" href="#t-integer"><em>integer</em></a> value, and a type to cast it to
+<tt class="docutils literal"><span class="pre">ty2</span></tt>, which must be an <a class="reference internal" href="#t-floating"><em>floating point</em></a> type. If
+<tt class="docutils literal"><span class="pre">ty</span></tt> is a vector integer type, <tt class="docutils literal"><span class="pre">ty2</span></tt> must be a vector floating point
+type with the same number of elements as <tt class="docutils literal"><span class="pre">ty</span></tt></p>
+</div>
+<div class="section" id="id255">
+<h5><a class="toc-backref" href="#id1253">Semantics:</a><a class="headerlink" href="#id255" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">uitofp</span></tt>‘ instruction interprets its operand as an unsigned
+integer quantity and converts it to the corresponding floating point
+value. If the value cannot fit in the floating point value, the results
+are undefined.</p>
+</div>
+<div class="section" id="id256">
+<h5><a class="toc-backref" href="#id1254">Example:</a><a class="headerlink" href="#id256" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%X</span> <span class="p">=</span> <span class="k">uitofp</span> <span class="k">i32</span> <span class="m">257</span> <span class="k">to</span> <span class="kt">float</span>         <span class="c">; yields float:257.0</span>
+<span class="nv">%Y</span> <span class="p">=</span> <span class="k">uitofp</span> <span class="k">i8</span> <span class="m">-1</span> <span class="k">to</span> <span class="kt">double</span>          <span class="c">; yields double:255.0</span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="sitofp-to-instruction">
+<h4><a class="toc-backref" href="#id1255">‘<tt class="docutils literal"><span class="pre">sitofp</span> <span class="pre">..</span> <span class="pre">to</span></tt>‘ Instruction</a><a class="headerlink" href="#sitofp-to-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id257">
+<h5><a class="toc-backref" href="#id1256">Syntax:</a><a class="headerlink" href="#id257" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = sitofp <ty> <value> to <ty2>             ; yields ty2</pre>
+</div>
+</div>
+<div class="section" id="id258">
+<h5><a class="toc-backref" href="#id1257">Overview:</a><a class="headerlink" href="#id258" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">sitofp</span></tt>‘ instruction regards <tt class="docutils literal"><span class="pre">value</span></tt> as a signed integer and
+converts that value to the <tt class="docutils literal"><span class="pre">ty2</span></tt> type.</p>
+</div>
+<div class="section" id="id259">
+<h5><a class="toc-backref" href="#id1258">Arguments:</a><a class="headerlink" href="#id259" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">sitofp</span></tt>‘ instruction takes a value to cast, which must be a
+scalar or vector <a class="reference internal" href="#t-integer"><em>integer</em></a> value, and a type to cast it to
+<tt class="docutils literal"><span class="pre">ty2</span></tt>, which must be an <a class="reference internal" href="#t-floating"><em>floating point</em></a> type. If
+<tt class="docutils literal"><span class="pre">ty</span></tt> is a vector integer type, <tt class="docutils literal"><span class="pre">ty2</span></tt> must be a vector floating point
+type with the same number of elements as <tt class="docutils literal"><span class="pre">ty</span></tt></p>
+</div>
+<div class="section" id="id260">
+<h5><a class="toc-backref" href="#id1259">Semantics:</a><a class="headerlink" href="#id260" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">sitofp</span></tt>‘ instruction interprets its operand as a signed integer
+quantity and converts it to the corresponding floating point value. If
+the value cannot fit in the floating point value, the results are
+undefined.</p>
+</div>
+<div class="section" id="id261">
+<h5><a class="toc-backref" href="#id1260">Example:</a><a class="headerlink" href="#id261" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%X</span> <span class="p">=</span> <span class="k">sitofp</span> <span class="k">i32</span> <span class="m">257</span> <span class="k">to</span> <span class="kt">float</span>         <span class="c">; yields float:257.0</span>
+<span class="nv">%Y</span> <span class="p">=</span> <span class="k">sitofp</span> <span class="k">i8</span> <span class="m">-1</span> <span class="k">to</span> <span class="kt">double</span>          <span class="c">; yields double:-1.0</span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="ptrtoint-to-instruction">
+<span id="i-ptrtoint"></span><h4><a class="toc-backref" href="#id1261">‘<tt class="docutils literal"><span class="pre">ptrtoint</span> <span class="pre">..</span> <span class="pre">to</span></tt>‘ Instruction</a><a class="headerlink" href="#ptrtoint-to-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id262">
+<h5><a class="toc-backref" href="#id1262">Syntax:</a><a class="headerlink" href="#id262" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = ptrtoint <ty> <value> to <ty2>             ; yields ty2</pre>
+</div>
+</div>
+<div class="section" id="id263">
+<h5><a class="toc-backref" href="#id1263">Overview:</a><a class="headerlink" href="#id263" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">ptrtoint</span></tt>‘ instruction converts the pointer or a vector of
+pointers <tt class="docutils literal"><span class="pre">value</span></tt> to the integer (or vector of integers) type <tt class="docutils literal"><span class="pre">ty2</span></tt>.</p>
+</div>
+<div class="section" id="id264">
+<h5><a class="toc-backref" href="#id1264">Arguments:</a><a class="headerlink" href="#id264" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">ptrtoint</span></tt>‘ instruction takes a <tt class="docutils literal"><span class="pre">value</span></tt> to cast, which must be
+a value of type <a class="reference internal" href="#t-pointer"><em>pointer</em></a> or a vector of pointers, and a
+type to cast it to <tt class="docutils literal"><span class="pre">ty2</span></tt>, which must be an <a class="reference internal" href="#t-integer"><em>integer</em></a> or
+a vector of integers type.</p>
+</div>
+<div class="section" id="id265">
+<h5><a class="toc-backref" href="#id1265">Semantics:</a><a class="headerlink" href="#id265" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">ptrtoint</span></tt>‘ instruction converts <tt class="docutils literal"><span class="pre">value</span></tt> to integer type
+<tt class="docutils literal"><span class="pre">ty2</span></tt> by interpreting the pointer value as an integer and either
+truncating or zero extending that value to the size of the integer type.
+If <tt class="docutils literal"><span class="pre">value</span></tt> is smaller than <tt class="docutils literal"><span class="pre">ty2</span></tt> then a zero extension is done. If
+<tt class="docutils literal"><span class="pre">value</span></tt> is larger than <tt class="docutils literal"><span class="pre">ty2</span></tt> then a truncation is done. If they are
+the same size, then nothing is done (<em>no-op cast</em>) other than a type
+change.</p>
+</div>
+<div class="section" id="id266">
+<h5><a class="toc-backref" href="#id1266">Example:</a><a class="headerlink" href="#id266" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%X</span> <span class="p">=</span> <span class="k">ptrtoint</span> <span class="k">i32</span><span class="p">*</span> <span class="nv">%P</span> <span class="k">to</span> <span class="k">i8</span>                         <span class="c">; yields truncation on 32-bit architecture</span>
+<span class="nv">%Y</span> <span class="p">=</span> <span class="k">ptrtoint</span> <span class="k">i32</span><span class="p">*</span> <span class="nv">%P</span> <span class="k">to</span> <span class="k">i64</span>                        <span class="c">; yields zero extension on 32-bit architecture</span>
+<span class="nv">%Z</span> <span class="p">=</span> <span class="k">ptrtoint</span> <span class="p"><</span><span class="m">4</span> <span class="k">x</span> <span class="k">i32</span><span class="p">*></span> <span class="nv">%P</span> <span class="k">to</span> <span class="p"><</span><span class="m">4</span> <span class="k">x</span> <span class="k">i64</span><span class="p">></span><span class="c">; yields vector zero extension for a vector of addresses on 32-bit architecture</span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="inttoptr-to-instruction">
+<span id="i-inttoptr"></span><h4><a class="toc-backref" href="#id1267">‘<tt class="docutils literal"><span class="pre">inttoptr</span> <span class="pre">..</span> <span class="pre">to</span></tt>‘ Instruction</a><a class="headerlink" href="#inttoptr-to-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id267">
+<h5><a class="toc-backref" href="#id1268">Syntax:</a><a class="headerlink" href="#id267" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = inttoptr <ty> <value> to <ty2>             ; yields ty2</pre>
+</div>
+</div>
+<div class="section" id="id268">
+<h5><a class="toc-backref" href="#id1269">Overview:</a><a class="headerlink" href="#id268" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">inttoptr</span></tt>‘ instruction converts an integer <tt class="docutils literal"><span class="pre">value</span></tt> to a
+pointer type, <tt class="docutils literal"><span class="pre">ty2</span></tt>.</p>
+</div>
+<div class="section" id="id269">
+<h5><a class="toc-backref" href="#id1270">Arguments:</a><a class="headerlink" href="#id269" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">inttoptr</span></tt>‘ instruction takes an <a class="reference internal" href="#t-integer"><em>integer</em></a> value to
+cast, and a type to cast it to, which must be a <a class="reference internal" href="#t-pointer"><em>pointer</em></a>
+type.</p>
+</div>
+<div class="section" id="id270">
+<h5><a class="toc-backref" href="#id1271">Semantics:</a><a class="headerlink" href="#id270" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">inttoptr</span></tt>‘ instruction converts <tt class="docutils literal"><span class="pre">value</span></tt> to type <tt class="docutils literal"><span class="pre">ty2</span></tt> by
+applying either a zero extension or a truncation depending on the size
+of the integer <tt class="docutils literal"><span class="pre">value</span></tt>. If <tt class="docutils literal"><span class="pre">value</span></tt> is larger than the size of a
+pointer then a truncation is done. If <tt class="docutils literal"><span class="pre">value</span></tt> is smaller than the size
+of a pointer then a zero extension is done. If they are the same size,
+nothing is done (<em>no-op cast</em>).</p>
+</div>
+<div class="section" id="id271">
+<h5><a class="toc-backref" href="#id1272">Example:</a><a class="headerlink" href="#id271" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%X</span> <span class="p">=</span> <span class="k">inttoptr</span> <span class="k">i32</span> <span class="m">255</span> <span class="k">to</span> <span class="k">i32</span><span class="p">*</span>          <span class="c">; yields zero extension on 64-bit architecture</span>
+<span class="nv">%Y</span> <span class="p">=</span> <span class="k">inttoptr</span> <span class="k">i32</span> <span class="m">255</span> <span class="k">to</span> <span class="k">i32</span><span class="p">*</span>          <span class="c">; yields no-op on 32-bit architecture</span>
+<span class="nv">%Z</span> <span class="p">=</span> <span class="k">inttoptr</span> <span class="k">i64</span> <span class="m">0</span> <span class="k">to</span> <span class="k">i32</span><span class="p">*</span>            <span class="c">; yields truncation on 32-bit architecture</span>
+<span class="nv">%Z</span> <span class="p">=</span> <span class="k">inttoptr</span> <span class="p"><</span><span class="m">4</span> <span class="k">x</span> <span class="k">i32</span><span class="p">></span> <span class="nv">%G</span> <span class="k">to</span> <span class="p"><</span><span class="m">4</span> <span class="k">x</span> <span class="k">i8</span><span class="p">*></span><span class="c">; yields truncation of vector G to four pointers</span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="bitcast-to-instruction">
+<span id="i-bitcast"></span><h4><a class="toc-backref" href="#id1273">‘<tt class="docutils literal"><span class="pre">bitcast</span> <span class="pre">..</span> <span class="pre">to</span></tt>‘ Instruction</a><a class="headerlink" href="#bitcast-to-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id272">
+<h5><a class="toc-backref" href="#id1274">Syntax:</a><a class="headerlink" href="#id272" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = bitcast <ty> <value> to <ty2>             ; yields ty2</pre>
+</div>
+</div>
+<div class="section" id="id273">
+<h5><a class="toc-backref" href="#id1275">Overview:</a><a class="headerlink" href="#id273" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">bitcast</span></tt>‘ instruction converts <tt class="docutils literal"><span class="pre">value</span></tt> to type <tt class="docutils literal"><span class="pre">ty2</span></tt> without
+changing any bits.</p>
+</div>
+<div class="section" id="id274">
+<h5><a class="toc-backref" href="#id1276">Arguments:</a><a class="headerlink" href="#id274" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">bitcast</span></tt>‘ instruction takes a value to cast, which must be a
+non-aggregate first class value, and a type to cast it to, which must
+also be a non-aggregate <a class="reference internal" href="#t-firstclass"><em>first class</em></a> type. The
+bit sizes of <tt class="docutils literal"><span class="pre">value</span></tt> and the destination type, <tt class="docutils literal"><span class="pre">ty2</span></tt>, must be
+identical. If the source type is a pointer, the destination type must
+also be a pointer of the same size. This instruction supports bitwise
+conversion of vectors to integers and to vectors of other types (as
+long as they have the same size).</p>
+</div>
+<div class="section" id="id275">
+<h5><a class="toc-backref" href="#id1277">Semantics:</a><a class="headerlink" href="#id275" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">bitcast</span></tt>‘ instruction converts <tt class="docutils literal"><span class="pre">value</span></tt> to type <tt class="docutils literal"><span class="pre">ty2</span></tt>. It
+is always a <em>no-op cast</em> because no bits change with this
+conversion. The conversion is done as if the <tt class="docutils literal"><span class="pre">value</span></tt> had been stored
+to memory and read back as type <tt class="docutils literal"><span class="pre">ty2</span></tt>. Pointer (or vector of
+pointers) types may only be converted to other pointer (or vector of
+pointers) types with the same address space through this instruction.
+To convert pointers to other types, use the <a class="reference internal" href="#i-inttoptr"><em>inttoptr</em></a>
+or <a class="reference internal" href="#i-ptrtoint"><em>ptrtoint</em></a> instructions first.</p>
+</div>
+<div class="section" id="id276">
+<h5><a class="toc-backref" href="#id1278">Example:</a><a class="headerlink" href="#id276" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre>%X = bitcast i8 255 to i8              ; yields i8 :-1
+%Y = bitcast i32* %x to sint*          ; yields sint*:%x
+%Z = bitcast <2 x int> %V to i64;        ; yields i64: %V
+%Z = bitcast <2 x i32*> %V to <2 x i64*> ; yields <2 x i64*>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="addrspacecast-to-instruction">
+<span id="i-addrspacecast"></span><h4><a class="toc-backref" href="#id1279">‘<tt class="docutils literal"><span class="pre">addrspacecast</span> <span class="pre">..</span> <span class="pre">to</span></tt>‘ Instruction</a><a class="headerlink" href="#addrspacecast-to-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id277">
+<h5><a class="toc-backref" href="#id1280">Syntax:</a><a class="headerlink" href="#id277" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = addrspacecast <pty> <ptrval> to <pty2>       ; yields pty2</pre>
+</div>
+</div>
+<div class="section" id="id278">
+<h5><a class="toc-backref" href="#id1281">Overview:</a><a class="headerlink" href="#id278" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">addrspacecast</span></tt>‘ instruction converts <tt class="docutils literal"><span class="pre">ptrval</span></tt> from <tt class="docutils literal"><span class="pre">pty</span></tt> in
+address space <tt class="docutils literal"><span class="pre">n</span></tt> to type <tt class="docutils literal"><span class="pre">pty2</span></tt> in address space <tt class="docutils literal"><span class="pre">m</span></tt>.</p>
+</div>
+<div class="section" id="id279">
+<h5><a class="toc-backref" href="#id1282">Arguments:</a><a class="headerlink" href="#id279" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">addrspacecast</span></tt>‘ instruction takes a pointer or vector of pointer value
+to cast and a pointer type to cast it to, which must have a different
+address space.</p>
+</div>
+<div class="section" id="id280">
+<h5><a class="toc-backref" href="#id1283">Semantics:</a><a class="headerlink" href="#id280" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">addrspacecast</span></tt>‘ instruction converts the pointer value
+<tt class="docutils literal"><span class="pre">ptrval</span></tt> to type <tt class="docutils literal"><span class="pre">pty2</span></tt>. It can be a <em>no-op cast</em> or a complex
+value modification, depending on the target and the address space
+pair. Pointer conversions within the same address space must be
+performed with the <tt class="docutils literal"><span class="pre">bitcast</span></tt> instruction. Note that if the address space
+conversion is legal then both result and operand refer to the same memory
+location.</p>
+</div>
+<div class="section" id="id281">
+<h5><a class="toc-backref" href="#id1284">Example:</a><a class="headerlink" href="#id281" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><pre>%X = addrspacecast i32* %x to i32 addrspace(1)*    ; yields i32 addrspace(1)*:%x
+%Y = addrspacecast i32 addrspace(1)* %y to i64 addrspace(2)*    ; yields i64 addrspace(2)*:%y
+%Z = addrspacecast <4 x i32*> %z to <4 x float addrspace(3)*>   ; yields <4 x float addrspace(3)*>:%z</pre>
+</div>
+</div>
+</div>
+</div>
+<div class="section" id="other-operations">
+<span id="otherops"></span><h3><a class="toc-backref" href="#id1285">Other Operations</a><a class="headerlink" href="#other-operations" title="Permalink to this headline">¶</a></h3>
+<p>The instructions in this category are the “miscellaneous” instructions,
+which defy better classification.</p>
+<div class="section" id="icmp-instruction">
+<span id="i-icmp"></span><h4><a class="toc-backref" href="#id1286">‘<tt class="docutils literal"><span class="pre">icmp</span></tt>‘ Instruction</a><a class="headerlink" href="#icmp-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id282">
+<h5><a class="toc-backref" href="#id1287">Syntax:</a><a class="headerlink" href="#id282" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = icmp <cond> <ty> <op1>, <op2>   ; yields i1 or <N x i1>:result</pre>
+</div>
+</div>
+<div class="section" id="id283">
+<h5><a class="toc-backref" href="#id1288">Overview:</a><a class="headerlink" href="#id283" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">icmp</span></tt>‘ instruction returns a boolean value or a vector of
+boolean values based on comparison of its two integer, integer vector,
+pointer, or pointer vector operands.</p>
+</div>
+<div class="section" id="id284">
+<h5><a class="toc-backref" href="#id1289">Arguments:</a><a class="headerlink" href="#id284" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">icmp</span></tt>‘ instruction takes three operands. The first operand is
+the condition code indicating the kind of comparison to perform. It is
+not a value, just a keyword. The possible condition codes are:</p>
+<ol class="arabic simple">
+<li><tt class="docutils literal"><span class="pre">eq</span></tt>: equal</li>
+<li><tt class="docutils literal"><span class="pre">ne</span></tt>: not equal</li>
+<li><tt class="docutils literal"><span class="pre">ugt</span></tt>: unsigned greater than</li>
+<li><tt class="docutils literal"><span class="pre">uge</span></tt>: unsigned greater or equal</li>
+<li><tt class="docutils literal"><span class="pre">ult</span></tt>: unsigned less than</li>
+<li><tt class="docutils literal"><span class="pre">ule</span></tt>: unsigned less or equal</li>
+<li><tt class="docutils literal"><span class="pre">sgt</span></tt>: signed greater than</li>
+<li><tt class="docutils literal"><span class="pre">sge</span></tt>: signed greater or equal</li>
+<li><tt class="docutils literal"><span class="pre">slt</span></tt>: signed less than</li>
+<li><tt class="docutils literal"><span class="pre">sle</span></tt>: signed less or equal</li>
+</ol>
+<p>The remaining two arguments must be <a class="reference internal" href="#t-integer"><em>integer</em></a> or
+<a class="reference internal" href="#t-pointer"><em>pointer</em></a> or integer <a class="reference internal" href="#t-vector"><em>vector</em></a> typed. They
+must also be identical types.</p>
+</div>
+<div class="section" id="id285">
+<h5><a class="toc-backref" href="#id1290">Semantics:</a><a class="headerlink" href="#id285" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">icmp</span></tt>‘ compares <tt class="docutils literal"><span class="pre">op1</span></tt> and <tt class="docutils literal"><span class="pre">op2</span></tt> according to the condition
+code given as <tt class="docutils literal"><span class="pre">cond</span></tt>. The comparison performed always yields either an
+<a class="reference internal" href="#t-integer"><em>i1</em></a> or vector of <tt class="docutils literal"><span class="pre">i1</span></tt> result, as follows:</p>
+<ol class="arabic simple">
+<li><tt class="docutils literal"><span class="pre">eq</span></tt>: yields <tt class="docutils literal"><span class="pre">true</span></tt> if the operands are equal, <tt class="docutils literal"><span class="pre">false</span></tt>
+otherwise. No sign interpretation is necessary or performed.</li>
+<li><tt class="docutils literal"><span class="pre">ne</span></tt>: yields <tt class="docutils literal"><span class="pre">true</span></tt> if the operands are unequal, <tt class="docutils literal"><span class="pre">false</span></tt>
+otherwise. No sign interpretation is necessary or performed.</li>
+<li><tt class="docutils literal"><span class="pre">ugt</span></tt>: interprets the operands as unsigned values and yields
+<tt class="docutils literal"><span class="pre">true</span></tt> if <tt class="docutils literal"><span class="pre">op1</span></tt> is greater than <tt class="docutils literal"><span class="pre">op2</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">uge</span></tt>: interprets the operands as unsigned values and yields
+<tt class="docutils literal"><span class="pre">true</span></tt> if <tt class="docutils literal"><span class="pre">op1</span></tt> is greater than or equal to <tt class="docutils literal"><span class="pre">op2</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">ult</span></tt>: interprets the operands as unsigned values and yields
+<tt class="docutils literal"><span class="pre">true</span></tt> if <tt class="docutils literal"><span class="pre">op1</span></tt> is less than <tt class="docutils literal"><span class="pre">op2</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">ule</span></tt>: interprets the operands as unsigned values and yields
+<tt class="docutils literal"><span class="pre">true</span></tt> if <tt class="docutils literal"><span class="pre">op1</span></tt> is less than or equal to <tt class="docutils literal"><span class="pre">op2</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">sgt</span></tt>: interprets the operands as signed values and yields <tt class="docutils literal"><span class="pre">true</span></tt>
+if <tt class="docutils literal"><span class="pre">op1</span></tt> is greater than <tt class="docutils literal"><span class="pre">op2</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">sge</span></tt>: interprets the operands as signed values and yields <tt class="docutils literal"><span class="pre">true</span></tt>
+if <tt class="docutils literal"><span class="pre">op1</span></tt> is greater than or equal to <tt class="docutils literal"><span class="pre">op2</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">slt</span></tt>: interprets the operands as signed values and yields <tt class="docutils literal"><span class="pre">true</span></tt>
+if <tt class="docutils literal"><span class="pre">op1</span></tt> is less than <tt class="docutils literal"><span class="pre">op2</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">sle</span></tt>: interprets the operands as signed values and yields <tt class="docutils literal"><span class="pre">true</span></tt>
+if <tt class="docutils literal"><span class="pre">op1</span></tt> is less than or equal to <tt class="docutils literal"><span class="pre">op2</span></tt>.</li>
+</ol>
+<p>If the operands are <a class="reference internal" href="#t-pointer"><em>pointer</em></a> typed, the pointer values
+are compared as if they were integers.</p>
+<p>If the operands are integer vectors, then they are compared element by
+element. The result is an <tt class="docutils literal"><span class="pre">i1</span></tt> vector with the same number of elements
+as the values being compared. Otherwise, the result is an <tt class="docutils literal"><span class="pre">i1</span></tt>.</p>
+</div>
+<div class="section" id="id286">
+<h5><a class="toc-backref" href="#id1291">Example:</a><a class="headerlink" href="#id286" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre><result> = icmp eq i32 4, 5          ; yields: result=false
+<result> = icmp ne float* %X, %X     ; yields: result=false
+<result> = icmp ult i16  4, 5        ; yields: result=true
+<result> = icmp sgt i16  4, 5        ; yields: result=false
+<result> = icmp ule i16 -4, 5        ; yields: result=false
+<result> = icmp sge i16  4, 5        ; yields: result=false
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="fcmp-instruction">
+<span id="i-fcmp"></span><h4><a class="toc-backref" href="#id1292">‘<tt class="docutils literal"><span class="pre">fcmp</span></tt>‘ Instruction</a><a class="headerlink" href="#fcmp-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id287">
+<h5><a class="toc-backref" href="#id1293">Syntax:</a><a class="headerlink" href="#id287" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = fcmp [fast-math flags]* <cond> <ty> <op1>, <op2>     ; yields i1 or <N x i1>:result</pre>
+</div>
+</div>
+<div class="section" id="id288">
+<h5><a class="toc-backref" href="#id1294">Overview:</a><a class="headerlink" href="#id288" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">fcmp</span></tt>‘ instruction returns a boolean value or vector of boolean
+values based on comparison of its operands.</p>
+<p>If the operands are floating point scalars, then the result type is a
+boolean (<a class="reference internal" href="#t-integer"><em>i1</em></a>).</p>
+<p>If the operands are floating point vectors, then the result type is a
+vector of boolean with the same number of elements as the operands being
+compared.</p>
+</div>
+<div class="section" id="id289">
+<h5><a class="toc-backref" href="#id1295">Arguments:</a><a class="headerlink" href="#id289" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">fcmp</span></tt>‘ instruction takes three operands. The first operand is
+the condition code indicating the kind of comparison to perform. It is
+not a value, just a keyword. The possible condition codes are:</p>
+<ol class="arabic simple">
+<li><tt class="docutils literal"><span class="pre">false</span></tt>: no comparison, always returns false</li>
+<li><tt class="docutils literal"><span class="pre">oeq</span></tt>: ordered and equal</li>
+<li><tt class="docutils literal"><span class="pre">ogt</span></tt>: ordered and greater than</li>
+<li><tt class="docutils literal"><span class="pre">oge</span></tt>: ordered and greater than or equal</li>
+<li><tt class="docutils literal"><span class="pre">olt</span></tt>: ordered and less than</li>
+<li><tt class="docutils literal"><span class="pre">ole</span></tt>: ordered and less than or equal</li>
+<li><tt class="docutils literal"><span class="pre">one</span></tt>: ordered and not equal</li>
+<li><tt class="docutils literal"><span class="pre">ord</span></tt>: ordered (no nans)</li>
+<li><tt class="docutils literal"><span class="pre">ueq</span></tt>: unordered or equal</li>
+<li><tt class="docutils literal"><span class="pre">ugt</span></tt>: unordered or greater than</li>
+<li><tt class="docutils literal"><span class="pre">uge</span></tt>: unordered or greater than or equal</li>
+<li><tt class="docutils literal"><span class="pre">ult</span></tt>: unordered or less than</li>
+<li><tt class="docutils literal"><span class="pre">ule</span></tt>: unordered or less than or equal</li>
+<li><tt class="docutils literal"><span class="pre">une</span></tt>: unordered or not equal</li>
+<li><tt class="docutils literal"><span class="pre">uno</span></tt>: unordered (either nans)</li>
+<li><tt class="docutils literal"><span class="pre">true</span></tt>: no comparison, always returns true</li>
+</ol>
+<p><em>Ordered</em> means that neither operand is a QNAN while <em>unordered</em> means
+that either operand may be a QNAN.</p>
+<p>Each of <tt class="docutils literal"><span class="pre">val1</span></tt> and <tt class="docutils literal"><span class="pre">val2</span></tt> arguments must be either a <a class="reference internal" href="#t-floating"><em>floating
+point</em></a> type or a <a class="reference internal" href="#t-vector"><em>vector</em></a> of floating point
+type. They must have identical types.</p>
+</div>
+<div class="section" id="id290">
+<h5><a class="toc-backref" href="#id1296">Semantics:</a><a class="headerlink" href="#id290" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">fcmp</span></tt>‘ instruction compares <tt class="docutils literal"><span class="pre">op1</span></tt> and <tt class="docutils literal"><span class="pre">op2</span></tt> according to the
+condition code given as <tt class="docutils literal"><span class="pre">cond</span></tt>. If the operands are vectors, then the
+vectors are compared element by element. Each comparison performed
+always yields an <a class="reference internal" href="#t-integer"><em>i1</em></a> result, as follows:</p>
+<ol class="arabic simple">
+<li><tt class="docutils literal"><span class="pre">false</span></tt>: always yields <tt class="docutils literal"><span class="pre">false</span></tt>, regardless of operands.</li>
+<li><tt class="docutils literal"><span class="pre">oeq</span></tt>: yields <tt class="docutils literal"><span class="pre">true</span></tt> if both operands are not a QNAN and <tt class="docutils literal"><span class="pre">op1</span></tt>
+is equal to <tt class="docutils literal"><span class="pre">op2</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">ogt</span></tt>: yields <tt class="docutils literal"><span class="pre">true</span></tt> if both operands are not a QNAN and <tt class="docutils literal"><span class="pre">op1</span></tt>
+is greater than <tt class="docutils literal"><span class="pre">op2</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">oge</span></tt>: yields <tt class="docutils literal"><span class="pre">true</span></tt> if both operands are not a QNAN and <tt class="docutils literal"><span class="pre">op1</span></tt>
+is greater than or equal to <tt class="docutils literal"><span class="pre">op2</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">olt</span></tt>: yields <tt class="docutils literal"><span class="pre">true</span></tt> if both operands are not a QNAN and <tt class="docutils literal"><span class="pre">op1</span></tt>
+is less than <tt class="docutils literal"><span class="pre">op2</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">ole</span></tt>: yields <tt class="docutils literal"><span class="pre">true</span></tt> if both operands are not a QNAN and <tt class="docutils literal"><span class="pre">op1</span></tt>
+is less than or equal to <tt class="docutils literal"><span class="pre">op2</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">one</span></tt>: yields <tt class="docutils literal"><span class="pre">true</span></tt> if both operands are not a QNAN and <tt class="docutils literal"><span class="pre">op1</span></tt>
+is not equal to <tt class="docutils literal"><span class="pre">op2</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">ord</span></tt>: yields <tt class="docutils literal"><span class="pre">true</span></tt> if both operands are not a QNAN.</li>
+<li><tt class="docutils literal"><span class="pre">ueq</span></tt>: yields <tt class="docutils literal"><span class="pre">true</span></tt> if either operand is a QNAN or <tt class="docutils literal"><span class="pre">op1</span></tt> is
+equal to <tt class="docutils literal"><span class="pre">op2</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">ugt</span></tt>: yields <tt class="docutils literal"><span class="pre">true</span></tt> if either operand is a QNAN or <tt class="docutils literal"><span class="pre">op1</span></tt> is
+greater than <tt class="docutils literal"><span class="pre">op2</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">uge</span></tt>: yields <tt class="docutils literal"><span class="pre">true</span></tt> if either operand is a QNAN or <tt class="docutils literal"><span class="pre">op1</span></tt> is
+greater than or equal to <tt class="docutils literal"><span class="pre">op2</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">ult</span></tt>: yields <tt class="docutils literal"><span class="pre">true</span></tt> if either operand is a QNAN or <tt class="docutils literal"><span class="pre">op1</span></tt> is
+less than <tt class="docutils literal"><span class="pre">op2</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">ule</span></tt>: yields <tt class="docutils literal"><span class="pre">true</span></tt> if either operand is a QNAN or <tt class="docutils literal"><span class="pre">op1</span></tt> is
+less than or equal to <tt class="docutils literal"><span class="pre">op2</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">une</span></tt>: yields <tt class="docutils literal"><span class="pre">true</span></tt> if either operand is a QNAN or <tt class="docutils literal"><span class="pre">op1</span></tt> is
+not equal to <tt class="docutils literal"><span class="pre">op2</span></tt>.</li>
+<li><tt class="docutils literal"><span class="pre">uno</span></tt>: yields <tt class="docutils literal"><span class="pre">true</span></tt> if either operand is a QNAN.</li>
+<li><tt class="docutils literal"><span class="pre">true</span></tt>: always yields <tt class="docutils literal"><span class="pre">true</span></tt>, regardless of operands.</li>
+</ol>
+<p>The <tt class="docutils literal"><span class="pre">fcmp</span></tt> instruction can also optionally take any number of
+<a class="reference internal" href="#fastmath"><em>fast-math flags</em></a>, which are optimization hints to enable
+otherwise unsafe floating point optimizations.</p>
+<p>Any set of fast-math flags are legal on an <tt class="docutils literal"><span class="pre">fcmp</span></tt> instruction, but the
+only flags that have any effect on its semantics are those that allow
+assumptions to be made about the values of input arguments; namely
+<tt class="docutils literal"><span class="pre">nnan</span></tt>, <tt class="docutils literal"><span class="pre">ninf</span></tt>, and <tt class="docutils literal"><span class="pre">nsz</span></tt>. See <a class="reference internal" href="#fastmath"><em>Fast-Math Flags</em></a> for more information.</p>
+</div>
+<div class="section" id="id291">
+<h5><a class="toc-backref" href="#id1297">Example:</a><a class="headerlink" href="#id291" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre><result> = fcmp oeq float 4.0, 5.0    ; yields: result=false
+<result> = fcmp one float 4.0, 5.0    ; yields: result=true
+<result> = fcmp olt float 4.0, 5.0    ; yields: result=true
+<result> = fcmp ueq double 1.0, 2.0   ; yields: result=false
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="phi-instruction">
+<span id="i-phi"></span><h4><a class="toc-backref" href="#id1298">‘<tt class="docutils literal"><span class="pre">phi</span></tt>‘ Instruction</a><a class="headerlink" href="#phi-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id292">
+<h5><a class="toc-backref" href="#id1299">Syntax:</a><a class="headerlink" href="#id292" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = phi <ty> [ <val0>, <label0>], ...</pre>
+</div>
+</div>
+<div class="section" id="id293">
+<h5><a class="toc-backref" href="#id1300">Overview:</a><a class="headerlink" href="#id293" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">phi</span></tt>‘ instruction is used to implement the φ node in the SSA
+graph representing the function.</p>
+</div>
+<div class="section" id="id294">
+<h5><a class="toc-backref" href="#id1301">Arguments:</a><a class="headerlink" href="#id294" title="Permalink to this headline">¶</a></h5>
+<p>The type of the incoming values is specified with the first type field.
+After this, the ‘<tt class="docutils literal"><span class="pre">phi</span></tt>‘ instruction takes a list of pairs as
+arguments, with one pair for each predecessor basic block of the current
+block. Only values of <a class="reference internal" href="#t-firstclass"><em>first class</em></a> type may be used as
+the value arguments to the PHI node. Only labels may be used as the
+label arguments.</p>
+<p>There must be no non-phi instructions between the start of a basic block
+and the PHI instructions: i.e. PHI instructions must be first in a basic
+block.</p>
+<p>For the purposes of the SSA form, the use of each incoming value is
+deemed to occur on the edge from the corresponding predecessor block to
+the current block (but after any definition of an ‘<tt class="docutils literal"><span class="pre">invoke</span></tt>‘
+instruction’s return value on the same edge).</p>
+</div>
+<div class="section" id="id295">
+<h5><a class="toc-backref" href="#id1302">Semantics:</a><a class="headerlink" href="#id295" title="Permalink to this headline">¶</a></h5>
+<p>At runtime, the ‘<tt class="docutils literal"><span class="pre">phi</span></tt>‘ instruction logically takes on the value
+specified by the pair corresponding to the predecessor basic block that
+executed just prior to the current block.</p>
+</div>
+<div class="section" id="id296">
+<h5><a class="toc-backref" href="#id1303">Example:</a><a class="headerlink" href="#id296" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nl">Loop:</span>       <span class="c">; Infinite loop that counts from 0 on up...</span>
+  <span class="nv">%indvar</span> <span class="p">=</span> <span class="k">phi</span> <span class="k">i32</span> <span class="p">[</span> <span class="m">0</span><span class="p">,</span> <span class="nv">%LoopHeader</span> <span class="p">],</span> <span class="p">[</span> <span class="nv">%nextindvar</span><span class="p">,</span> <span class="nv">%Loop</span> <span class="p">]</span>
+  <span class="nv">%nextindvar</span> <span class="p">=</span> <span class="k">add</span> <span class="k">i32</span> <span class="nv">%indvar</span><span class="p">,</span> <span class="m">1</span>
+  <span class="k">br</span> <span class="kt">label</span> <span class="nv">%Loop</span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="select-instruction">
+<span id="i-select"></span><h4><a class="toc-backref" href="#id1304">‘<tt class="docutils literal"><span class="pre">select</span></tt>‘ Instruction</a><a class="headerlink" href="#select-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id297">
+<h5><a class="toc-backref" href="#id1305">Syntax:</a><a class="headerlink" href="#id297" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = select selty <cond>, <ty> <val1>, <ty> <val2>             ; yields ty
+
+selty is either i1 or {<N x i1>}</pre>
+</div>
+</div>
+<div class="section" id="id298">
+<h5><a class="toc-backref" href="#id1306">Overview:</a><a class="headerlink" href="#id298" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">select</span></tt>‘ instruction is used to choose one value based on a
+condition, without IR-level branching.</p>
+</div>
+<div class="section" id="id299">
+<h5><a class="toc-backref" href="#id1307">Arguments:</a><a class="headerlink" href="#id299" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">select</span></tt>‘ instruction requires an ‘i1’ value or a vector of ‘i1’
+values indicating the condition, and two values of the same <a class="reference internal" href="#t-firstclass"><em>first
+class</em></a> type.</p>
+</div>
+<div class="section" id="id300">
+<h5><a class="toc-backref" href="#id1308">Semantics:</a><a class="headerlink" href="#id300" title="Permalink to this headline">¶</a></h5>
+<p>If the condition is an i1 and it evaluates to 1, the instruction returns
+the first value argument; otherwise, it returns the second value
+argument.</p>
+<p>If the condition is a vector of i1, then the value arguments must be
+vectors of the same size, and the selection is done element by element.</p>
+<p>If the condition is an i1 and the value arguments are vectors of the
+same size, then an entire vector is selected.</p>
+</div>
+<div class="section" id="id301">
+<h5><a class="toc-backref" href="#id1309">Example:</a><a class="headerlink" href="#id301" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%X</span> <span class="p">=</span> <span class="k">select</span> <span class="k">i1</span> <span class="k">true</span><span class="p">,</span> <span class="k">i8</span> <span class="m">17</span><span class="p">,</span> <span class="k">i8</span> <span class="m">42</span>          <span class="c">; yields i8:17</span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="call-instruction">
+<span id="i-call"></span><h4><a class="toc-backref" href="#id1310">‘<tt class="docutils literal"><span class="pre">call</span></tt>‘ Instruction</a><a class="headerlink" href="#call-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id302">
+<h5><a class="toc-backref" href="#id1311">Syntax:</a><a class="headerlink" href="#id302" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><result> = [tail | musttail | notail ] call [fast-math flags] [cconv] [ret attrs] <ty>|<fnty> <fnptrval>(<function args>) [fn attrs]
+             [ operand bundles ]</pre>
+</div>
+</div>
+<div class="section" id="id303">
+<h5><a class="toc-backref" href="#id1312">Overview:</a><a class="headerlink" href="#id303" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">call</span></tt>‘ instruction represents a simple function call.</p>
+</div>
+<div class="section" id="id304">
+<h5><a class="toc-backref" href="#id1313">Arguments:</a><a class="headerlink" href="#id304" title="Permalink to this headline">¶</a></h5>
+<p>This instruction requires several arguments:</p>
+<ol class="arabic">
+<li><p class="first">The optional <tt class="docutils literal"><span class="pre">tail</span></tt> and <tt class="docutils literal"><span class="pre">musttail</span></tt> markers indicate that the optimizers
+should perform tail call optimization. The <tt class="docutils literal"><span class="pre">tail</span></tt> marker is a hint that
+<a class="reference external" href="CodeGenerator.html#sibcallopt">can be ignored</a>. The <tt class="docutils literal"><span class="pre">musttail</span></tt> marker
+means that the call must be tail call optimized in order for the program to
+be correct. The <tt class="docutils literal"><span class="pre">musttail</span></tt> marker provides these guarantees:</p>
+<ol class="arabic simple">
+<li>The call will not cause unbounded stack growth if it is part of a
+recursive cycle in the call graph.</li>
+<li>Arguments with the <a class="reference internal" href="#attr-inalloca"><em>inalloca</em></a> attribute are
+forwarded in place.</li>
+</ol>
+<p>Both markers imply that the callee does not access allocas or varargs from
+the caller. Calls marked <tt class="docutils literal"><span class="pre">musttail</span></tt> must obey the following additional
+rules:</p>
+<ul class="simple">
+<li>The call must immediately precede a <a class="reference internal" href="#i-ret"><em>ret</em></a> instruction,
+or a pointer bitcast followed by a ret instruction.</li>
+<li>The ret instruction must return the (possibly bitcasted) value
+produced by the call or void.</li>
+<li>The caller and callee prototypes must match. Pointer types of
+parameters or return types may differ in pointee type, but not
+in address space.</li>
+<li>The calling conventions of the caller and callee must match.</li>
+<li>All ABI-impacting function attributes, such as sret, byval, inreg,
+returned, and inalloca, must match.</li>
+<li>The callee must be varargs iff the caller is varargs. Bitcasting a
+non-varargs function to the appropriate varargs type is legal so
+long as the non-varargs prefixes obey the other rules.</li>
+</ul>
+<p>Tail call optimization for calls marked <tt class="docutils literal"><span class="pre">tail</span></tt> is guaranteed to occur if
+the following conditions are met:</p>
+<ul class="simple">
+<li>Caller and callee both have the calling convention <tt class="docutils literal"><span class="pre">fastcc</span></tt>.</li>
+<li>The call is in tail position (ret immediately follows call and ret
+uses value of call or is void).</li>
+<li>Option <tt class="docutils literal"><span class="pre">-tailcallopt</span></tt> is enabled, or
+<tt class="docutils literal"><span class="pre">llvm::GuaranteedTailCallOpt</span></tt> is <tt class="docutils literal"><span class="pre">true</span></tt>.</li>
+<li><a class="reference external" href="CodeGenerator.html#tailcallopt">Platform-specific constraints are
+met.</a></li>
+</ul>
+</li>
+<li><p class="first">The optional <tt class="docutils literal"><span class="pre">notail</span></tt> marker indicates that the optimizers should not add
+<tt class="docutils literal"><span class="pre">tail</span></tt> or <tt class="docutils literal"><span class="pre">musttail</span></tt> markers to the call. It is used to prevent tail
+call optimization from being performed on the call.</p>
+</li>
+<li><p class="first">The optional <tt class="docutils literal"><span class="pre">fast-math</span> <span class="pre">flags</span></tt> marker indicates that the call has one or more
+<a class="reference internal" href="#fastmath"><em>fast-math flags</em></a>, which are optimization hints to enable
+otherwise unsafe floating-point optimizations. Fast-math flags are only valid
+for calls that return a floating-point scalar or vector type.</p>
+</li>
+<li><p class="first">The optional “cconv” marker indicates which <a class="reference internal" href="#callingconv"><em>calling
+convention</em></a> the call should use. If none is
+specified, the call defaults to using C calling conventions. The
+calling convention of the call must match the calling convention of
+the target function, or else the behavior is undefined.</p>
+</li>
+<li><p class="first">The optional <a class="reference internal" href="#paramattrs"><em>Parameter Attributes</em></a> list for return
+values. Only ‘<tt class="docutils literal"><span class="pre">zeroext</span></tt>‘, ‘<tt class="docutils literal"><span class="pre">signext</span></tt>‘, and ‘<tt class="docutils literal"><span class="pre">inreg</span></tt>‘ attributes
+are valid here.</p>
+</li>
+<li><p class="first">‘<tt class="docutils literal"><span class="pre">ty</span></tt>‘: the type of the call instruction itself which is also the
+type of the return value. Functions that return no value are marked
+<tt class="docutils literal"><span class="pre">void</span></tt>.</p>
+</li>
+<li><p class="first">‘<tt class="docutils literal"><span class="pre">fnty</span></tt>‘: shall be the signature of the function being called. The
+argument types must match the types implied by this signature. This
+type can be omitted if the function is not varargs.</p>
+</li>
+<li><p class="first">‘<tt class="docutils literal"><span class="pre">fnptrval</span></tt>‘: An LLVM value containing a pointer to a function to
+be called. In most cases, this is a direct function call, but
+indirect <tt class="docutils literal"><span class="pre">call</span></tt>‘s are just as possible, calling an arbitrary pointer
+to function value.</p>
+</li>
+<li><p class="first">‘<tt class="docutils literal"><span class="pre">function</span> <span class="pre">args</span></tt>‘: argument list whose types match the function
+signature argument types and parameter attributes. All arguments must
+be of <a class="reference internal" href="#t-firstclass"><em>first class</em></a> type. If the function signature
+indicates the function accepts a variable number of arguments, the
+extra arguments can be specified.</p>
+</li>
+<li><p class="first">The optional <a class="reference internal" href="#fnattrs"><em>function attributes</em></a> list.</p>
+</li>
+<li><p class="first">The optional <a class="reference internal" href="#opbundles"><em>operand bundles</em></a> list.</p>
+</li>
+</ol>
+</div>
+<div class="section" id="id305">
+<h5><a class="toc-backref" href="#id1314">Semantics:</a><a class="headerlink" href="#id305" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">call</span></tt>‘ instruction is used to cause control flow to transfer to
+a specified function, with its incoming arguments bound to the specified
+values. Upon a ‘<tt class="docutils literal"><span class="pre">ret</span></tt>‘ instruction in the called function, control
+flow continues with the instruction after the function call, and the
+return value of the function is bound to the result argument.</p>
+</div>
+<div class="section" id="id306">
+<h5><a class="toc-backref" href="#id1315">Example:</a><a class="headerlink" href="#id306" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%retval</span> <span class="p">=</span> <span class="k">call</span> <span class="k">i32</span> <span class="vg">@test</span><span class="p">(</span><span class="k">i32</span> <span class="nv">%argc</span><span class="p">)</span>
+<span class="k">call</span> <span class="k">i32</span> <span class="p">(</span><span class="k">i8</span><span class="p">*,</span> <span class="p">...)*</span> <span class="vg">@printf</span><span class="p">(</span><span class="k">i8</span><span class="p">*</span> <span class="nv">%msg</span><span class="p">,</span> <span class="k">i32</span> <span class="m">12</span><span class="p">,</span> <span class="k">i8</span> <span class="m">42</span><span class="p">)</span>        <span class="c">; yields i32</span>
+<span class="nv">%X</span> <span class="p">=</span> <span class="k">tail</span> <span class="k">call</span> <span class="k">i32</span> <span class="vg">@foo</span><span class="p">()</span>                                    <span class="c">; yields i32</span>
+<span class="nv">%Y</span> <span class="p">=</span> <span class="k">tail</span> <span class="k">call</span> <span class="k">fastcc</span> <span class="k">i32</span> <span class="vg">@foo</span><span class="p">()</span>  <span class="c">; yields i32</span>
+<span class="k">call</span> <span class="kt">void</span> <span class="nv">%foo</span><span class="p">(</span><span class="k">i8</span> <span class="m">97</span> <span class="k">signext</span><span class="p">)</span>
+
+<span class="nv">%struct.A</span> <span class="p">=</span> <span class="k">type</span> <span class="p">{</span> <span class="k">i32</span><span class="p">,</span> <span class="k">i8</span> <span class="p">}</span>
+<span class="nv">%r</span> <span class="p">=</span> <span class="k">call</span> <span class="nv">%struct.A</span> <span class="vg">@foo</span><span class="p">()</span>                        <span class="c">; yields { i32, i8 }</span>
+<span class="nv">%gr</span> <span class="p">=</span> <span class="k">extractvalue</span> <span class="nv">%struct.A</span> <span class="nv">%r</span><span class="p">,</span> <span class="m">0</span>                <span class="c">; yields i32</span>
+<span class="nv">%gr1</span> <span class="p">=</span> <span class="k">extractvalue</span> <span class="nv">%struct.A</span> <span class="nv">%r</span><span class="p">,</span> <span class="m">1</span>               <span class="c">; yields i8</span>
+<span class="nv">%Z</span> <span class="p">=</span> <span class="k">call</span> <span class="kt">void</span> <span class="vg">@foo</span><span class="p">()</span> <span class="k">noreturn</span>                    <span class="c">; indicates that %foo never returns normally</span>
+<span class="nv">%ZZ</span> <span class="p">=</span> <span class="k">call</span> <span class="k">zeroext</span> <span class="k">i32</span> <span class="vg">@bar</span><span class="p">()</span>                     <span class="c">; Return value is %zero extended</span>
+</pre></div>
+</div>
+<p>llvm treats calls to some functions with names and arguments that match
+the standard C99 library as being the C99 library functions, and may
+perform optimizations or generate code for them under that assumption.
+This is something we’d like to change in the future to provide better
+support for freestanding environments and non-C-based languages.</p>
+</div>
+</div>
+<div class="section" id="va-arg-instruction">
+<span id="i-va-arg"></span><h4><a class="toc-backref" href="#id1316">‘<tt class="docutils literal"><span class="pre">va_arg</span></tt>‘ Instruction</a><a class="headerlink" href="#va-arg-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id307">
+<h5><a class="toc-backref" href="#id1317">Syntax:</a><a class="headerlink" href="#id307" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><resultval> = va_arg <va_list*> <arglist>, <argty></pre>
+</div>
+</div>
+<div class="section" id="id308">
+<h5><a class="toc-backref" href="#id1318">Overview:</a><a class="headerlink" href="#id308" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">va_arg</span></tt>‘ instruction is used to access arguments passed through
+the “variable argument” area of a function call. It is used to implement
+the <tt class="docutils literal"><span class="pre">va_arg</span></tt> macro in C.</p>
+</div>
+<div class="section" id="id309">
+<h5><a class="toc-backref" href="#id1319">Arguments:</a><a class="headerlink" href="#id309" title="Permalink to this headline">¶</a></h5>
+<p>This instruction takes a <tt class="docutils literal"><span class="pre">va_list*</span></tt> value and the type of the
+argument. It returns a value of the specified argument type and
+increments the <tt class="docutils literal"><span class="pre">va_list</span></tt> to point to the next argument. The actual
+type of <tt class="docutils literal"><span class="pre">va_list</span></tt> is target specific.</p>
+</div>
+<div class="section" id="id310">
+<h5><a class="toc-backref" href="#id1320">Semantics:</a><a class="headerlink" href="#id310" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">va_arg</span></tt>‘ instruction loads an argument of the specified type
+from the specified <tt class="docutils literal"><span class="pre">va_list</span></tt> and causes the <tt class="docutils literal"><span class="pre">va_list</span></tt> to point to
+the next argument. For more information, see the variable argument
+handling <a class="reference internal" href="#int-varargs"><em>Intrinsic Functions</em></a>.</p>
+<p>It is legal for this instruction to be called in a function which does
+not take a variable number of arguments, for example, the <tt class="docutils literal"><span class="pre">vfprintf</span></tt>
+function.</p>
+<p><tt class="docutils literal"><span class="pre">va_arg</span></tt> is an LLVM instruction instead of an <a class="reference internal" href="#intrinsics"><em>intrinsic
+function</em></a> because it takes a type as an argument.</p>
+</div>
+<div class="section" id="id311">
+<h5><a class="toc-backref" href="#id1321">Example:</a><a class="headerlink" href="#id311" title="Permalink to this headline">¶</a></h5>
+<p>See the <a class="reference internal" href="#int-varargs"><em>variable argument processing</em></a> section.</p>
+<p>Note that the code generator does not yet fully support va_arg on many
+targets. Also, it does not currently support va_arg with aggregate
+types on any target.</p>
+</div>
+</div>
+<div class="section" id="landingpad-instruction">
+<span id="i-landingpad"></span><h4><a class="toc-backref" href="#id1322">‘<tt class="docutils literal"><span class="pre">landingpad</span></tt>‘ Instruction</a><a class="headerlink" href="#landingpad-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id312">
+<h5><a class="toc-backref" href="#id1323">Syntax:</a><a class="headerlink" href="#id312" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><resultval> = landingpad <resultty> <clause>+
+<resultval> = landingpad <resultty> cleanup <clause>*
+
+<clause> := catch <type> <value>
+<clause> := filter <array constant type> <array constant></pre>
+</div>
+</div>
+<div class="section" id="id313">
+<h5><a class="toc-backref" href="#id1324">Overview:</a><a class="headerlink" href="#id313" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">landingpad</span></tt>‘ instruction is used by <a class="reference external" href="ExceptionHandling.html#overview">LLVM’s exception handling
+system</a> to specify that a basic block
+is a landing pad — one where the exception lands, and corresponds to the
+code found in the <tt class="docutils literal"><span class="pre">catch</span></tt> portion of a <tt class="docutils literal"><span class="pre">try</span></tt>/<tt class="docutils literal"><span class="pre">catch</span></tt> sequence. It
+defines values supplied by the <a class="reference internal" href="#personalityfn"><em>personality function</em></a> upon
+re-entry to the function. The <tt class="docutils literal"><span class="pre">resultval</span></tt> has the type <tt class="docutils literal"><span class="pre">resultty</span></tt>.</p>
+</div>
+<div class="section" id="id315">
+<h5><a class="toc-backref" href="#id1325">Arguments:</a><a class="headerlink" href="#id315" title="Permalink to this headline">¶</a></h5>
+<p>The optional
+<tt class="docutils literal"><span class="pre">cleanup</span></tt> flag indicates that the landing pad block is a cleanup.</p>
+<p>A <tt class="docutils literal"><span class="pre">clause</span></tt> begins with the clause type — <tt class="docutils literal"><span class="pre">catch</span></tt> or <tt class="docutils literal"><span class="pre">filter</span></tt> — and
+contains the global variable representing the “type” that may be caught
+or filtered respectively. Unlike the <tt class="docutils literal"><span class="pre">catch</span></tt> clause, the <tt class="docutils literal"><span class="pre">filter</span></tt>
+clause takes an array constant as its argument. Use
+“<tt class="docutils literal"><span class="pre">[0</span> <span class="pre">x</span> <span class="pre">i8**]</span> <span class="pre">undef</span></tt>” for a filter which cannot throw. The
+‘<tt class="docutils literal"><span class="pre">landingpad</span></tt>‘ instruction must contain <em>at least</em> one <tt class="docutils literal"><span class="pre">clause</span></tt> or
+the <tt class="docutils literal"><span class="pre">cleanup</span></tt> flag.</p>
+</div>
+<div class="section" id="id316">
+<h5><a class="toc-backref" href="#id1326">Semantics:</a><a class="headerlink" href="#id316" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">landingpad</span></tt>‘ instruction defines the values which are set by the
+<a class="reference internal" href="#personalityfn"><em>personality function</em></a> upon re-entry to the function, and
+therefore the “result type” of the <tt class="docutils literal"><span class="pre">landingpad</span></tt> instruction. As with
+calling conventions, how the personality function results are
+represented in LLVM IR is target specific.</p>
+<p>The clauses are applied in order from top to bottom. If two
+<tt class="docutils literal"><span class="pre">landingpad</span></tt> instructions are merged together through inlining, the
+clauses from the calling function are appended to the list of clauses.
+When the call stack is being unwound due to an exception being thrown,
+the exception is compared against each <tt class="docutils literal"><span class="pre">clause</span></tt> in turn. If it doesn’t
+match any of the clauses, and the <tt class="docutils literal"><span class="pre">cleanup</span></tt> flag is not set, then
+unwinding continues further up the call stack.</p>
+<p>The <tt class="docutils literal"><span class="pre">landingpad</span></tt> instruction has several restrictions:</p>
+<ul class="simple">
+<li>A landing pad block is a basic block which is the unwind destination
+of an ‘<tt class="docutils literal"><span class="pre">invoke</span></tt>‘ instruction.</li>
+<li>A landing pad block must have a ‘<tt class="docutils literal"><span class="pre">landingpad</span></tt>‘ instruction as its
+first non-PHI instruction.</li>
+<li>There can be only one ‘<tt class="docutils literal"><span class="pre">landingpad</span></tt>‘ instruction within the landing
+pad block.</li>
+<li>A basic block that is not a landing pad block may not include a
+‘<tt class="docutils literal"><span class="pre">landingpad</span></tt>‘ instruction.</li>
+</ul>
+</div>
+<div class="section" id="id317">
+<h5><a class="toc-backref" href="#id1327">Example:</a><a class="headerlink" href="#id317" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><pre>;; A landing pad which can catch an integer.
+%res = landingpad { i8*, i32 }
+         catch i8** @_ZTIi
+;; A landing pad that is a cleanup.
+%res = landingpad { i8*, i32 }
+         cleanup
+;; A landing pad which can catch an integer and can only throw a double.
+%res = landingpad { i8*, i32 }
+         catch i8** @_ZTIi
+         filter [1 x i8**] [@_ZTId]</pre>
+</div>
+</div>
+</div>
+<div class="section" id="catchpad-instruction">
+<span id="i-catchpad"></span><h4><a class="toc-backref" href="#id1328">‘<tt class="docutils literal"><span class="pre">catchpad</span></tt>‘ Instruction</a><a class="headerlink" href="#catchpad-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id318">
+<h5><a class="toc-backref" href="#id1329">Syntax:</a><a class="headerlink" href="#id318" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><resultval> = catchpad within <catchswitch> [<args>*]</pre>
+</div>
+</div>
+<div class="section" id="id319">
+<h5><a class="toc-backref" href="#id1330">Overview:</a><a class="headerlink" href="#id319" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">catchpad</span></tt>‘ instruction is used by <a class="reference external" href="ExceptionHandling.html#overview">LLVM’s exception handling
+system</a> to specify that a basic block
+begins a catch handler — one where a personality routine attempts to transfer
+control to catch an exception.</p>
+</div>
+<div class="section" id="id321">
+<h5><a class="toc-backref" href="#id1331">Arguments:</a><a class="headerlink" href="#id321" title="Permalink to this headline">¶</a></h5>
+<p>The <tt class="docutils literal"><span class="pre">catchswitch</span></tt> operand must always be a token produced by a
+<a class="reference internal" href="#i-catchswitch"><em>catchswitch</em></a> instruction in a predecessor block. This
+ensures that each <tt class="docutils literal"><span class="pre">catchpad</span></tt> has exactly one predecessor block, and it always
+terminates in a <tt class="docutils literal"><span class="pre">catchswitch</span></tt>.</p>
+<p>The <tt class="docutils literal"><span class="pre">args</span></tt> correspond to whatever information the personality routine
+requires to know if this is an appropriate handler for the exception. Control
+will transfer to the <tt class="docutils literal"><span class="pre">catchpad</span></tt> if this is the first appropriate handler for
+the exception.</p>
+<p>The <tt class="docutils literal"><span class="pre">resultval</span></tt> has the type <a class="reference internal" href="#t-token"><em>token</em></a> and is used to match the
+<tt class="docutils literal"><span class="pre">catchpad</span></tt> to corresponding <a class="reference internal" href="#i-catchret"><em>catchrets</em></a> and other nested EH
+pads.</p>
+</div>
+<div class="section" id="id322">
+<h5><a class="toc-backref" href="#id1332">Semantics:</a><a class="headerlink" href="#id322" title="Permalink to this headline">¶</a></h5>
+<p>When the call stack is being unwound due to an exception being thrown, the
+exception is compared against the <tt class="docutils literal"><span class="pre">args</span></tt>. If it doesn’t match, control will
+not reach the <tt class="docutils literal"><span class="pre">catchpad</span></tt> instruction.  The representation of <tt class="docutils literal"><span class="pre">args</span></tt> is
+entirely target and personality function-specific.</p>
+<p>Like the <a class="reference internal" href="#i-landingpad"><em>landingpad</em></a> instruction, the <tt class="docutils literal"><span class="pre">catchpad</span></tt>
+instruction must be the first non-phi of its parent basic block.</p>
+<p>The meaning of the tokens produced and consumed by <tt class="docutils literal"><span class="pre">catchpad</span></tt> and other “pad”
+instructions is described in the
+<a class="reference external" href="ExceptionHandling.html#wineh">Windows exception handling documentation</a>.</p>
+<p>When a <tt class="docutils literal"><span class="pre">catchpad</span></tt> has been “entered” but not yet “exited” (as
+described in the <a class="reference external" href="ExceptionHandling.html#wineh-constraints">EH documentation</a>),
+it is undefined behavior to execute a <a class="reference internal" href="#i-call"><em>call</em></a> or <a class="reference internal" href="#i-invoke"><em>invoke</em></a>
+that does not carry an appropriate <a class="reference internal" href="#ob-funclet"><em>“funclet” bundle</em></a>.</p>
+</div>
+<div class="section" id="id324">
+<h5><a class="toc-backref" href="#id1333">Example:</a><a class="headerlink" href="#id324" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre>dispatch:
+  %cs = catchswitch within none [label %handler0] unwind to caller
+  ;; A catch block which can catch an integer.
+handler0:
+  %tok = catchpad within %cs [i8** @_ZTIi]
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="cleanuppad-instruction">
+<span id="i-cleanuppad"></span><h4><a class="toc-backref" href="#id1334">‘<tt class="docutils literal"><span class="pre">cleanuppad</span></tt>‘ Instruction</a><a class="headerlink" href="#cleanuppad-instruction" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id325">
+<h5><a class="toc-backref" href="#id1335">Syntax:</a><a class="headerlink" href="#id325" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre><resultval> = cleanuppad within <parent> [<args>*]</pre>
+</div>
+</div>
+<div class="section" id="id326">
+<h5><a class="toc-backref" href="#id1336">Overview:</a><a class="headerlink" href="#id326" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">cleanuppad</span></tt>‘ instruction is used by <a class="reference external" href="ExceptionHandling.html#overview">LLVM’s exception handling
+system</a> to specify that a basic block
+is a cleanup block — one where a personality routine attempts to
+transfer control to run cleanup actions.
+The <tt class="docutils literal"><span class="pre">args</span></tt> correspond to whatever additional
+information the <a class="reference internal" href="#personalityfn"><em>personality function</em></a> requires to
+execute the cleanup.
+The <tt class="docutils literal"><span class="pre">resultval</span></tt> has the type <a class="reference internal" href="#t-token"><em>token</em></a> and is used to
+match the <tt class="docutils literal"><span class="pre">cleanuppad</span></tt> to corresponding <a class="reference internal" href="#i-cleanupret"><em>cleanuprets</em></a>.
+The <tt class="docutils literal"><span class="pre">parent</span></tt> argument is the token of the funclet that contains the
+<tt class="docutils literal"><span class="pre">cleanuppad</span></tt> instruction. If the <tt class="docutils literal"><span class="pre">cleanuppad</span></tt> is not inside a funclet,
+this operand may be the token <tt class="docutils literal"><span class="pre">none</span></tt>.</p>
+</div>
+<div class="section" id="id328">
+<h5><a class="toc-backref" href="#id1337">Arguments:</a><a class="headerlink" href="#id328" title="Permalink to this headline">¶</a></h5>
+<p>The instruction takes a list of arbitrary values which are interpreted
+by the <a class="reference internal" href="#personalityfn"><em>personality function</em></a>.</p>
+</div>
+<div class="section" id="id329">
+<h5><a class="toc-backref" href="#id1338">Semantics:</a><a class="headerlink" href="#id329" title="Permalink to this headline">¶</a></h5>
+<p>When the call stack is being unwound due to an exception being thrown,
+the <a class="reference internal" href="#personalityfn"><em>personality function</em></a> transfers control to the
+<tt class="docutils literal"><span class="pre">cleanuppad</span></tt> with the aid of the personality-specific arguments.
+As with calling conventions, how the personality function results are
+represented in LLVM IR is target specific.</p>
+<p>The <tt class="docutils literal"><span class="pre">cleanuppad</span></tt> instruction has several restrictions:</p>
+<ul class="simple">
+<li>A cleanup block is a basic block which is the unwind destination of
+an exceptional instruction.</li>
+<li>A cleanup block must have a ‘<tt class="docutils literal"><span class="pre">cleanuppad</span></tt>‘ instruction as its
+first non-PHI instruction.</li>
+<li>There can be only one ‘<tt class="docutils literal"><span class="pre">cleanuppad</span></tt>‘ instruction within the
+cleanup block.</li>
+<li>A basic block that is not a cleanup block may not include a
+‘<tt class="docutils literal"><span class="pre">cleanuppad</span></tt>‘ instruction.</li>
+</ul>
+<p>When a <tt class="docutils literal"><span class="pre">cleanuppad</span></tt> has been “entered” but not yet “exited” (as
+described in the <a class="reference external" href="ExceptionHandling.html#wineh-constraints">EH documentation</a>),
+it is undefined behavior to execute a <a class="reference internal" href="#i-call"><em>call</em></a> or <a class="reference internal" href="#i-invoke"><em>invoke</em></a>
+that does not carry an appropriate <a class="reference internal" href="#ob-funclet"><em>“funclet” bundle</em></a>.</p>
+</div>
+<div class="section" id="id331">
+<h5><a class="toc-backref" href="#id1339">Example:</a><a class="headerlink" href="#id331" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-text"><div class="highlight"><pre>%tok = cleanuppad within %cs []
+</pre></div>
+</div>
+</div>
+</div>
+</div>
+</div>
+<div class="section" id="intrinsic-functions">
+<span id="intrinsics"></span><h2><a class="toc-backref" href="#id1340">Intrinsic Functions</a><a class="headerlink" href="#intrinsic-functions" title="Permalink to this headline">¶</a></h2>
+<p>LLVM supports the notion of an “intrinsic function”. These functions
+have well known names and semantics and are required to follow certain
+restrictions. Overall, these intrinsics represent an extension mechanism
+for the LLVM language that does not require changing all of the
+transformations in LLVM when adding to the language (or the bitcode
+reader/writer, the parser, etc...).</p>
+<p>Intrinsic function names must all start with an “<tt class="docutils literal"><span class="pre">llvm.</span></tt>” prefix. This
+prefix is reserved in LLVM for intrinsic names; thus, function names may
+not begin with this prefix. Intrinsic functions must always be external
+functions: you cannot define the body of intrinsic functions. Intrinsic
+functions may only be used in call or invoke instructions: it is illegal
+to take the address of an intrinsic function. Additionally, because
+intrinsic functions are part of the LLVM language, it is required if any
+are added that they be documented here.</p>
+<p>Some intrinsic functions can be overloaded, i.e., the intrinsic
+represents a family of functions that perform the same operation but on
+different data types. Because LLVM can represent over 8 million
+different integer types, overloading is used commonly to allow an
+intrinsic function to operate on any integer type. One or more of the
+argument types or the result type can be overloaded to accept any
+integer type. Argument types may also be defined as exactly matching a
+previous argument’s type or the result type. This allows an intrinsic
+function which accepts multiple arguments, but needs all of them to be
+of the same type, to only be overloaded with respect to a single
+argument or the result.</p>
+<p>Overloaded intrinsics will have the names of its overloaded argument
+types encoded into its function name, each preceded by a period. Only
+those types which are overloaded result in a name suffix. Arguments
+whose type is matched against another type do not. For example, the
+<tt class="docutils literal"><span class="pre">llvm.ctpop</span></tt> function can take an integer of any width and returns an
+integer of exactly the same integer width. This leads to a family of
+functions such as <tt class="docutils literal"><span class="pre">i8</span> <span class="pre">@llvm.ctpop.i8(i8</span> <span class="pre">%val)</span></tt> and
+<tt class="docutils literal"><span class="pre">i29</span> <span class="pre">@llvm.ctpop.i29(i29</span> <span class="pre">%val)</span></tt>. Only one type, the return type, is
+overloaded, and only one type suffix is required. Because the argument’s
+type is matched against the return type, it does not require its own
+name suffix.</p>
+<p>To learn how to add an intrinsic function, please see the <a class="reference external" href="ExtendingLLVM.html">Extending
+LLVM Guide</a>.</p>
+<div class="section" id="variable-argument-handling-intrinsics">
+<span id="int-varargs"></span><h3><a class="toc-backref" href="#id1341">Variable Argument Handling Intrinsics</a><a class="headerlink" href="#variable-argument-handling-intrinsics" title="Permalink to this headline">¶</a></h3>
+<p>Variable argument support is defined in LLVM with the
+<a class="reference internal" href="#i-va-arg"><em>va_arg</em></a> instruction and these three intrinsic
+functions. These functions are related to the similarly named macros
+defined in the <tt class="docutils literal"><span class="pre"><stdarg.h></span></tt> header file.</p>
+<p>All of these functions operate on arguments that use a target-specific
+value type “<tt class="docutils literal"><span class="pre">va_list</span></tt>”. The LLVM assembly language reference manual
+does not define what this type is, so all transformations should be
+prepared to handle these functions regardless of the type used.</p>
+<p>This example shows how the <a class="reference internal" href="#i-va-arg"><em>va_arg</em></a> instruction and the
+variable argument handling intrinsic functions are used.</p>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="c">; This struct is different for every platform. For most platforms,</span>
+<span class="c">; it is merely an i8*.</span>
+<span class="nv">%struct.va_list</span> <span class="p">=</span> <span class="k">type</span> <span class="p">{</span> <span class="k">i8</span><span class="p">*</span> <span class="p">}</span>
+
+<span class="c">; For Unix x86_64 platforms, va_list is the following struct:</span>
+<span class="c">; %struct.va_list = type { i32, i32, i8*, i8* }</span>
+
+<span class="k">define</span> <span class="k">i32</span> <span class="vg">@test</span><span class="p">(</span><span class="k">i32</span> <span class="nv">%X</span><span class="p">,</span> <span class="p">...)</span> <span class="p">{</span>
+  <span class="c">; Initialize variable argument processing</span>
+  <span class="nv">%ap</span> <span class="p">=</span> <span class="k">alloca</span> <span class="nv">%struct.va_list</span>
+  <span class="nv">%ap2</span> <span class="p">=</span> <span class="k">bitcast</span> <span class="nv">%struct.va_list</span><span class="p">*</span> <span class="nv">%ap</span> <span class="k">to</span> <span class="k">i8</span><span class="p">*</span>
+  <span class="k">call</span> <span class="kt">void</span> <span class="vg">@llvm.va_start</span><span class="p">(</span><span class="k">i8</span><span class="p">*</span> <span class="nv">%ap2</span><span class="p">)</span>
+
+  <span class="c">; Read a single integer argument</span>
+  <span class="nv">%tmp</span> <span class="p">=</span> <span class="k">va_arg</span> <span class="k">i8</span><span class="p">*</span> <span class="nv">%ap2</span><span class="p">,</span> <span class="k">i32</span>
+
+  <span class="c">; Demonstrate usage of llvm.va_copy and llvm.va_end</span>
+  <span class="nv">%aq</span> <span class="p">=</span> <span class="k">alloca</span> <span class="k">i8</span><span class="p">*</span>
+  <span class="nv">%aq2</span> <span class="p">=</span> <span class="k">bitcast</span> <span class="k">i8</span><span class="p">**</span> <span class="nv">%aq</span> <span class="k">to</span> <span class="k">i8</span><span class="p">*</span>
+  <span class="k">call</span> <span class="kt">void</span> <span class="vg">@llvm.va_copy</span><span class="p">(</span><span class="k">i8</span><span class="p">*</span> <span class="nv">%aq2</span><span class="p">,</span> <span class="k">i8</span><span class="p">*</span> <span class="nv">%ap2</span><span class="p">)</span>
+  <span class="k">call</span> <span class="kt">void</span> <span class="vg">@llvm.va_end</span><span class="p">(</span><span class="k">i8</span><span class="p">*</span> <span class="nv">%aq2</span><span class="p">)</span>
+
+  <span class="c">; Stop processing of arguments.</span>
+  <span class="k">call</span> <span class="kt">void</span> <span class="vg">@llvm.va_end</span><span class="p">(</span><span class="k">i8</span><span class="p">*</span> <span class="nv">%ap2</span><span class="p">)</span>
+  <span class="k">ret</span> <span class="k">i32</span> <span class="nv">%tmp</span>
+<span class="p">}</span>
+
+<span class="k">declare</span> <span class="kt">void</span> <span class="vg">@llvm.va_start</span><span class="p">(</span><span class="k">i8</span><span class="p">*)</span>
+<span class="k">declare</span> <span class="kt">void</span> <span class="vg">@llvm.va_copy</span><span class="p">(</span><span class="k">i8</span><span class="p">*,</span> <span class="k">i8</span><span class="p">*)</span>
+<span class="k">declare</span> <span class="kt">void</span> <span class="vg">@llvm.va_end</span><span class="p">(</span><span class="k">i8</span><span class="p">*)</span>
+</pre></div>
+</div>
+<div class="section" id="llvm-va-start-intrinsic">
+<span id="int-va-start"></span><h4><a class="toc-backref" href="#id1342">‘<tt class="docutils literal"><span class="pre">llvm.va_start</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-va-start-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id332">
+<h5><a class="toc-backref" href="#id1343">Syntax:</a><a class="headerlink" href="#id332" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>declare void @llvm.va_start(i8* <arglist>)</pre>
+</div>
+</div>
+<div class="section" id="id333">
+<h5><a class="toc-backref" href="#id1344">Overview:</a><a class="headerlink" href="#id333" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.va_start</span></tt>‘ intrinsic initializes <tt class="docutils literal"><span class="pre">*<arglist></span></tt> for
+subsequent use by <tt class="docutils literal"><span class="pre">va_arg</span></tt>.</p>
+</div>
+<div class="section" id="id334">
+<h5><a class="toc-backref" href="#id1345">Arguments:</a><a class="headerlink" href="#id334" title="Permalink to this headline">¶</a></h5>
+<p>The argument is a pointer to a <tt class="docutils literal"><span class="pre">va_list</span></tt> element to initialize.</p>
+</div>
+<div class="section" id="id335">
+<h5><a class="toc-backref" href="#id1346">Semantics:</a><a class="headerlink" href="#id335" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.va_start</span></tt>‘ intrinsic works just like the <tt class="docutils literal"><span class="pre">va_start</span></tt> macro
+available in C. In a target-dependent way, it initializes the
+<tt class="docutils literal"><span class="pre">va_list</span></tt> element to which the argument points, so that the next call
+to <tt class="docutils literal"><span class="pre">va_arg</span></tt> will produce the first variable argument passed to the
+function. Unlike the C <tt class="docutils literal"><span class="pre">va_start</span></tt> macro, this intrinsic does not need
+to know the last argument of the function as the compiler can figure
+that out.</p>
+</div>
+</div>
+<div class="section" id="llvm-va-end-intrinsic">
+<h4><a class="toc-backref" href="#id1347">‘<tt class="docutils literal"><span class="pre">llvm.va_end</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-va-end-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id336">
+<h5><a class="toc-backref" href="#id1348">Syntax:</a><a class="headerlink" href="#id336" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>declare void @llvm.va_end(i8* <arglist>)</pre>
+</div>
+</div>
+<div class="section" id="id337">
+<h5><a class="toc-backref" href="#id1349">Overview:</a><a class="headerlink" href="#id337" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.va_end</span></tt>‘ intrinsic destroys <tt class="docutils literal"><span class="pre">*<arglist></span></tt>, which has been
+initialized previously with <tt class="docutils literal"><span class="pre">llvm.va_start</span></tt> or <tt class="docutils literal"><span class="pre">llvm.va_copy</span></tt>.</p>
+</div>
+<div class="section" id="id338">
+<h5><a class="toc-backref" href="#id1350">Arguments:</a><a class="headerlink" href="#id338" title="Permalink to this headline">¶</a></h5>
+<p>The argument is a pointer to a <tt class="docutils literal"><span class="pre">va_list</span></tt> to destroy.</p>
+</div>
+<div class="section" id="id339">
+<h5><a class="toc-backref" href="#id1351">Semantics:</a><a class="headerlink" href="#id339" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.va_end</span></tt>‘ intrinsic works just like the <tt class="docutils literal"><span class="pre">va_end</span></tt> macro
+available in C. In a target-dependent way, it destroys the <tt class="docutils literal"><span class="pre">va_list</span></tt>
+element to which the argument points. Calls to
+<a class="reference internal" href="#int-va-start"><em>llvm.va_start</em></a> and
+<a class="reference internal" href="#int-va-copy"><em>llvm.va_copy</em></a> must be matched exactly with calls to
+<tt class="docutils literal"><span class="pre">llvm.va_end</span></tt>.</p>
+</div>
+</div>
+<div class="section" id="llvm-va-copy-intrinsic">
+<span id="int-va-copy"></span><h4><a class="toc-backref" href="#id1352">‘<tt class="docutils literal"><span class="pre">llvm.va_copy</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-va-copy-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id340">
+<h5><a class="toc-backref" href="#id1353">Syntax:</a><a class="headerlink" href="#id340" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>declare void @llvm.va_copy(i8* <destarglist>, i8* <srcarglist>)</pre>
+</div>
+</div>
+<div class="section" id="id341">
+<h5><a class="toc-backref" href="#id1354">Overview:</a><a class="headerlink" href="#id341" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.va_copy</span></tt>‘ intrinsic copies the current argument position
+from the source argument list to the destination argument list.</p>
+</div>
+<div class="section" id="id342">
+<h5><a class="toc-backref" href="#id1355">Arguments:</a><a class="headerlink" href="#id342" title="Permalink to this headline">¶</a></h5>
+<p>The first argument is a pointer to a <tt class="docutils literal"><span class="pre">va_list</span></tt> element to initialize.
+The second argument is a pointer to a <tt class="docutils literal"><span class="pre">va_list</span></tt> element to copy from.</p>
+</div>
+<div class="section" id="id343">
+<h5><a class="toc-backref" href="#id1356">Semantics:</a><a class="headerlink" href="#id343" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.va_copy</span></tt>‘ intrinsic works just like the <tt class="docutils literal"><span class="pre">va_copy</span></tt> macro
+available in C. In a target-dependent way, it copies the source
+<tt class="docutils literal"><span class="pre">va_list</span></tt> element into the destination <tt class="docutils literal"><span class="pre">va_list</span></tt> element. This
+intrinsic is necessary because the `` llvm.va_start`` intrinsic may be
+arbitrarily complex and require, for example, memory allocation.</p>
+</div>
+</div>
+</div>
+<div class="section" id="accurate-garbage-collection-intrinsics">
+<h3><a class="toc-backref" href="#id1357">Accurate Garbage Collection Intrinsics</a><a class="headerlink" href="#accurate-garbage-collection-intrinsics" title="Permalink to this headline">¶</a></h3>
+<p>LLVM’s support for <a class="reference external" href="GarbageCollection.html">Accurate Garbage Collection</a>
+(GC) requires the frontend to generate code containing appropriate intrinsic
+calls and select an appropriate GC strategy which knows how to lower these
+intrinsics in a manner which is appropriate for the target collector.</p>
+<p>These intrinsics allow identification of <a class="reference internal" href="#int-gcroot"><em>GC roots on the
+stack</em></a>, as well as garbage collector implementations that
+require <a class="reference internal" href="#int-gcread"><em>read</em></a> and <a class="reference internal" href="#int-gcwrite"><em>write</em></a> barriers.
+Frontends for type-safe garbage collected languages should generate
+these intrinsics to make use of the LLVM garbage collectors. For more
+details, see <a class="reference external" href="GarbageCollection.html">Garbage Collection with LLVM</a>.</p>
+<div class="section" id="experimental-statepoint-intrinsics">
+<h4><a class="toc-backref" href="#id1358">Experimental Statepoint Intrinsics</a><a class="headerlink" href="#experimental-statepoint-intrinsics" title="Permalink to this headline">¶</a></h4>
+<p>LLVM provides an second experimental set of intrinsics for describing garbage
+collection safepoints in compiled code. These intrinsics are an alternative
+to the <tt class="docutils literal"><span class="pre">llvm.gcroot</span></tt> intrinsics, but are compatible with the ones for
+<a class="reference internal" href="#int-gcread"><em>read</em></a> and <a class="reference internal" href="#int-gcwrite"><em>write</em></a> barriers. The
+differences in approach are covered in the <a class="reference external" href="GarbageCollection.html">Garbage Collection with LLVM</a> documentation. The intrinsics themselves are
+described in <a class="reference internal" href="Statepoints.html"><em>Garbage Collection Safepoints in LLVM</em></a>.</p>
+</div>
+<div class="section" id="llvm-gcroot-intrinsic">
+<span id="int-gcroot"></span><h4><a class="toc-backref" href="#id1359">‘<tt class="docutils literal"><span class="pre">llvm.gcroot</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-gcroot-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id345">
+<h5><a class="toc-backref" href="#id1360">Syntax:</a><a class="headerlink" href="#id345" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>declare void @llvm.gcroot(i8** %ptrloc, i8* %metadata)</pre>
+</div>
+</div>
+<div class="section" id="id346">
+<h5><a class="toc-backref" href="#id1361">Overview:</a><a class="headerlink" href="#id346" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.gcroot</span></tt>‘ intrinsic declares the existence of a GC root to
+the code generator, and allows some metadata to be associated with it.</p>
+</div>
+<div class="section" id="id347">
+<h5><a class="toc-backref" href="#id1362">Arguments:</a><a class="headerlink" href="#id347" title="Permalink to this headline">¶</a></h5>
+<p>The first argument specifies the address of a stack object that contains
+the root pointer. The second pointer (which must be either a constant or
+a global value address) contains the meta-data to be associated with the
+root.</p>
+</div>
+<div class="section" id="id348">
+<h5><a class="toc-backref" href="#id1363">Semantics:</a><a class="headerlink" href="#id348" title="Permalink to this headline">¶</a></h5>
+<p>At runtime, a call to this intrinsic stores a null pointer into the
+“ptrloc” location. At compile-time, the code generator generates
+information to allow the runtime to find the pointer at GC safe points.
+The ‘<tt class="docutils literal"><span class="pre">llvm.gcroot</span></tt>‘ intrinsic may only be used in a function which
+<a class="reference internal" href="#gc"><em>specifies a GC algorithm</em></a>.</p>
+</div>
+</div>
+<div class="section" id="llvm-gcread-intrinsic">
+<span id="int-gcread"></span><h4><a class="toc-backref" href="#id1364">‘<tt class="docutils literal"><span class="pre">llvm.gcread</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-gcread-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id349">
+<h5><a class="toc-backref" href="#id1365">Syntax:</a><a class="headerlink" href="#id349" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>declare i8* @llvm.gcread(i8* %ObjPtr, i8** %Ptr)</pre>
+</div>
+</div>
+<div class="section" id="id350">
+<h5><a class="toc-backref" href="#id1366">Overview:</a><a class="headerlink" href="#id350" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.gcread</span></tt>‘ intrinsic identifies reads of references from heap
+locations, allowing garbage collector implementations that require read
+barriers.</p>
+</div>
+<div class="section" id="id351">
+<h5><a class="toc-backref" href="#id1367">Arguments:</a><a class="headerlink" href="#id351" title="Permalink to this headline">¶</a></h5>
+<p>The second argument is the address to read from, which should be an
+address allocated from the garbage collector. The first object is a
+pointer to the start of the referenced object, if needed by the language
+runtime (otherwise null).</p>
+</div>
+<div class="section" id="id352">
+<h5><a class="toc-backref" href="#id1368">Semantics:</a><a class="headerlink" href="#id352" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.gcread</span></tt>‘ intrinsic has the same semantics as a load
+instruction, but may be replaced with substantially more complex code by
+the garbage collector runtime, as needed. The ‘<tt class="docutils literal"><span class="pre">llvm.gcread</span></tt>‘
+intrinsic may only be used in a function which <a class="reference internal" href="#gc"><em>specifies a GC
+algorithm</em></a>.</p>
+</div>
+</div>
+<div class="section" id="llvm-gcwrite-intrinsic">
+<span id="int-gcwrite"></span><h4><a class="toc-backref" href="#id1369">‘<tt class="docutils literal"><span class="pre">llvm.gcwrite</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-gcwrite-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id353">
+<h5><a class="toc-backref" href="#id1370">Syntax:</a><a class="headerlink" href="#id353" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>declare void @llvm.gcwrite(i8* %P1, i8* %Obj, i8** %P2)</pre>
+</div>
+</div>
+<div class="section" id="id354">
+<h5><a class="toc-backref" href="#id1371">Overview:</a><a class="headerlink" href="#id354" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.gcwrite</span></tt>‘ intrinsic identifies writes of references to heap
+locations, allowing garbage collector implementations that require write
+barriers (such as generational or reference counting collectors).</p>
+</div>
+<div class="section" id="id355">
+<h5><a class="toc-backref" href="#id1372">Arguments:</a><a class="headerlink" href="#id355" title="Permalink to this headline">¶</a></h5>
+<p>The first argument is the reference to store, the second is the start of
+the object to store it to, and the third is the address of the field of
+Obj to store to. If the runtime does not require a pointer to the
+object, Obj may be null.</p>
+</div>
+<div class="section" id="id356">
+<h5><a class="toc-backref" href="#id1373">Semantics:</a><a class="headerlink" href="#id356" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.gcwrite</span></tt>‘ intrinsic has the same semantics as a store
+instruction, but may be replaced with substantially more complex code by
+the garbage collector runtime, as needed. The ‘<tt class="docutils literal"><span class="pre">llvm.gcwrite</span></tt>‘
+intrinsic may only be used in a function which <a class="reference internal" href="#gc"><em>specifies a GC
+algorithm</em></a>.</p>
+</div>
+</div>
+</div>
+<div class="section" id="code-generator-intrinsics">
+<h3><a class="toc-backref" href="#id1374">Code Generator Intrinsics</a><a class="headerlink" href="#code-generator-intrinsics" title="Permalink to this headline">¶</a></h3>
+<p>These intrinsics are provided by LLVM to expose special features that
+may only be implemented with code generator support.</p>
+<div class="section" id="llvm-returnaddress-intrinsic">
+<h4><a class="toc-backref" href="#id1375">‘<tt class="docutils literal"><span class="pre">llvm.returnaddress</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-returnaddress-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id357">
+<h5><a class="toc-backref" href="#id1376">Syntax:</a><a class="headerlink" href="#id357" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>declare i8* @llvm.returnaddress(i32 <level>)</pre>
+</div>
+</div>
+<div class="section" id="id358">
+<h5><a class="toc-backref" href="#id1377">Overview:</a><a class="headerlink" href="#id358" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.returnaddress</span></tt>‘ intrinsic attempts to compute a
+target-specific value indicating the return address of the current
+function or one of its callers.</p>
+</div>
+<div class="section" id="id359">
+<h5><a class="toc-backref" href="#id1378">Arguments:</a><a class="headerlink" href="#id359" title="Permalink to this headline">¶</a></h5>
+<p>The argument to this intrinsic indicates which function to return the
+address for. Zero indicates the calling function, one indicates its
+caller, etc. The argument is <strong>required</strong> to be a constant integer
+value.</p>
+</div>
+<div class="section" id="id360">
+<h5><a class="toc-backref" href="#id1379">Semantics:</a><a class="headerlink" href="#id360" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.returnaddress</span></tt>‘ intrinsic either returns a pointer
+indicating the return address of the specified call frame, or zero if it
+cannot be identified. The value returned by this intrinsic is likely to
+be incorrect or 0 for arguments other than zero, so it should only be
+used for debugging purposes.</p>
+<p>Note that calling this intrinsic does not prevent function inlining or
+other aggressive transformations, so the value returned may not be that
+of the obvious source-language caller.</p>
+</div>
+</div>
+<div class="section" id="llvm-addressofreturnaddress-intrinsic">
+<h4><a class="toc-backref" href="#id1380">‘<tt class="docutils literal"><span class="pre">llvm.addressofreturnaddress</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-addressofreturnaddress-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id361">
+<h5><a class="toc-backref" href="#id1381">Syntax:</a><a class="headerlink" href="#id361" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>declare i8* @llvm.addressofreturnaddress()</pre>
+</div>
+</div>
+<div class="section" id="id362">
+<h5><a class="toc-backref" href="#id1382">Overview:</a><a class="headerlink" href="#id362" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.addressofreturnaddress</span></tt>‘ intrinsic returns a target-specific
+pointer to the place in the stack frame where the return address of the
+current function is stored.</p>
+</div>
+<div class="section" id="id363">
+<h5><a class="toc-backref" href="#id1383">Semantics:</a><a class="headerlink" href="#id363" title="Permalink to this headline">¶</a></h5>
+<p>Note that calling this intrinsic does not prevent function inlining or
+other aggressive transformations, so the value returned may not be that
+of the obvious source-language caller.</p>
+<p>This intrinsic is only implemented for x86.</p>
+</div>
+</div>
+<div class="section" id="llvm-frameaddress-intrinsic">
+<h4><a class="toc-backref" href="#id1384">‘<tt class="docutils literal"><span class="pre">llvm.frameaddress</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-frameaddress-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id364">
+<h5><a class="toc-backref" href="#id1385">Syntax:</a><a class="headerlink" href="#id364" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>declare i8* @llvm.frameaddress(i32 <level>)</pre>
+</div>
+</div>
+<div class="section" id="id365">
+<h5><a class="toc-backref" href="#id1386">Overview:</a><a class="headerlink" href="#id365" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.frameaddress</span></tt>‘ intrinsic attempts to return the
+target-specific frame pointer value for the specified stack frame.</p>
+</div>
+<div class="section" id="id366">
+<h5><a class="toc-backref" href="#id1387">Arguments:</a><a class="headerlink" href="#id366" title="Permalink to this headline">¶</a></h5>
+<p>The argument to this intrinsic indicates which function to return the
+frame pointer for. Zero indicates the calling function, one indicates
+its caller, etc. The argument is <strong>required</strong> to be a constant integer
+value.</p>
+</div>
+<div class="section" id="id367">
+<h5><a class="toc-backref" href="#id1388">Semantics:</a><a class="headerlink" href="#id367" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.frameaddress</span></tt>‘ intrinsic either returns a pointer
+indicating the frame address of the specified call frame, or zero if it
+cannot be identified. The value returned by this intrinsic is likely to
+be incorrect or 0 for arguments other than zero, so it should only be
+used for debugging purposes.</p>
+<p>Note that calling this intrinsic does not prevent function inlining or
+other aggressive transformations, so the value returned may not be that
+of the obvious source-language caller.</p>
+</div>
+</div>
+<div class="section" id="llvm-localescape-and-llvm-localrecover-intrinsics">
+<h4><a class="toc-backref" href="#id1389">‘<tt class="docutils literal"><span class="pre">llvm.localescape</span></tt>‘ and ‘<tt class="docutils literal"><span class="pre">llvm.localrecover</span></tt>‘ Intrinsics</a><a class="headerlink" href="#llvm-localescape-and-llvm-localrecover-intrinsics" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id368">
+<h5><a class="toc-backref" href="#id1390">Syntax:</a><a class="headerlink" href="#id368" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>declare void @llvm.localescape(...)
+declare i8* @llvm.localrecover(i8* %func, i8* %fp, i32 %idx)</pre>
+</div>
+</div>
+<div class="section" id="id369">
+<h5><a class="toc-backref" href="#id1391">Overview:</a><a class="headerlink" href="#id369" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.localescape</span></tt>‘ intrinsic escapes offsets of a collection of static
+allocas, and the ‘<tt class="docutils literal"><span class="pre">llvm.localrecover</span></tt>‘ intrinsic applies those offsets to a
+live frame pointer to recover the address of the allocation. The offset is
+computed during frame layout of the caller of <tt class="docutils literal"><span class="pre">llvm.localescape</span></tt>.</p>
+</div>
+<div class="section" id="id370">
+<h5><a class="toc-backref" href="#id1392">Arguments:</a><a class="headerlink" href="#id370" title="Permalink to this headline">¶</a></h5>
+<p>All arguments to ‘<tt class="docutils literal"><span class="pre">llvm.localescape</span></tt>‘ must be pointers to static allocas or
+casts of static allocas. Each function can only call ‘<tt class="docutils literal"><span class="pre">llvm.localescape</span></tt>‘
+once, and it can only do so from the entry block.</p>
+<p>The <tt class="docutils literal"><span class="pre">func</span></tt> argument to ‘<tt class="docutils literal"><span class="pre">llvm.localrecover</span></tt>‘ must be a constant
+bitcasted pointer to a function defined in the current module. The code
+generator cannot determine the frame allocation offset of functions defined in
+other modules.</p>
+<p>The <tt class="docutils literal"><span class="pre">fp</span></tt> argument to ‘<tt class="docutils literal"><span class="pre">llvm.localrecover</span></tt>‘ must be a frame pointer of a
+call frame that is currently live. The return value of ‘<tt class="docutils literal"><span class="pre">llvm.localaddress</span></tt>‘
+is one way to produce such a value, but various runtimes also expose a suitable
+pointer in platform-specific ways.</p>
+<p>The <tt class="docutils literal"><span class="pre">idx</span></tt> argument to ‘<tt class="docutils literal"><span class="pre">llvm.localrecover</span></tt>‘ indicates which alloca passed to
+‘<tt class="docutils literal"><span class="pre">llvm.localescape</span></tt>‘ to recover. It is zero-indexed.</p>
+</div>
+<div class="section" id="id371">
+<h5><a class="toc-backref" href="#id1393">Semantics:</a><a class="headerlink" href="#id371" title="Permalink to this headline">¶</a></h5>
+<p>These intrinsics allow a group of functions to share access to a set of local
+stack allocations of a one parent function. The parent function may call the
+‘<tt class="docutils literal"><span class="pre">llvm.localescape</span></tt>‘ intrinsic once from the function entry block, and the
+child functions can use ‘<tt class="docutils literal"><span class="pre">llvm.localrecover</span></tt>‘ to access the escaped allocas.
+The ‘<tt class="docutils literal"><span class="pre">llvm.localescape</span></tt>‘ intrinsic blocks inlining, as inlining changes where
+the escaped allocas are allocated, which would break attempts to use
+‘<tt class="docutils literal"><span class="pre">llvm.localrecover</span></tt>‘.</p>
+</div>
+</div>
+<div class="section" id="llvm-read-register-and-llvm-write-register-intrinsics">
+<span id="int-write-register"></span><span id="int-read-register"></span><h4><a class="toc-backref" href="#id1394">‘<tt class="docutils literal"><span class="pre">llvm.read_register</span></tt>‘ and ‘<tt class="docutils literal"><span class="pre">llvm.write_register</span></tt>‘ Intrinsics</a><a class="headerlink" href="#llvm-read-register-and-llvm-write-register-intrinsics" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id372">
+<h5><a class="toc-backref" href="#id1395">Syntax:</a><a class="headerlink" href="#id372" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>declare i32 @llvm.read_register.i32(metadata)
+declare i64 @llvm.read_register.i64(metadata)
+declare void @llvm.write_register.i32(metadata, i32 @value)
+declare void @llvm.write_register.i64(metadata, i64 @value)
+!0 = !{!"sp\00"}</pre>
+</div>
+</div>
+<div class="section" id="id373">
+<h5><a class="toc-backref" href="#id1396">Overview:</a><a class="headerlink" href="#id373" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.read_register</span></tt>‘ and ‘<tt class="docutils literal"><span class="pre">llvm.write_register</span></tt>‘ intrinsics
+provides access to the named register. The register must be valid on
+the architecture being compiled to. The type needs to be compatible
+with the register being read.</p>
+</div>
+<div class="section" id="id374">
+<h5><a class="toc-backref" href="#id1397">Semantics:</a><a class="headerlink" href="#id374" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.read_register</span></tt>‘ intrinsic returns the current value of the
+register, where possible. The ‘<tt class="docutils literal"><span class="pre">llvm.write_register</span></tt>‘ intrinsic sets
+the current value of the register, where possible.</p>
+<p>This is useful to implement named register global variables that need
+to always be mapped to a specific register, as is common practice on
+bare-metal programs including OS kernels.</p>
+<p>The compiler doesn’t check for register availability or use of the used
+register in surrounding code, including inline assembly. Because of that,
+allocatable registers are not supported.</p>
+<p>Warning: So far it only works with the stack pointer on selected
+architectures (ARM, AArch64, PowerPC and x86_64). Significant amount of
+work is needed to support other registers and even more so, allocatable
+registers.</p>
+</div>
+</div>
+<div class="section" id="llvm-stacksave-intrinsic">
+<span id="int-stacksave"></span><h4><a class="toc-backref" href="#id1398">‘<tt class="docutils literal"><span class="pre">llvm.stacksave</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-stacksave-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id375">
+<h5><a class="toc-backref" href="#id1399">Syntax:</a><a class="headerlink" href="#id375" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>declare i8* @llvm.stacksave()</pre>
+</div>
+</div>
+<div class="section" id="id376">
+<h5><a class="toc-backref" href="#id1400">Overview:</a><a class="headerlink" href="#id376" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.stacksave</span></tt>‘ intrinsic is used to remember the current state
+of the function stack, for use with
+<a class="reference internal" href="#int-stackrestore"><em>llvm.stackrestore</em></a>. This is useful for
+implementing language features like scoped automatic variable sized
+arrays in C99.</p>
+</div>
+<div class="section" id="id377">
+<h5><a class="toc-backref" href="#id1401">Semantics:</a><a class="headerlink" href="#id377" title="Permalink to this headline">¶</a></h5>
+<p>This intrinsic returns a opaque pointer value that can be passed to
+<a class="reference internal" href="#int-stackrestore"><em>llvm.stackrestore</em></a>. When an
+<tt class="docutils literal"><span class="pre">llvm.stackrestore</span></tt> intrinsic is executed with a value saved from
+<tt class="docutils literal"><span class="pre">llvm.stacksave</span></tt>, it effectively restores the state of the stack to
+the state it was in when the <tt class="docutils literal"><span class="pre">llvm.stacksave</span></tt> intrinsic executed. In
+practice, this pops any <a class="reference internal" href="#i-alloca"><em>alloca</em></a> blocks from the stack that
+were allocated after the <tt class="docutils literal"><span class="pre">llvm.stacksave</span></tt> was executed.</p>
+</div>
+</div>
+<div class="section" id="llvm-stackrestore-intrinsic">
+<span id="int-stackrestore"></span><h4><a class="toc-backref" href="#id1402">‘<tt class="docutils literal"><span class="pre">llvm.stackrestore</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-stackrestore-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id378">
+<h5><a class="toc-backref" href="#id1403">Syntax:</a><a class="headerlink" href="#id378" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>declare void @llvm.stackrestore(i8* %ptr)</pre>
+</div>
+</div>
+<div class="section" id="id379">
+<h5><a class="toc-backref" href="#id1404">Overview:</a><a class="headerlink" href="#id379" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.stackrestore</span></tt>‘ intrinsic is used to restore the state of
+the function stack to the state it was in when the corresponding
+<a class="reference internal" href="#int-stacksave"><em>llvm.stacksave</em></a> intrinsic executed. This is
+useful for implementing language features like scoped automatic variable
+sized arrays in C99.</p>
+</div>
+<div class="section" id="id380">
+<h5><a class="toc-backref" href="#id1405">Semantics:</a><a class="headerlink" href="#id380" title="Permalink to this headline">¶</a></h5>
+<p>See the description for <a class="reference internal" href="#int-stacksave"><em>llvm.stacksave</em></a>.</p>
+</div>
+</div>
+<div class="section" id="llvm-get-dynamic-area-offset-intrinsic">
+<span id="int-get-dynamic-area-offset"></span><h4><a class="toc-backref" href="#id1406">‘<tt class="docutils literal"><span class="pre">llvm.get.dynamic.area.offset</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-get-dynamic-area-offset-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id381">
+<h5><a class="toc-backref" href="#id1407">Syntax:</a><a class="headerlink" href="#id381" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>declare i32 @llvm.get.dynamic.area.offset.i32()
+declare i64 @llvm.get.dynamic.area.offset.i64()</pre>
+</div>
+</div>
+<div class="section" id="id382">
+<h5><a class="toc-backref" href="#id1408">Overview:</a><a class="headerlink" href="#id382" title="Permalink to this headline">¶</a></h5>
+<blockquote>
+<div>The ‘<tt class="docutils literal"><span class="pre">llvm.get.dynamic.area.offset.*</span></tt>‘ intrinsic family is used to
+get the offset from native stack pointer to the address of the most
+recent dynamic alloca on the caller’s stack. These intrinsics are
+intendend for use in combination with
+<a class="reference internal" href="#int-stacksave"><em>llvm.stacksave</em></a> to get a
+pointer to the most recent dynamic alloca. This is useful, for example,
+for AddressSanitizer’s stack unpoisoning routines.</div></blockquote>
+</div>
+<div class="section" id="id383">
+<h5><a class="toc-backref" href="#id1409">Semantics:</a><a class="headerlink" href="#id383" title="Permalink to this headline">¶</a></h5>
+<blockquote>
+<div><p>These intrinsics return a non-negative integer value that can be used to
+get the address of the most recent dynamic alloca, allocated by <a class="reference internal" href="#i-alloca"><em>alloca</em></a>
+on the caller’s stack. In particular, for targets where stack grows downwards,
+adding this offset to the native stack pointer would get the address of the most
+recent dynamic alloca. For targets where stack grows upwards, the situation is a bit more
+complicated, because subtracting this value from stack pointer would get the address
+one past the end of the most recent dynamic alloca.</p>
+<p>Although for most targets <cite>llvm.get.dynamic.area.offset <int_get_dynamic_area_offset></cite>
+returns just a zero, for others, such as PowerPC and PowerPC64, it returns a
+compile-time-known constant value.</p>
+<p>The return value type of <a class="reference internal" href="#int-get-dynamic-area-offset"><em>llvm.get.dynamic.area.offset</em></a>
+must match the target’s default address space’s (address space 0) pointer type.</p>
+</div></blockquote>
+</div>
+</div>
+<div class="section" id="llvm-prefetch-intrinsic">
+<h4><a class="toc-backref" href="#id1410">‘<tt class="docutils literal"><span class="pre">llvm.prefetch</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-prefetch-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id384">
+<h5><a class="toc-backref" href="#id1411">Syntax:</a><a class="headerlink" href="#id384" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>declare void @llvm.prefetch(i8* <address>, i32 <rw>, i32 <locality>, i32 <cache type>)</pre>
+</div>
+</div>
+<div class="section" id="id385">
+<h5><a class="toc-backref" href="#id1412">Overview:</a><a class="headerlink" href="#id385" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.prefetch</span></tt>‘ intrinsic is a hint to the code generator to
+insert a prefetch instruction if supported; otherwise, it is a noop.
+Prefetches have no effect on the behavior of the program but can change
+its performance characteristics.</p>
+</div>
+<div class="section" id="id386">
+<h5><a class="toc-backref" href="#id1413">Arguments:</a><a class="headerlink" href="#id386" title="Permalink to this headline">¶</a></h5>
+<p><tt class="docutils literal"><span class="pre">address</span></tt> is the address to be prefetched, <tt class="docutils literal"><span class="pre">rw</span></tt> is the specifier
+determining if the fetch should be for a read (0) or write (1), and
+<tt class="docutils literal"><span class="pre">locality</span></tt> is a temporal locality specifier ranging from (0) - no
+locality, to (3) - extremely local keep in cache. The <tt class="docutils literal"><span class="pre">cache</span> <span class="pre">type</span></tt>
+specifies whether the prefetch is performed on the data (1) or
+instruction (0) cache. The <tt class="docutils literal"><span class="pre">rw</span></tt>, <tt class="docutils literal"><span class="pre">locality</span></tt> and <tt class="docutils literal"><span class="pre">cache</span> <span class="pre">type</span></tt>
+arguments must be constant integers.</p>
+</div>
+<div class="section" id="id387">
+<h5><a class="toc-backref" href="#id1414">Semantics:</a><a class="headerlink" href="#id387" title="Permalink to this headline">¶</a></h5>
+<p>This intrinsic does not modify the behavior of the program. In
+particular, prefetches cannot trap and do not produce a value. On
+targets that support this intrinsic, the prefetch can provide hints to
+the processor cache for better performance.</p>
+</div>
+</div>
+<div class="section" id="llvm-pcmarker-intrinsic">
+<h4><a class="toc-backref" href="#id1415">‘<tt class="docutils literal"><span class="pre">llvm.pcmarker</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-pcmarker-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id388">
+<h5><a class="toc-backref" href="#id1416">Syntax:</a><a class="headerlink" href="#id388" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>declare void @llvm.pcmarker(i32 <id>)</pre>
+</div>
+</div>
+<div class="section" id="id389">
+<h5><a class="toc-backref" href="#id1417">Overview:</a><a class="headerlink" href="#id389" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.pcmarker</span></tt>‘ intrinsic is a method to export a Program
+Counter (PC) in a region of code to simulators and other tools. The
+method is target specific, but it is expected that the marker will use
+exported symbols to transmit the PC of the marker. The marker makes no
+guarantees that it will remain with any specific instruction after
+optimizations. It is possible that the presence of a marker will inhibit
+optimizations. The intended use is to be inserted after optimizations to
+allow correlations of simulation runs.</p>
+</div>
+<div class="section" id="id390">
+<h5><a class="toc-backref" href="#id1418">Arguments:</a><a class="headerlink" href="#id390" title="Permalink to this headline">¶</a></h5>
+<p><tt class="docutils literal"><span class="pre">id</span></tt> is a numerical id identifying the marker.</p>
+</div>
+<div class="section" id="id391">
+<h5><a class="toc-backref" href="#id1419">Semantics:</a><a class="headerlink" href="#id391" title="Permalink to this headline">¶</a></h5>
+<p>This intrinsic does not modify the behavior of the program. Backends
+that do not support this intrinsic may ignore it.</p>
+</div>
+</div>
+<div class="section" id="llvm-readcyclecounter-intrinsic">
+<h4><a class="toc-backref" href="#id1420">‘<tt class="docutils literal"><span class="pre">llvm.readcyclecounter</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-readcyclecounter-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id392">
+<h5><a class="toc-backref" href="#id1421">Syntax:</a><a class="headerlink" href="#id392" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>declare i64 @llvm.readcyclecounter()</pre>
+</div>
+</div>
+<div class="section" id="id393">
+<h5><a class="toc-backref" href="#id1422">Overview:</a><a class="headerlink" href="#id393" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.readcyclecounter</span></tt>‘ intrinsic provides access to the cycle
+counter register (or similar low latency, high accuracy clocks) on those
+targets that support it. On X86, it should map to RDTSC. On Alpha, it
+should map to RPCC. As the backing counters overflow quickly (on the
+order of 9 seconds on alpha), this should only be used for small
+timings.</p>
+</div>
+<div class="section" id="id394">
+<h5><a class="toc-backref" href="#id1423">Semantics:</a><a class="headerlink" href="#id394" title="Permalink to this headline">¶</a></h5>
+<p>When directly supported, reading the cycle counter should not modify any
+memory. Implementations are allowed to either return a application
+specific value or a system wide value. On backends without support, this
+is lowered to a constant 0.</p>
+<p>Note that runtime support may be conditional on the privilege-level code is
+running at and the host platform.</p>
+</div>
+</div>
+<div class="section" id="llvm-clear-cache-intrinsic">
+<h4><a class="toc-backref" href="#id1424">‘<tt class="docutils literal"><span class="pre">llvm.clear_cache</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-clear-cache-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id395">
+<h5><a class="toc-backref" href="#id1425">Syntax:</a><a class="headerlink" href="#id395" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>declare void @llvm.clear_cache(i8*, i8*)</pre>
+</div>
+</div>
+<div class="section" id="id396">
+<h5><a class="toc-backref" href="#id1426">Overview:</a><a class="headerlink" href="#id396" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.clear_cache</span></tt>‘ intrinsic ensures visibility of modifications
+in the specified range to the execution unit of the processor. On
+targets with non-unified instruction and data cache, the implementation
+flushes the instruction cache.</p>
+</div>
+<div class="section" id="id397">
+<h5><a class="toc-backref" href="#id1427">Semantics:</a><a class="headerlink" href="#id397" title="Permalink to this headline">¶</a></h5>
+<p>On platforms with coherent instruction and data caches (e.g. x86), this
+intrinsic is a nop. On platforms with non-coherent instruction and data
+cache (e.g. ARM, MIPS), the intrinsic is lowered either to appropriate
+instructions or a system call, if cache flushing requires special
+privileges.</p>
+<p>The default behavior is to emit a call to <tt class="docutils literal"><span class="pre">__clear_cache</span></tt> from the run
+time library.</p>
+<p>This instrinsic does <em>not</em> empty the instruction pipeline. Modifications
+of the current function are outside the scope of the intrinsic.</p>
+</div>
+</div>
+<div class="section" id="llvm-instrprof-increment-intrinsic">
+<h4><a class="toc-backref" href="#id1428">‘<tt class="docutils literal"><span class="pre">llvm.instrprof_increment</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-instrprof-increment-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id398">
+<h5><a class="toc-backref" href="#id1429">Syntax:</a><a class="headerlink" href="#id398" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>declare void @llvm.instrprof_increment(i8* <name>, i64 <hash>,
+                                       i32 <num-counters>, i32 <index>)</pre>
+</div>
+</div>
+<div class="section" id="id399">
+<h5><a class="toc-backref" href="#id1430">Overview:</a><a class="headerlink" href="#id399" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.instrprof_increment</span></tt>‘ intrinsic can be emitted by a
+frontend for use with instrumentation based profiling. These will be
+lowered by the <tt class="docutils literal"><span class="pre">-instrprof</span></tt> pass to generate execution counts of a
+program at runtime.</p>
+</div>
+<div class="section" id="id400">
+<h5><a class="toc-backref" href="#id1431">Arguments:</a><a class="headerlink" href="#id400" title="Permalink to this headline">¶</a></h5>
+<p>The first argument is a pointer to a global variable containing the
+name of the entity being instrumented. This should generally be the
+(mangled) function name for a set of counters.</p>
+<p>The second argument is a hash value that can be used by the consumer
+of the profile data to detect changes to the instrumented source, and
+the third is the number of counters associated with <tt class="docutils literal"><span class="pre">name</span></tt>. It is an
+error if <tt class="docutils literal"><span class="pre">hash</span></tt> or <tt class="docutils literal"><span class="pre">num-counters</span></tt> differ between two instances of
+<tt class="docutils literal"><span class="pre">instrprof_increment</span></tt> that refer to the same name.</p>
+<p>The last argument refers to which of the counters for <tt class="docutils literal"><span class="pre">name</span></tt> should
+be incremented. It should be a value between 0 and <tt class="docutils literal"><span class="pre">num-counters</span></tt>.</p>
+</div>
+<div class="section" id="id401">
+<h5><a class="toc-backref" href="#id1432">Semantics:</a><a class="headerlink" href="#id401" title="Permalink to this headline">¶</a></h5>
+<p>This intrinsic represents an increment of a profiling counter. It will
+cause the <tt class="docutils literal"><span class="pre">-instrprof</span></tt> pass to generate the appropriate data
+structures and the code to increment the appropriate value, in a
+format that can be written out by a compiler runtime and consumed via
+the <tt class="docutils literal"><span class="pre">llvm-profdata</span></tt> tool.</p>
+</div>
+</div>
+<div class="section" id="llvm-instrprof-increment-step-intrinsic">
+<h4><a class="toc-backref" href="#id1433">‘<tt class="docutils literal"><span class="pre">llvm.instrprof_increment_step</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-instrprof-increment-step-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id402">
+<h5><a class="toc-backref" href="#id1434">Syntax:</a><a class="headerlink" href="#id402" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>declare void @llvm.instrprof_increment_step(i8* <name>, i64 <hash>,
+                                            i32 <num-counters>,
+                                            i32 <index>, i64 <step>)</pre>
+</div>
+</div>
+<div class="section" id="id403">
+<h5><a class="toc-backref" href="#id1435">Overview:</a><a class="headerlink" href="#id403" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.instrprof_increment_step</span></tt>‘ intrinsic is an extension to
+the ‘<tt class="docutils literal"><span class="pre">llvm.instrprof_increment</span></tt>‘ intrinsic with an additional fifth
+argument to specify the step of the increment.</p>
+</div>
+<div class="section" id="id404">
+<h5><a class="toc-backref" href="#id1436">Arguments:</a><a class="headerlink" href="#id404" title="Permalink to this headline">¶</a></h5>
+<p>The first four arguments are the same as ‘<tt class="docutils literal"><span class="pre">llvm.instrprof_increment</span></tt>‘
+intrinsic.</p>
+<p>The last argument specifies the value of the increment of the counter variable.</p>
+</div>
+<div class="section" id="id405">
+<h5><a class="toc-backref" href="#id1437">Semantics:</a><a class="headerlink" href="#id405" title="Permalink to this headline">¶</a></h5>
+<p>See description of ‘<tt class="docutils literal"><span class="pre">llvm.instrprof_increment</span></tt>‘ instrinsic.</p>
+</div>
+</div>
+<div class="section" id="llvm-instrprof-value-profile-intrinsic">
+<h4><a class="toc-backref" href="#id1438">‘<tt class="docutils literal"><span class="pre">llvm.instrprof_value_profile</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-instrprof-value-profile-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id406">
+<h5><a class="toc-backref" href="#id1439">Syntax:</a><a class="headerlink" href="#id406" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>declare void @llvm.instrprof_value_profile(i8* <name>, i64 <hash>,
+                                           i64 <value>, i32 <value_kind>,
+                                           i32 <index>)</pre>
+</div>
+</div>
+<div class="section" id="id407">
+<h5><a class="toc-backref" href="#id1440">Overview:</a><a class="headerlink" href="#id407" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.instrprof_value_profile</span></tt>‘ intrinsic can be emitted by a
+frontend for use with instrumentation based profiling. This will be
+lowered by the <tt class="docutils literal"><span class="pre">-instrprof</span></tt> pass to find out the target values,
+instrumented expressions take in a program at runtime.</p>
+</div>
+<div class="section" id="id408">
+<h5><a class="toc-backref" href="#id1441">Arguments:</a><a class="headerlink" href="#id408" title="Permalink to this headline">¶</a></h5>
+<p>The first argument is a pointer to a global variable containing the
+name of the entity being instrumented. <tt class="docutils literal"><span class="pre">name</span></tt> should generally be the
+(mangled) function name for a set of counters.</p>
+<p>The second argument is a hash value that can be used by the consumer
+of the profile data to detect changes to the instrumented source. It
+is an error if <tt class="docutils literal"><span class="pre">hash</span></tt> differs between two instances of
+<tt class="docutils literal"><span class="pre">llvm.instrprof_*</span></tt> that refer to the same name.</p>
+<p>The third argument is the value of the expression being profiled. The profiled
+expression’s value should be representable as an unsigned 64-bit value. The
+fourth argument represents the kind of value profiling that is being done. The
+supported value profiling kinds are enumerated through the
+<tt class="docutils literal"><span class="pre">InstrProfValueKind</span></tt> type declared in the
+<tt class="docutils literal"><span class="pre"><include/llvm/ProfileData/InstrProf.h></span></tt> header file. The last argument is the
+index of the instrumented expression within <tt class="docutils literal"><span class="pre">name</span></tt>. It should be >= 0.</p>
+</div>
+<div class="section" id="id409">
+<h5><a class="toc-backref" href="#id1442">Semantics:</a><a class="headerlink" href="#id409" title="Permalink to this headline">¶</a></h5>
+<p>This intrinsic represents the point where a call to a runtime routine
+should be inserted for value profiling of target expressions. <tt class="docutils literal"><span class="pre">-instrprof</span></tt>
+pass will generate the appropriate data structures and replace the
+<tt class="docutils literal"><span class="pre">llvm.instrprof_value_profile</span></tt> intrinsic with the call to the profile
+runtime library with proper arguments.</p>
+</div>
+</div>
+<div class="section" id="llvm-thread-pointer-intrinsic">
+<h4><a class="toc-backref" href="#id1443">‘<tt class="docutils literal"><span class="pre">llvm.thread.pointer</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-thread-pointer-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id410">
+<h5><a class="toc-backref" href="#id1444">Syntax:</a><a class="headerlink" href="#id410" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><pre>declare i8* @llvm.thread.pointer()</pre>
+</div>
+</div>
+<div class="section" id="id411">
+<h5><a class="toc-backref" href="#id1445">Overview:</a><a class="headerlink" href="#id411" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.thread.pointer</span></tt>‘ intrinsic returns the value of the thread
+pointer.</p>
+</div>
+<div class="section" id="id412">
+<h5><a class="toc-backref" href="#id1446">Semantics:</a><a class="headerlink" href="#id412" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.thread.pointer</span></tt>‘ intrinsic returns a pointer to the TLS area
+for the current thread.  The exact semantics of this value are target
+specific: it may point to the start of TLS area, to the end, or somewhere
+in the middle.  Depending on the target, this intrinsic may read a register,
+call a helper function, read from an alternate memory space, or perform
+other operations necessary to locate the TLS area.  Not all targets support
+this intrinsic.</p>
+</div>
+</div>
+</div>
+<div class="section" id="standard-c-library-intrinsics">
+<h3><a class="toc-backref" href="#id1447">Standard C Library Intrinsics</a><a class="headerlink" href="#standard-c-library-intrinsics" title="Permalink to this headline">¶</a></h3>
+<p>LLVM provides intrinsics for a few important standard C library
+functions. These intrinsics allow source-language front-ends to pass
+information about the alignment of the pointer arguments to the code
+generator, providing opportunity for more efficient code generation.</p>
+<div class="section" id="llvm-memcpy-intrinsic">
+<span id="int-memcpy"></span><h4><a class="toc-backref" href="#id1448">‘<tt class="docutils literal"><span class="pre">llvm.memcpy</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-memcpy-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id413">
+<h5><a class="toc-backref" href="#id1449">Syntax:</a><a class="headerlink" href="#id413" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.memcpy</span></tt> on any
+integer bit width and for different address spaces. Not all targets
+support all bit widths however.</p>
+<div class="highlight-python"><pre>declare void @llvm.memcpy.p0i8.p0i8.i32(i8* <dest>, i8* <src>,
+                                        i32 <len>, i32 <align>, i1 <isvolatile>)
+declare void @llvm.memcpy.p0i8.p0i8.i64(i8* <dest>, i8* <src>,
+                                        i64 <len>, i32 <align>, i1 <isvolatile>)</pre>
+</div>
+</div>
+<div class="section" id="id414">
+<h5><a class="toc-backref" href="#id1450">Overview:</a><a class="headerlink" href="#id414" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.memcpy.*</span></tt>‘ intrinsics copy a block of memory from the
+source location to the destination location.</p>
+<p>Note that, unlike the standard libc function, the <tt class="docutils literal"><span class="pre">llvm.memcpy.*</span></tt>
+intrinsics do not return a value, takes extra alignment/isvolatile
+arguments and the pointers can be in specified address spaces.</p>
+</div>
+<div class="section" id="id415">
+<h5><a class="toc-backref" href="#id1451">Arguments:</a><a class="headerlink" href="#id415" title="Permalink to this headline">¶</a></h5>
+<p>The first argument is a pointer to the destination, the second is a
+pointer to the source. The third argument is an integer argument
+specifying the number of bytes to copy, the fourth argument is the
+alignment of the source and destination locations, and the fifth is a
+boolean indicating a volatile access.</p>
+<p>If the call to this intrinsic has an alignment value that is not 0 or 1,
+then the caller guarantees that both the source and destination pointers
+are aligned to that boundary.</p>
+<p>If the <tt class="docutils literal"><span class="pre">isvolatile</span></tt> parameter is <tt class="docutils literal"><span class="pre">true</span></tt>, the <tt class="docutils literal"><span class="pre">llvm.memcpy</span></tt> call is
+a <a class="reference internal" href="#volatile"><em>volatile operation</em></a>. The detailed access behavior is not
+very cleanly specified and it is unwise to depend on it.</p>
+</div>
+<div class="section" id="id416">
+<h5><a class="toc-backref" href="#id1452">Semantics:</a><a class="headerlink" href="#id416" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.memcpy.*</span></tt>‘ intrinsics copy a block of memory from the
+source location to the destination location, which are not allowed to
+overlap. It copies “len” bytes of memory over. If the argument is known
+to be aligned to some boundary, this can be specified as the fourth
+argument, otherwise it should be set to 0 or 1 (both meaning no alignment).</p>
+</div>
+</div>
+<div class="section" id="llvm-memmove-intrinsic">
+<span id="int-memmove"></span><h4><a class="toc-backref" href="#id1453">‘<tt class="docutils literal"><span class="pre">llvm.memmove</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-memmove-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id417">
+<h5><a class="toc-backref" href="#id1454">Syntax:</a><a class="headerlink" href="#id417" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use llvm.memmove on any integer
+bit width and for different address space. Not all targets support all
+bit widths however.</p>
+<div class="highlight-python"><pre>declare void @llvm.memmove.p0i8.p0i8.i32(i8* <dest>, i8* <src>,
+                                         i32 <len>, i32 <align>, i1 <isvolatile>)
+declare void @llvm.memmove.p0i8.p0i8.i64(i8* <dest>, i8* <src>,
+                                         i64 <len>, i32 <align>, i1 <isvolatile>)</pre>
+</div>
+</div>
+<div class="section" id="id418">
+<h5><a class="toc-backref" href="#id1455">Overview:</a><a class="headerlink" href="#id418" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.memmove.*</span></tt>‘ intrinsics move a block of memory from the
+source location to the destination location. It is similar to the
+‘<tt class="docutils literal"><span class="pre">llvm.memcpy</span></tt>‘ intrinsic but allows the two memory locations to
+overlap.</p>
+<p>Note that, unlike the standard libc function, the <tt class="docutils literal"><span class="pre">llvm.memmove.*</span></tt>
+intrinsics do not return a value, takes extra alignment/isvolatile
+arguments and the pointers can be in specified address spaces.</p>
+</div>
+<div class="section" id="id419">
+<h5><a class="toc-backref" href="#id1456">Arguments:</a><a class="headerlink" href="#id419" title="Permalink to this headline">¶</a></h5>
+<p>The first argument is a pointer to the destination, the second is a
+pointer to the source. The third argument is an integer argument
+specifying the number of bytes to copy, the fourth argument is the
+alignment of the source and destination locations, and the fifth is a
+boolean indicating a volatile access.</p>
+<p>If the call to this intrinsic has an alignment value that is not 0 or 1,
+then the caller guarantees that the source and destination pointers are
+aligned to that boundary.</p>
+<p>If the <tt class="docutils literal"><span class="pre">isvolatile</span></tt> parameter is <tt class="docutils literal"><span class="pre">true</span></tt>, the <tt class="docutils literal"><span class="pre">llvm.memmove</span></tt> call
+is a <a class="reference internal" href="#volatile"><em>volatile operation</em></a>. The detailed access behavior is
+not very cleanly specified and it is unwise to depend on it.</p>
+</div>
+<div class="section" id="id420">
+<h5><a class="toc-backref" href="#id1457">Semantics:</a><a class="headerlink" href="#id420" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.memmove.*</span></tt>‘ intrinsics copy a block of memory from the
+source location to the destination location, which may overlap. It
+copies “len” bytes of memory over. If the argument is known to be
+aligned to some boundary, this can be specified as the fourth argument,
+otherwise it should be set to 0 or 1 (both meaning no alignment).</p>
+</div>
+</div>
+<div class="section" id="llvm-memset-intrinsics">
+<span id="int-memset"></span><h4><a class="toc-backref" href="#id1458">‘<tt class="docutils literal"><span class="pre">llvm.memset.*</span></tt>‘ Intrinsics</a><a class="headerlink" href="#llvm-memset-intrinsics" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id421">
+<h5><a class="toc-backref" href="#id1459">Syntax:</a><a class="headerlink" href="#id421" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use llvm.memset on any integer
+bit width and for different address spaces. However, not all targets
+support all bit widths.</p>
+<div class="highlight-python"><pre>declare void @llvm.memset.p0i8.i32(i8* <dest>, i8 <val>,
+                                   i32 <len>, i32 <align>, i1 <isvolatile>)
+declare void @llvm.memset.p0i8.i64(i8* <dest>, i8 <val>,
+                                   i64 <len>, i32 <align>, i1 <isvolatile>)</pre>
+</div>
+</div>
+<div class="section" id="id422">
+<h5><a class="toc-backref" href="#id1460">Overview:</a><a class="headerlink" href="#id422" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.memset.*</span></tt>‘ intrinsics fill a block of memory with a
+particular byte value.</p>
+<p>Note that, unlike the standard libc function, the <tt class="docutils literal"><span class="pre">llvm.memset</span></tt>
+intrinsic does not return a value and takes extra alignment/volatile
+arguments. Also, the destination can be in an arbitrary address space.</p>
+</div>
+<div class="section" id="id423">
+<h5><a class="toc-backref" href="#id1461">Arguments:</a><a class="headerlink" href="#id423" title="Permalink to this headline">¶</a></h5>
+<p>The first argument is a pointer to the destination to fill, the second
+is the byte value with which to fill it, the third argument is an
+integer argument specifying the number of bytes to fill, and the fourth
+argument is the known alignment of the destination location.</p>
+<p>If the call to this intrinsic has an alignment value that is not 0 or 1,
+then the caller guarantees that the destination pointer is aligned to
+that boundary.</p>
+<p>If the <tt class="docutils literal"><span class="pre">isvolatile</span></tt> parameter is <tt class="docutils literal"><span class="pre">true</span></tt>, the <tt class="docutils literal"><span class="pre">llvm.memset</span></tt> call is
+a <a class="reference internal" href="#volatile"><em>volatile operation</em></a>. The detailed access behavior is not
+very cleanly specified and it is unwise to depend on it.</p>
+</div>
+<div class="section" id="id424">
+<h5><a class="toc-backref" href="#id1462">Semantics:</a><a class="headerlink" href="#id424" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.memset.*</span></tt>‘ intrinsics fill “len” bytes of memory starting
+at the destination location. If the argument is known to be aligned to
+some boundary, this can be specified as the fourth argument, otherwise
+it should be set to 0 or 1 (both meaning no alignment).</p>
+</div>
+</div>
+<div class="section" id="llvm-sqrt-intrinsic">
+<h4><a class="toc-backref" href="#id1463">‘<tt class="docutils literal"><span class="pre">llvm.sqrt.*</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-sqrt-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id425">
+<h5><a class="toc-backref" href="#id1464">Syntax:</a><a class="headerlink" href="#id425" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.sqrt</span></tt> on any
+floating-point or vector of floating-point type. Not all targets support
+all types however.</p>
+<div class="highlight-python"><pre>declare float     @llvm.sqrt.f32(float %Val)
+declare double    @llvm.sqrt.f64(double %Val)
+declare x86_fp80  @llvm.sqrt.f80(x86_fp80 %Val)
+declare fp128     @llvm.sqrt.f128(fp128 %Val)
+declare ppc_fp128 @llvm.sqrt.ppcf128(ppc_fp128 %Val)</pre>
+</div>
+</div>
+<div class="section" id="id426">
+<h5><a class="toc-backref" href="#id1465">Overview:</a><a class="headerlink" href="#id426" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.sqrt</span></tt>‘ intrinsics return the square root of the specified value.</p>
+</div>
+<div class="section" id="id427">
+<h5><a class="toc-backref" href="#id1466">Arguments:</a><a class="headerlink" href="#id427" title="Permalink to this headline">¶</a></h5>
+<p>The argument and return value are floating-point numbers of the same type.</p>
+</div>
+<div class="section" id="id428">
+<h5><a class="toc-backref" href="#id1467">Semantics:</a><a class="headerlink" href="#id428" title="Permalink to this headline">¶</a></h5>
+<p>Return the same value as a corresponding libm ‘<tt class="docutils literal"><span class="pre">sqrt</span></tt>‘ function but without
+trapping or setting <tt class="docutils literal"><span class="pre">errno</span></tt>. For types specified by IEEE-754, the result
+matches a conforming libm implementation.</p>
+<p>When specified with the fast-math-flag ‘afn’, the result may be approximated
+using a less accurate calculation.</p>
+</div>
+</div>
+<div class="section" id="llvm-powi-intrinsic">
+<h4><a class="toc-backref" href="#id1468">‘<tt class="docutils literal"><span class="pre">llvm.powi.*</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-powi-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id429">
+<h5><a class="toc-backref" href="#id1469">Syntax:</a><a class="headerlink" href="#id429" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.powi</span></tt> on any
+floating point or vector of floating point type. Not all targets support
+all types however.</p>
+<div class="highlight-python"><pre>declare float     @llvm.powi.f32(float  %Val, i32 %power)
+declare double    @llvm.powi.f64(double %Val, i32 %power)
+declare x86_fp80  @llvm.powi.f80(x86_fp80  %Val, i32 %power)
+declare fp128     @llvm.powi.f128(fp128 %Val, i32 %power)
+declare ppc_fp128 @llvm.powi.ppcf128(ppc_fp128  %Val, i32 %power)</pre>
+</div>
+</div>
+<div class="section" id="id430">
+<h5><a class="toc-backref" href="#id1470">Overview:</a><a class="headerlink" href="#id430" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.powi.*</span></tt>‘ intrinsics return the first operand raised to the
+specified (positive or negative) power. The order of evaluation of
+multiplications is not defined. When a vector of floating point type is
+used, the second argument remains a scalar integer value.</p>
+</div>
+<div class="section" id="id431">
+<h5><a class="toc-backref" href="#id1471">Arguments:</a><a class="headerlink" href="#id431" title="Permalink to this headline">¶</a></h5>
+<p>The second argument is an integer power, and the first is a value to
+raise to that power.</p>
+</div>
+<div class="section" id="id432">
+<h5><a class="toc-backref" href="#id1472">Semantics:</a><a class="headerlink" href="#id432" title="Permalink to this headline">¶</a></h5>
+<p>This function returns the first value raised to the second power with an
+unspecified sequence of rounding operations.</p>
+</div>
+</div>
+<div class="section" id="llvm-sin-intrinsic">
+<h4><a class="toc-backref" href="#id1473">‘<tt class="docutils literal"><span class="pre">llvm.sin.*</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-sin-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id433">
+<h5><a class="toc-backref" href="#id1474">Syntax:</a><a class="headerlink" href="#id433" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.sin</span></tt> on any
+floating-point or vector of floating-point type. Not all targets support
+all types however.</p>
+<div class="highlight-python"><pre>declare float     @llvm.sin.f32(float  %Val)
+declare double    @llvm.sin.f64(double %Val)
+declare x86_fp80  @llvm.sin.f80(x86_fp80  %Val)
+declare fp128     @llvm.sin.f128(fp128 %Val)
+declare ppc_fp128 @llvm.sin.ppcf128(ppc_fp128  %Val)</pre>
+</div>
+</div>
+<div class="section" id="id434">
+<h5><a class="toc-backref" href="#id1475">Overview:</a><a class="headerlink" href="#id434" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.sin.*</span></tt>‘ intrinsics return the sine of the operand.</p>
+</div>
+<div class="section" id="id435">
+<h5><a class="toc-backref" href="#id1476">Arguments:</a><a class="headerlink" href="#id435" title="Permalink to this headline">¶</a></h5>
+<p>The argument and return value are floating-point numbers of the same type.</p>
+</div>
+<div class="section" id="id436">
+<h5><a class="toc-backref" href="#id1477">Semantics:</a><a class="headerlink" href="#id436" title="Permalink to this headline">¶</a></h5>
+<p>Return the same value as a corresponding libm ‘<tt class="docutils literal"><span class="pre">sin</span></tt>‘ function but without
+trapping or setting <tt class="docutils literal"><span class="pre">errno</span></tt>.</p>
+<p>When specified with the fast-math-flag ‘afn’, the result may be approximated
+using a less accurate calculation.</p>
+</div>
+</div>
+<div class="section" id="llvm-cos-intrinsic">
+<h4><a class="toc-backref" href="#id1478">‘<tt class="docutils literal"><span class="pre">llvm.cos.*</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-cos-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id437">
+<h5><a class="toc-backref" href="#id1479">Syntax:</a><a class="headerlink" href="#id437" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.cos</span></tt> on any
+floating-point or vector of floating-point type. Not all targets support
+all types however.</p>
+<div class="highlight-python"><pre>declare float     @llvm.cos.f32(float  %Val)
+declare double    @llvm.cos.f64(double %Val)
+declare x86_fp80  @llvm.cos.f80(x86_fp80  %Val)
+declare fp128     @llvm.cos.f128(fp128 %Val)
+declare ppc_fp128 @llvm.cos.ppcf128(ppc_fp128  %Val)</pre>
+</div>
+</div>
+<div class="section" id="id438">
+<h5><a class="toc-backref" href="#id1480">Overview:</a><a class="headerlink" href="#id438" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.cos.*</span></tt>‘ intrinsics return the cosine of the operand.</p>
+</div>
+<div class="section" id="id439">
+<h5><a class="toc-backref" href="#id1481">Arguments:</a><a class="headerlink" href="#id439" title="Permalink to this headline">¶</a></h5>
+<p>The argument and return value are floating-point numbers of the same type.</p>
+</div>
+<div class="section" id="id440">
+<h5><a class="toc-backref" href="#id1482">Semantics:</a><a class="headerlink" href="#id440" title="Permalink to this headline">¶</a></h5>
+<p>Return the same value as a corresponding libm ‘<tt class="docutils literal"><span class="pre">cos</span></tt>‘ function but without
+trapping or setting <tt class="docutils literal"><span class="pre">errno</span></tt>.</p>
+<p>When specified with the fast-math-flag ‘afn’, the result may be approximated
+using a less accurate calculation.</p>
+</div>
+</div>
+<div class="section" id="llvm-pow-intrinsic">
+<h4><a class="toc-backref" href="#id1483">‘<tt class="docutils literal"><span class="pre">llvm.pow.*</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-pow-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id441">
+<h5><a class="toc-backref" href="#id1484">Syntax:</a><a class="headerlink" href="#id441" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.pow</span></tt> on any
+floating-point or vector of floating-point type. Not all targets support
+all types however.</p>
+<div class="highlight-python"><pre>declare float     @llvm.pow.f32(float  %Val, float %Power)
+declare double    @llvm.pow.f64(double %Val, double %Power)
+declare x86_fp80  @llvm.pow.f80(x86_fp80  %Val, x86_fp80 %Power)
+declare fp128     @llvm.pow.f128(fp128 %Val, fp128 %Power)
+declare ppc_fp128 @llvm.pow.ppcf128(ppc_fp128  %Val, ppc_fp128 Power)</pre>
+</div>
+</div>
+<div class="section" id="id442">
+<h5><a class="toc-backref" href="#id1485">Overview:</a><a class="headerlink" href="#id442" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.pow.*</span></tt>‘ intrinsics return the first operand raised to the
+specified (positive or negative) power.</p>
+</div>
+<div class="section" id="id443">
+<h5><a class="toc-backref" href="#id1486">Arguments:</a><a class="headerlink" href="#id443" title="Permalink to this headline">¶</a></h5>
+<p>The arguments and return value are floating-point numbers of the same type.</p>
+</div>
+<div class="section" id="id444">
+<h5><a class="toc-backref" href="#id1487">Semantics:</a><a class="headerlink" href="#id444" title="Permalink to this headline">¶</a></h5>
+<p>Return the same value as a corresponding libm ‘<tt class="docutils literal"><span class="pre">pow</span></tt>‘ function but without
+trapping or setting <tt class="docutils literal"><span class="pre">errno</span></tt>.</p>
+<p>When specified with the fast-math-flag ‘afn’, the result may be approximated
+using a less accurate calculation.</p>
+</div>
+</div>
+<div class="section" id="llvm-exp-intrinsic">
+<h4><a class="toc-backref" href="#id1488">‘<tt class="docutils literal"><span class="pre">llvm.exp.*</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-exp-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id445">
+<h5><a class="toc-backref" href="#id1489">Syntax:</a><a class="headerlink" href="#id445" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.exp</span></tt> on any
+floating-point or vector of floating-point type. Not all targets support
+all types however.</p>
+<div class="highlight-python"><pre>declare float     @llvm.exp.f32(float  %Val)
+declare double    @llvm.exp.f64(double %Val)
+declare x86_fp80  @llvm.exp.f80(x86_fp80  %Val)
+declare fp128     @llvm.exp.f128(fp128 %Val)
+declare ppc_fp128 @llvm.exp.ppcf128(ppc_fp128  %Val)</pre>
+</div>
+</div>
+<div class="section" id="id446">
+<h5><a class="toc-backref" href="#id1490">Overview:</a><a class="headerlink" href="#id446" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.exp.*</span></tt>‘ intrinsics compute the base-e exponential of the specified
+value.</p>
+</div>
+<div class="section" id="id447">
+<h5><a class="toc-backref" href="#id1491">Arguments:</a><a class="headerlink" href="#id447" title="Permalink to this headline">¶</a></h5>
+<p>The argument and return value are floating-point numbers of the same type.</p>
+</div>
+<div class="section" id="id448">
+<h5><a class="toc-backref" href="#id1492">Semantics:</a><a class="headerlink" href="#id448" title="Permalink to this headline">¶</a></h5>
+<p>Return the same value as a corresponding libm ‘<tt class="docutils literal"><span class="pre">exp</span></tt>‘ function but without
+trapping or setting <tt class="docutils literal"><span class="pre">errno</span></tt>.</p>
+<p>When specified with the fast-math-flag ‘afn’, the result may be approximated
+using a less accurate calculation.</p>
+</div>
+</div>
+<div class="section" id="llvm-exp2-intrinsic">
+<h4><a class="toc-backref" href="#id1493">‘<tt class="docutils literal"><span class="pre">llvm.exp2.*</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-exp2-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id449">
+<h5><a class="toc-backref" href="#id1494">Syntax:</a><a class="headerlink" href="#id449" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.exp2</span></tt> on any
+floating-point or vector of floating-point type. Not all targets support
+all types however.</p>
+<div class="highlight-python"><pre>declare float     @llvm.exp2.f32(float  %Val)
+declare double    @llvm.exp2.f64(double %Val)
+declare x86_fp80  @llvm.exp2.f80(x86_fp80  %Val)
+declare fp128     @llvm.exp2.f128(fp128 %Val)
+declare ppc_fp128 @llvm.exp2.ppcf128(ppc_fp128  %Val)</pre>
+</div>
+</div>
+<div class="section" id="id450">
+<h5><a class="toc-backref" href="#id1495">Overview:</a><a class="headerlink" href="#id450" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.exp2.*</span></tt>‘ intrinsics compute the base-2 exponential of the
+specified value.</p>
+</div>
+<div class="section" id="id451">
+<h5><a class="toc-backref" href="#id1496">Arguments:</a><a class="headerlink" href="#id451" title="Permalink to this headline">¶</a></h5>
+<p>The argument and return value are floating-point numbers of the same type.</p>
+</div>
+<div class="section" id="id452">
+<h5><a class="toc-backref" href="#id1497">Semantics:</a><a class="headerlink" href="#id452" title="Permalink to this headline">¶</a></h5>
+<p>Return the same value as a corresponding libm ‘<tt class="docutils literal"><span class="pre">exp2</span></tt>‘ function but without
+trapping or setting <tt class="docutils literal"><span class="pre">errno</span></tt>.</p>
+<p>When specified with the fast-math-flag ‘afn’, the result may be approximated
+using a less accurate calculation.</p>
+</div>
+</div>
+<div class="section" id="llvm-log-intrinsic">
+<h4><a class="toc-backref" href="#id1498">‘<tt class="docutils literal"><span class="pre">llvm.log.*</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-log-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id453">
+<h5><a class="toc-backref" href="#id1499">Syntax:</a><a class="headerlink" href="#id453" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.log</span></tt> on any
+floating-point or vector of floating-point type. Not all targets support
+all types however.</p>
+<div class="highlight-python"><pre>declare float     @llvm.log.f32(float  %Val)
+declare double    @llvm.log.f64(double %Val)
+declare x86_fp80  @llvm.log.f80(x86_fp80  %Val)
+declare fp128     @llvm.log.f128(fp128 %Val)
+declare ppc_fp128 @llvm.log.ppcf128(ppc_fp128  %Val)</pre>
+</div>
+</div>
+<div class="section" id="id454">
+<h5><a class="toc-backref" href="#id1500">Overview:</a><a class="headerlink" href="#id454" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.log.*</span></tt>‘ intrinsics compute the base-e logarithm of the specified
+value.</p>
+</div>
+<div class="section" id="id455">
+<h5><a class="toc-backref" href="#id1501">Arguments:</a><a class="headerlink" href="#id455" title="Permalink to this headline">¶</a></h5>
+<p>The argument and return value are floating-point numbers of the same type.</p>
+</div>
+<div class="section" id="id456">
+<h5><a class="toc-backref" href="#id1502">Semantics:</a><a class="headerlink" href="#id456" title="Permalink to this headline">¶</a></h5>
+<p>Return the same value as a corresponding libm ‘<tt class="docutils literal"><span class="pre">log</span></tt>‘ function but without
+trapping or setting <tt class="docutils literal"><span class="pre">errno</span></tt>.</p>
+<p>When specified with the fast-math-flag ‘afn’, the result may be approximated
+using a less accurate calculation.</p>
+</div>
+</div>
+<div class="section" id="llvm-log10-intrinsic">
+<h4><a class="toc-backref" href="#id1503">‘<tt class="docutils literal"><span class="pre">llvm.log10.*</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-log10-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id457">
+<h5><a class="toc-backref" href="#id1504">Syntax:</a><a class="headerlink" href="#id457" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.log10</span></tt> on any
+floating-point or vector of floating-point type. Not all targets support
+all types however.</p>
+<div class="highlight-python"><pre>declare float     @llvm.log10.f32(float  %Val)
+declare double    @llvm.log10.f64(double %Val)
+declare x86_fp80  @llvm.log10.f80(x86_fp80  %Val)
+declare fp128     @llvm.log10.f128(fp128 %Val)
+declare ppc_fp128 @llvm.log10.ppcf128(ppc_fp128  %Val)</pre>
+</div>
+</div>
+<div class="section" id="id458">
+<h5><a class="toc-backref" href="#id1505">Overview:</a><a class="headerlink" href="#id458" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.log10.*</span></tt>‘ intrinsics compute the base-10 logarithm of the
+specified value.</p>
+</div>
+<div class="section" id="id459">
+<h5><a class="toc-backref" href="#id1506">Arguments:</a><a class="headerlink" href="#id459" title="Permalink to this headline">¶</a></h5>
+<p>The argument and return value are floating-point numbers of the same type.</p>
+</div>
+<div class="section" id="id460">
+<h5><a class="toc-backref" href="#id1507">Semantics:</a><a class="headerlink" href="#id460" title="Permalink to this headline">¶</a></h5>
+<p>Return the same value as a corresponding libm ‘<tt class="docutils literal"><span class="pre">log10</span></tt>‘ function but without
+trapping or setting <tt class="docutils literal"><span class="pre">errno</span></tt>.</p>
+<p>When specified with the fast-math-flag ‘afn’, the result may be approximated
+using a less accurate calculation.</p>
+</div>
+</div>
+<div class="section" id="llvm-log2-intrinsic">
+<h4><a class="toc-backref" href="#id1508">‘<tt class="docutils literal"><span class="pre">llvm.log2.*</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-log2-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id461">
+<h5><a class="toc-backref" href="#id1509">Syntax:</a><a class="headerlink" href="#id461" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.log2</span></tt> on any
+floating-point or vector of floating-point type. Not all targets support
+all types however.</p>
+<div class="highlight-python"><pre>declare float     @llvm.log2.f32(float  %Val)
+declare double    @llvm.log2.f64(double %Val)
+declare x86_fp80  @llvm.log2.f80(x86_fp80  %Val)
+declare fp128     @llvm.log2.f128(fp128 %Val)
+declare ppc_fp128 @llvm.log2.ppcf128(ppc_fp128  %Val)</pre>
+</div>
+</div>
+<div class="section" id="id462">
+<h5><a class="toc-backref" href="#id1510">Overview:</a><a class="headerlink" href="#id462" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.log2.*</span></tt>‘ intrinsics compute the base-2 logarithm of the specified
+value.</p>
+</div>
+<div class="section" id="id463">
+<h5><a class="toc-backref" href="#id1511">Arguments:</a><a class="headerlink" href="#id463" title="Permalink to this headline">¶</a></h5>
+<p>The argument and return value are floating-point numbers of the same type.</p>
+</div>
+<div class="section" id="id464">
+<h5><a class="toc-backref" href="#id1512">Semantics:</a><a class="headerlink" href="#id464" title="Permalink to this headline">¶</a></h5>
+<p>Return the same value as a corresponding libm ‘<tt class="docutils literal"><span class="pre">log2</span></tt>‘ function but without
+trapping or setting <tt class="docutils literal"><span class="pre">errno</span></tt>.</p>
+<p>When specified with the fast-math-flag ‘afn’, the result may be approximated
+using a less accurate calculation.</p>
+</div>
+</div>
+<div class="section" id="llvm-fma-intrinsic">
+<h4><a class="toc-backref" href="#id1513">‘<tt class="docutils literal"><span class="pre">llvm.fma.*</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-fma-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id465">
+<h5><a class="toc-backref" href="#id1514">Syntax:</a><a class="headerlink" href="#id465" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.fma</span></tt> on any
+floating-point or vector of floating-point type. Not all targets support
+all types however.</p>
+<div class="highlight-python"><pre>declare float     @llvm.fma.f32(float  %a, float  %b, float  %c)
+declare double    @llvm.fma.f64(double %a, double %b, double %c)
+declare x86_fp80  @llvm.fma.f80(x86_fp80 %a, x86_fp80 %b, x86_fp80 %c)
+declare fp128     @llvm.fma.f128(fp128 %a, fp128 %b, fp128 %c)
+declare ppc_fp128 @llvm.fma.ppcf128(ppc_fp128 %a, ppc_fp128 %b, ppc_fp128 %c)</pre>
+</div>
+</div>
+<div class="section" id="id466">
+<h5><a class="toc-backref" href="#id1515">Overview:</a><a class="headerlink" href="#id466" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.fma.*</span></tt>‘ intrinsics perform the fused multiply-add operation.</p>
+</div>
+<div class="section" id="id467">
+<h5><a class="toc-backref" href="#id1516">Arguments:</a><a class="headerlink" href="#id467" title="Permalink to this headline">¶</a></h5>
+<p>The arguments and return value are floating-point numbers of the same type.</p>
+</div>
+<div class="section" id="id468">
+<h5><a class="toc-backref" href="#id1517">Semantics:</a><a class="headerlink" href="#id468" title="Permalink to this headline">¶</a></h5>
+<p>Return the same value as a corresponding libm ‘<tt class="docutils literal"><span class="pre">fma</span></tt>‘ function but without
+trapping or setting <tt class="docutils literal"><span class="pre">errno</span></tt>.</p>
+<p>When specified with the fast-math-flag ‘afn’, the result may be approximated
+using a less accurate calculation.</p>
+</div>
+</div>
+<div class="section" id="llvm-fabs-intrinsic">
+<h4><a class="toc-backref" href="#id1518">‘<tt class="docutils literal"><span class="pre">llvm.fabs.*</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-fabs-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id469">
+<h5><a class="toc-backref" href="#id1519">Syntax:</a><a class="headerlink" href="#id469" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.fabs</span></tt> on any
+floating point or vector of floating point type. Not all targets support
+all types however.</p>
+<div class="highlight-python"><pre>declare float     @llvm.fabs.f32(float  %Val)
+declare double    @llvm.fabs.f64(double %Val)
+declare x86_fp80  @llvm.fabs.f80(x86_fp80 %Val)
+declare fp128     @llvm.fabs.f128(fp128 %Val)
+declare ppc_fp128 @llvm.fabs.ppcf128(ppc_fp128 %Val)</pre>
+</div>
+</div>
+<div class="section" id="id470">
+<h5><a class="toc-backref" href="#id1520">Overview:</a><a class="headerlink" href="#id470" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.fabs.*</span></tt>‘ intrinsics return the absolute value of the
+operand.</p>
+</div>
+<div class="section" id="id471">
+<h5><a class="toc-backref" href="#id1521">Arguments:</a><a class="headerlink" href="#id471" title="Permalink to this headline">¶</a></h5>
+<p>The argument and return value are floating point numbers of the same
+type.</p>
+</div>
+<div class="section" id="id472">
+<h5><a class="toc-backref" href="#id1522">Semantics:</a><a class="headerlink" href="#id472" title="Permalink to this headline">¶</a></h5>
+<p>This function returns the same values as the libm <tt class="docutils literal"><span class="pre">fabs</span></tt> functions
+would, and handles error conditions in the same way.</p>
+</div>
+</div>
+<div class="section" id="llvm-minnum-intrinsic">
+<h4><a class="toc-backref" href="#id1523">‘<tt class="docutils literal"><span class="pre">llvm.minnum.*</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-minnum-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id473">
+<h5><a class="toc-backref" href="#id1524">Syntax:</a><a class="headerlink" href="#id473" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.minnum</span></tt> on any
+floating point or vector of floating point type. Not all targets support
+all types however.</p>
+<div class="highlight-python"><pre>declare float     @llvm.minnum.f32(float %Val0, float %Val1)
+declare double    @llvm.minnum.f64(double %Val0, double %Val1)
+declare x86_fp80  @llvm.minnum.f80(x86_fp80 %Val0, x86_fp80 %Val1)
+declare fp128     @llvm.minnum.f128(fp128 %Val0, fp128 %Val1)
+declare ppc_fp128 @llvm.minnum.ppcf128(ppc_fp128 %Val0, ppc_fp128 %Val1)</pre>
+</div>
+</div>
+<div class="section" id="id474">
+<h5><a class="toc-backref" href="#id1525">Overview:</a><a class="headerlink" href="#id474" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.minnum.*</span></tt>‘ intrinsics return the minimum of the two
+arguments.</p>
+</div>
+<div class="section" id="id475">
+<h5><a class="toc-backref" href="#id1526">Arguments:</a><a class="headerlink" href="#id475" title="Permalink to this headline">¶</a></h5>
+<p>The arguments and return value are floating point numbers of the same
+type.</p>
+</div>
+<div class="section" id="id476">
+<h5><a class="toc-backref" href="#id1527">Semantics:</a><a class="headerlink" href="#id476" title="Permalink to this headline">¶</a></h5>
+<p>Follows the IEEE-754 semantics for minNum, which also match for libm’s
+fmin.</p>
+<p>If either operand is a NaN, returns the other non-NaN operand. Returns
+NaN only if both operands are NaN. If the operands compare equal,
+returns a value that compares equal to both operands. This means that
+fmin(+/-0.0, +/-0.0) could return either -0.0 or 0.0.</p>
+</div>
+</div>
+<div class="section" id="llvm-maxnum-intrinsic">
+<h4><a class="toc-backref" href="#id1528">‘<tt class="docutils literal"><span class="pre">llvm.maxnum.*</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-maxnum-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id477">
+<h5><a class="toc-backref" href="#id1529">Syntax:</a><a class="headerlink" href="#id477" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.maxnum</span></tt> on any
+floating point or vector of floating point type. Not all targets support
+all types however.</p>
+<div class="highlight-python"><pre>declare float     @llvm.maxnum.f32(float  %Val0, float  %Val1l)
+declare double    @llvm.maxnum.f64(double %Val0, double %Val1)
+declare x86_fp80  @llvm.maxnum.f80(x86_fp80  %Val0, x86_fp80  %Val1)
+declare fp128     @llvm.maxnum.f128(fp128 %Val0, fp128 %Val1)
+declare ppc_fp128 @llvm.maxnum.ppcf128(ppc_fp128  %Val0, ppc_fp128  %Val1)</pre>
+</div>
+</div>
+<div class="section" id="id478">
+<h5><a class="toc-backref" href="#id1530">Overview:</a><a class="headerlink" href="#id478" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.maxnum.*</span></tt>‘ intrinsics return the maximum of the two
+arguments.</p>
+</div>
+<div class="section" id="id479">
+<h5><a class="toc-backref" href="#id1531">Arguments:</a><a class="headerlink" href="#id479" title="Permalink to this headline">¶</a></h5>
+<p>The arguments and return value are floating point numbers of the same
+type.</p>
+</div>
+<div class="section" id="id480">
+<h5><a class="toc-backref" href="#id1532">Semantics:</a><a class="headerlink" href="#id480" title="Permalink to this headline">¶</a></h5>
+<p>Follows the IEEE-754 semantics for maxNum, which also match for libm’s
+fmax.</p>
+<p>If either operand is a NaN, returns the other non-NaN operand. Returns
+NaN only if both operands are NaN. If the operands compare equal,
+returns a value that compares equal to both operands. This means that
+fmax(+/-0.0, +/-0.0) could return either -0.0 or 0.0.</p>
+</div>
+</div>
+<div class="section" id="llvm-copysign-intrinsic">
+<h4><a class="toc-backref" href="#id1533">‘<tt class="docutils literal"><span class="pre">llvm.copysign.*</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-copysign-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id481">
+<h5><a class="toc-backref" href="#id1534">Syntax:</a><a class="headerlink" href="#id481" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.copysign</span></tt> on any
+floating point or vector of floating point type. Not all targets support
+all types however.</p>
+<div class="highlight-python"><pre>declare float     @llvm.copysign.f32(float  %Mag, float  %Sgn)
+declare double    @llvm.copysign.f64(double %Mag, double %Sgn)
+declare x86_fp80  @llvm.copysign.f80(x86_fp80  %Mag, x86_fp80  %Sgn)
+declare fp128     @llvm.copysign.f128(fp128 %Mag, fp128 %Sgn)
+declare ppc_fp128 @llvm.copysign.ppcf128(ppc_fp128  %Mag, ppc_fp128  %Sgn)</pre>
+</div>
+</div>
+<div class="section" id="id482">
+<h5><a class="toc-backref" href="#id1535">Overview:</a><a class="headerlink" href="#id482" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.copysign.*</span></tt>‘ intrinsics return a value with the magnitude of the
+first operand and the sign of the second operand.</p>
+</div>
+<div class="section" id="id483">
+<h5><a class="toc-backref" href="#id1536">Arguments:</a><a class="headerlink" href="#id483" title="Permalink to this headline">¶</a></h5>
+<p>The arguments and return value are floating point numbers of the same
+type.</p>
+</div>
+<div class="section" id="id484">
+<h5><a class="toc-backref" href="#id1537">Semantics:</a><a class="headerlink" href="#id484" title="Permalink to this headline">¶</a></h5>
+<p>This function returns the same values as the libm <tt class="docutils literal"><span class="pre">copysign</span></tt>
+functions would, and handles error conditions in the same way.</p>
+</div>
+</div>
+<div class="section" id="llvm-floor-intrinsic">
+<h4><a class="toc-backref" href="#id1538">‘<tt class="docutils literal"><span class="pre">llvm.floor.*</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-floor-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id485">
+<h5><a class="toc-backref" href="#id1539">Syntax:</a><a class="headerlink" href="#id485" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.floor</span></tt> on any
+floating point or vector of floating point type. Not all targets support
+all types however.</p>
+<div class="highlight-python"><pre>declare float     @llvm.floor.f32(float  %Val)
+declare double    @llvm.floor.f64(double %Val)
+declare x86_fp80  @llvm.floor.f80(x86_fp80  %Val)
+declare fp128     @llvm.floor.f128(fp128 %Val)
+declare ppc_fp128 @llvm.floor.ppcf128(ppc_fp128  %Val)</pre>
+</div>
+</div>
+<div class="section" id="id486">
+<h5><a class="toc-backref" href="#id1540">Overview:</a><a class="headerlink" href="#id486" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.floor.*</span></tt>‘ intrinsics return the floor of the operand.</p>
+</div>
+<div class="section" id="id487">
+<h5><a class="toc-backref" href="#id1541">Arguments:</a><a class="headerlink" href="#id487" title="Permalink to this headline">¶</a></h5>
+<p>The argument and return value are floating point numbers of the same
+type.</p>
+</div>
+<div class="section" id="id488">
+<h5><a class="toc-backref" href="#id1542">Semantics:</a><a class="headerlink" href="#id488" title="Permalink to this headline">¶</a></h5>
+<p>This function returns the same values as the libm <tt class="docutils literal"><span class="pre">floor</span></tt> functions
+would, and handles error conditions in the same way.</p>
+</div>
+</div>
+<div class="section" id="llvm-ceil-intrinsic">
+<h4><a class="toc-backref" href="#id1543">‘<tt class="docutils literal"><span class="pre">llvm.ceil.*</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-ceil-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id489">
+<h5><a class="toc-backref" href="#id1544">Syntax:</a><a class="headerlink" href="#id489" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.ceil</span></tt> on any
+floating point or vector of floating point type. Not all targets support
+all types however.</p>
+<div class="highlight-python"><pre>declare float     @llvm.ceil.f32(float  %Val)
+declare double    @llvm.ceil.f64(double %Val)
+declare x86_fp80  @llvm.ceil.f80(x86_fp80  %Val)
+declare fp128     @llvm.ceil.f128(fp128 %Val)
+declare ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128  %Val)</pre>
+</div>
+</div>
+<div class="section" id="id490">
+<h5><a class="toc-backref" href="#id1545">Overview:</a><a class="headerlink" href="#id490" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.ceil.*</span></tt>‘ intrinsics return the ceiling of the operand.</p>
+</div>
+<div class="section" id="id491">
+<h5><a class="toc-backref" href="#id1546">Arguments:</a><a class="headerlink" href="#id491" title="Permalink to this headline">¶</a></h5>
+<p>The argument and return value are floating point numbers of the same
+type.</p>
+</div>
+<div class="section" id="id492">
+<h5><a class="toc-backref" href="#id1547">Semantics:</a><a class="headerlink" href="#id492" title="Permalink to this headline">¶</a></h5>
+<p>This function returns the same values as the libm <tt class="docutils literal"><span class="pre">ceil</span></tt> functions
+would, and handles error conditions in the same way.</p>
+</div>
+</div>
+<div class="section" id="llvm-trunc-intrinsic">
+<h4><a class="toc-backref" href="#id1548">‘<tt class="docutils literal"><span class="pre">llvm.trunc.*</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-trunc-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id493">
+<h5><a class="toc-backref" href="#id1549">Syntax:</a><a class="headerlink" href="#id493" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.trunc</span></tt> on any
+floating point or vector of floating point type. Not all targets support
+all types however.</p>
+<div class="highlight-python"><pre>declare float     @llvm.trunc.f32(float  %Val)
+declare double    @llvm.trunc.f64(double %Val)
+declare x86_fp80  @llvm.trunc.f80(x86_fp80  %Val)
+declare fp128     @llvm.trunc.f128(fp128 %Val)
+declare ppc_fp128 @llvm.trunc.ppcf128(ppc_fp128  %Val)</pre>
+</div>
+</div>
+<div class="section" id="id494">
+<h5><a class="toc-backref" href="#id1550">Overview:</a><a class="headerlink" href="#id494" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.trunc.*</span></tt>‘ intrinsics returns the operand rounded to the
+nearest integer not larger in magnitude than the operand.</p>
+</div>
+<div class="section" id="id495">
+<h5><a class="toc-backref" href="#id1551">Arguments:</a><a class="headerlink" href="#id495" title="Permalink to this headline">¶</a></h5>
+<p>The argument and return value are floating point numbers of the same
+type.</p>
+</div>
+<div class="section" id="id496">
+<h5><a class="toc-backref" href="#id1552">Semantics:</a><a class="headerlink" href="#id496" title="Permalink to this headline">¶</a></h5>
+<p>This function returns the same values as the libm <tt class="docutils literal"><span class="pre">trunc</span></tt> functions
+would, and handles error conditions in the same way.</p>
+</div>
+</div>
+<div class="section" id="llvm-rint-intrinsic">
+<h4><a class="toc-backref" href="#id1553">‘<tt class="docutils literal"><span class="pre">llvm.rint.*</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-rint-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id497">
+<h5><a class="toc-backref" href="#id1554">Syntax:</a><a class="headerlink" href="#id497" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.rint</span></tt> on any
+floating point or vector of floating point type. Not all targets support
+all types however.</p>
+<div class="highlight-python"><pre>declare float     @llvm.rint.f32(float  %Val)
+declare double    @llvm.rint.f64(double %Val)
+declare x86_fp80  @llvm.rint.f80(x86_fp80  %Val)
+declare fp128     @llvm.rint.f128(fp128 %Val)
+declare ppc_fp128 @llvm.rint.ppcf128(ppc_fp128  %Val)</pre>
+</div>
+</div>
+<div class="section" id="id498">
+<h5><a class="toc-backref" href="#id1555">Overview:</a><a class="headerlink" href="#id498" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.rint.*</span></tt>‘ intrinsics returns the operand rounded to the
+nearest integer. It may raise an inexact floating-point exception if the
+operand isn’t an integer.</p>
+</div>
+<div class="section" id="id499">
+<h5><a class="toc-backref" href="#id1556">Arguments:</a><a class="headerlink" href="#id499" title="Permalink to this headline">¶</a></h5>
+<p>The argument and return value are floating point numbers of the same
+type.</p>
+</div>
+<div class="section" id="id500">
+<h5><a class="toc-backref" href="#id1557">Semantics:</a><a class="headerlink" href="#id500" title="Permalink to this headline">¶</a></h5>
+<p>This function returns the same values as the libm <tt class="docutils literal"><span class="pre">rint</span></tt> functions
+would, and handles error conditions in the same way.</p>
+</div>
+</div>
+<div class="section" id="llvm-nearbyint-intrinsic">
+<h4><a class="toc-backref" href="#id1558">‘<tt class="docutils literal"><span class="pre">llvm.nearbyint.*</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-nearbyint-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id501">
+<h5><a class="toc-backref" href="#id1559">Syntax:</a><a class="headerlink" href="#id501" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.nearbyint</span></tt> on any
+floating point or vector of floating point type. Not all targets support
+all types however.</p>
+<div class="highlight-python"><pre>declare float     @llvm.nearbyint.f32(float  %Val)
+declare double    @llvm.nearbyint.f64(double %Val)
+declare x86_fp80  @llvm.nearbyint.f80(x86_fp80  %Val)
+declare fp128     @llvm.nearbyint.f128(fp128 %Val)
+declare ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128  %Val)</pre>
+</div>
+</div>
+<div class="section" id="id502">
+<h5><a class="toc-backref" href="#id1560">Overview:</a><a class="headerlink" href="#id502" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.nearbyint.*</span></tt>‘ intrinsics returns the operand rounded to the
+nearest integer.</p>
+</div>
+<div class="section" id="id503">
+<h5><a class="toc-backref" href="#id1561">Arguments:</a><a class="headerlink" href="#id503" title="Permalink to this headline">¶</a></h5>
+<p>The argument and return value are floating point numbers of the same
+type.</p>
+</div>
+<div class="section" id="id504">
+<h5><a class="toc-backref" href="#id1562">Semantics:</a><a class="headerlink" href="#id504" title="Permalink to this headline">¶</a></h5>
+<p>This function returns the same values as the libm <tt class="docutils literal"><span class="pre">nearbyint</span></tt>
+functions would, and handles error conditions in the same way.</p>
+</div>
+</div>
+<div class="section" id="llvm-round-intrinsic">
+<h4><a class="toc-backref" href="#id1563">‘<tt class="docutils literal"><span class="pre">llvm.round.*</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-round-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id505">
+<h5><a class="toc-backref" href="#id1564">Syntax:</a><a class="headerlink" href="#id505" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.round</span></tt> on any
+floating point or vector of floating point type. Not all targets support
+all types however.</p>
+<div class="highlight-python"><pre>declare float     @llvm.round.f32(float  %Val)
+declare double    @llvm.round.f64(double %Val)
+declare x86_fp80  @llvm.round.f80(x86_fp80  %Val)
+declare fp128     @llvm.round.f128(fp128 %Val)
+declare ppc_fp128 @llvm.round.ppcf128(ppc_fp128  %Val)</pre>
+</div>
+</div>
+<div class="section" id="id506">
+<h5><a class="toc-backref" href="#id1565">Overview:</a><a class="headerlink" href="#id506" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.round.*</span></tt>‘ intrinsics returns the operand rounded to the
+nearest integer.</p>
+</div>
+<div class="section" id="id507">
+<h5><a class="toc-backref" href="#id1566">Arguments:</a><a class="headerlink" href="#id507" title="Permalink to this headline">¶</a></h5>
+<p>The argument and return value are floating point numbers of the same
+type.</p>
+</div>
+<div class="section" id="id508">
+<h5><a class="toc-backref" href="#id1567">Semantics:</a><a class="headerlink" href="#id508" title="Permalink to this headline">¶</a></h5>
+<p>This function returns the same values as the libm <tt class="docutils literal"><span class="pre">round</span></tt>
+functions would, and handles error conditions in the same way.</p>
+</div>
+</div>
+</div>
+<div class="section" id="bit-manipulation-intrinsics">
+<h3><a class="toc-backref" href="#id1568">Bit Manipulation Intrinsics</a><a class="headerlink" href="#bit-manipulation-intrinsics" title="Permalink to this headline">¶</a></h3>
+<p>LLVM provides intrinsics for a few important bit manipulation
+operations. These allow efficient code generation for some algorithms.</p>
+<div class="section" id="llvm-bitreverse-intrinsics">
+<h4><a class="toc-backref" href="#id1569">‘<tt class="docutils literal"><span class="pre">llvm.bitreverse.*</span></tt>‘ Intrinsics</a><a class="headerlink" href="#llvm-bitreverse-intrinsics" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id509">
+<h5><a class="toc-backref" href="#id1570">Syntax:</a><a class="headerlink" href="#id509" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic function. You can use bitreverse on any
+integer type.</p>
+<div class="highlight-python"><pre>declare i16 @llvm.bitreverse.i16(i16 <id>)
+declare i32 @llvm.bitreverse.i32(i32 <id>)
+declare i64 @llvm.bitreverse.i64(i64 <id>)</pre>
+</div>
+</div>
+<div class="section" id="id510">
+<h5><a class="toc-backref" href="#id1571">Overview:</a><a class="headerlink" href="#id510" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.bitreverse</span></tt>‘ family of intrinsics is used to reverse the
+bitpattern of an integer value; for example <tt class="docutils literal"><span class="pre">0b10110110</span></tt> becomes
+<tt class="docutils literal"><span class="pre">0b01101101</span></tt>.</p>
+</div>
+<div class="section" id="id511">
+<h5><a class="toc-backref" href="#id1572">Semantics:</a><a class="headerlink" href="#id511" title="Permalink to this headline">¶</a></h5>
+<p>The <tt class="docutils literal"><span class="pre">llvm.bitreverse.iN</span></tt> intrinsic returns an iN value that has bit
+<tt class="docutils literal"><span class="pre">M</span></tt> in the input moved to bit <tt class="docutils literal"><span class="pre">N-M</span></tt> in the output.</p>
+</div>
+</div>
+<div class="section" id="llvm-bswap-intrinsics">
+<h4><a class="toc-backref" href="#id1573">‘<tt class="docutils literal"><span class="pre">llvm.bswap.*</span></tt>‘ Intrinsics</a><a class="headerlink" href="#llvm-bswap-intrinsics" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id512">
+<h5><a class="toc-backref" href="#id1574">Syntax:</a><a class="headerlink" href="#id512" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic function. You can use bswap on any
+integer type that is an even number of bytes (i.e. BitWidth % 16 == 0).</p>
+<div class="highlight-python"><pre>declare i16 @llvm.bswap.i16(i16 <id>)
+declare i32 @llvm.bswap.i32(i32 <id>)
+declare i64 @llvm.bswap.i64(i64 <id>)</pre>
+</div>
+</div>
+<div class="section" id="id513">
+<h5><a class="toc-backref" href="#id1575">Overview:</a><a class="headerlink" href="#id513" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.bswap</span></tt>‘ family of intrinsics is used to byte swap integer
+values with an even number of bytes (positive multiple of 16 bits).
+These are useful for performing operations on data that is not in the
+target’s native byte order.</p>
+</div>
+<div class="section" id="id514">
+<h5><a class="toc-backref" href="#id1576">Semantics:</a><a class="headerlink" href="#id514" title="Permalink to this headline">¶</a></h5>
+<p>The <tt class="docutils literal"><span class="pre">llvm.bswap.i16</span></tt> intrinsic returns an i16 value that has the high
+and low byte of the input i16 swapped. Similarly, the <tt class="docutils literal"><span class="pre">llvm.bswap.i32</span></tt>
+intrinsic returns an i32 value that has the four bytes of the input i32
+swapped, so that if the input bytes are numbered 0, 1, 2, 3 then the
+returned i32 will have its bytes in 3, 2, 1, 0 order. The
+<tt class="docutils literal"><span class="pre">llvm.bswap.i48</span></tt>, <tt class="docutils literal"><span class="pre">llvm.bswap.i64</span></tt> and other intrinsics extend this
+concept to additional even-byte lengths (6 bytes, 8 bytes and more,
+respectively).</p>
+</div>
+</div>
+<div class="section" id="llvm-ctpop-intrinsic">
+<h4><a class="toc-backref" href="#id1577">‘<tt class="docutils literal"><span class="pre">llvm.ctpop.*</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-ctpop-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id515">
+<h5><a class="toc-backref" href="#id1578">Syntax:</a><a class="headerlink" href="#id515" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use llvm.ctpop on any integer
+bit width, or on any vector with integer elements. Not all targets
+support all bit widths or vector types, however.</p>
+<div class="highlight-python"><pre>declare i8 @llvm.ctpop.i8(i8  <src>)
+declare i16 @llvm.ctpop.i16(i16 <src>)
+declare i32 @llvm.ctpop.i32(i32 <src>)
+declare i64 @llvm.ctpop.i64(i64 <src>)
+declare i256 @llvm.ctpop.i256(i256 <src>)
+declare <2 x i32> @llvm.ctpop.v2i32(<2 x i32> <src>)</pre>
+</div>
+</div>
+<div class="section" id="id516">
+<h5><a class="toc-backref" href="#id1579">Overview:</a><a class="headerlink" href="#id516" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.ctpop</span></tt>‘ family of intrinsics counts the number of bits set
+in a value.</p>
+</div>
+<div class="section" id="id517">
+<h5><a class="toc-backref" href="#id1580">Arguments:</a><a class="headerlink" href="#id517" title="Permalink to this headline">¶</a></h5>
+<p>The only argument is the value to be counted. The argument may be of any
+integer type, or a vector with integer elements. The return type must
+match the argument type.</p>
+</div>
+<div class="section" id="id518">
+<h5><a class="toc-backref" href="#id1581">Semantics:</a><a class="headerlink" href="#id518" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.ctpop</span></tt>‘ intrinsic counts the 1’s in a variable, or within
+each element of a vector.</p>
+</div>
+</div>
+<div class="section" id="llvm-ctlz-intrinsic">
+<h4><a class="toc-backref" href="#id1582">‘<tt class="docutils literal"><span class="pre">llvm.ctlz.*</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-ctlz-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id519">
+<h5><a class="toc-backref" href="#id1583">Syntax:</a><a class="headerlink" href="#id519" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.ctlz</span></tt> on any
+integer bit width, or any vector whose elements are integers. Not all
+targets support all bit widths or vector types, however.</p>
+<div class="highlight-python"><pre>declare i8   @llvm.ctlz.i8  (i8   <src>, i1 <is_zero_undef>)
+declare i16  @llvm.ctlz.i16 (i16  <src>, i1 <is_zero_undef>)
+declare i32  @llvm.ctlz.i32 (i32  <src>, i1 <is_zero_undef>)
+declare i64  @llvm.ctlz.i64 (i64  <src>, i1 <is_zero_undef>)
+declare i256 @llvm.ctlz.i256(i256 <src>, i1 <is_zero_undef>)
+declare <2 x i32> @llvm.ctlz.v2i32(<2 x i32> <src>, i1 <is_zero_undef>)</pre>
+</div>
+</div>
+<div class="section" id="id520">
+<h5><a class="toc-backref" href="#id1584">Overview:</a><a class="headerlink" href="#id520" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.ctlz</span></tt>‘ family of intrinsic functions counts the number of
+leading zeros in a variable.</p>
+</div>
+<div class="section" id="id521">
+<h5><a class="toc-backref" href="#id1585">Arguments:</a><a class="headerlink" href="#id521" title="Permalink to this headline">¶</a></h5>
+<p>The first argument is the value to be counted. This argument may be of
+any integer type, or a vector with integer element type. The return
+type must match the first argument type.</p>
+<p>The second argument must be a constant and is a flag to indicate whether
+the intrinsic should ensure that a zero as the first argument produces a
+defined result. Historically some architectures did not provide a
+defined result for zero values as efficiently, and many algorithms are
+now predicated on avoiding zero-value inputs.</p>
+</div>
+<div class="section" id="id522">
+<h5><a class="toc-backref" href="#id1586">Semantics:</a><a class="headerlink" href="#id522" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.ctlz</span></tt>‘ intrinsic counts the leading (most significant)
+zeros in a variable, or within each element of the vector. If
+<tt class="docutils literal"><span class="pre">src</span> <span class="pre">==</span> <span class="pre">0</span></tt> then the result is the size in bits of the type of <tt class="docutils literal"><span class="pre">src</span></tt>
+if <tt class="docutils literal"><span class="pre">is_zero_undef</span> <span class="pre">==</span> <span class="pre">0</span></tt> and <tt class="docutils literal"><span class="pre">undef</span></tt> otherwise. For example,
+<tt class="docutils literal"><span class="pre">llvm.ctlz(i32</span> <span class="pre">2)</span> <span class="pre">=</span> <span class="pre">30</span></tt>.</p>
+</div>
+</div>
+<div class="section" id="llvm-cttz-intrinsic">
+<h4><a class="toc-backref" href="#id1587">‘<tt class="docutils literal"><span class="pre">llvm.cttz.*</span></tt>‘ Intrinsic</a><a class="headerlink" href="#llvm-cttz-intrinsic" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id523">
+<h5><a class="toc-backref" href="#id1588">Syntax:</a><a class="headerlink" href="#id523" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.cttz</span></tt> on any
+integer bit width, or any vector of integer elements. Not all targets
+support all bit widths or vector types, however.</p>
+<div class="highlight-python"><pre>declare i8   @llvm.cttz.i8  (i8   <src>, i1 <is_zero_undef>)
+declare i16  @llvm.cttz.i16 (i16  <src>, i1 <is_zero_undef>)
+declare i32  @llvm.cttz.i32 (i32  <src>, i1 <is_zero_undef>)
+declare i64  @llvm.cttz.i64 (i64  <src>, i1 <is_zero_undef>)
+declare i256 @llvm.cttz.i256(i256 <src>, i1 <is_zero_undef>)
+declare <2 x i32> @llvm.cttz.v2i32(<2 x i32> <src>, i1 <is_zero_undef>)</pre>
+</div>
+</div>
+<div class="section" id="id524">
+<h5><a class="toc-backref" href="#id1589">Overview:</a><a class="headerlink" href="#id524" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.cttz</span></tt>‘ family of intrinsic functions counts the number of
+trailing zeros.</p>
+</div>
+<div class="section" id="id525">
+<h5><a class="toc-backref" href="#id1590">Arguments:</a><a class="headerlink" href="#id525" title="Permalink to this headline">¶</a></h5>
+<p>The first argument is the value to be counted. This argument may be of
+any integer type, or a vector with integer element type. The return
+type must match the first argument type.</p>
+<p>The second argument must be a constant and is a flag to indicate whether
+the intrinsic should ensure that a zero as the first argument produces a
+defined result. Historically some architectures did not provide a
+defined result for zero values as efficiently, and many algorithms are
+now predicated on avoiding zero-value inputs.</p>
+</div>
+<div class="section" id="id526">
+<h5><a class="toc-backref" href="#id1591">Semantics:</a><a class="headerlink" href="#id526" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.cttz</span></tt>‘ intrinsic counts the trailing (least significant)
+zeros in a variable, or within each element of a vector. If <tt class="docutils literal"><span class="pre">src</span> <span class="pre">==</span> <span class="pre">0</span></tt>
+then the result is the size in bits of the type of <tt class="docutils literal"><span class="pre">src</span></tt> if
+<tt class="docutils literal"><span class="pre">is_zero_undef</span> <span class="pre">==</span> <span class="pre">0</span></tt> and <tt class="docutils literal"><span class="pre">undef</span></tt> otherwise. For example,
+<tt class="docutils literal"><span class="pre">llvm.cttz(2)</span> <span class="pre">=</span> <span class="pre">1</span></tt>.</p>
+</div>
+</div>
+</div>
+<div class="section" id="arithmetic-with-overflow-intrinsics">
+<span id="int-overflow"></span><h3><a class="toc-backref" href="#id1592">Arithmetic with Overflow Intrinsics</a><a class="headerlink" href="#arithmetic-with-overflow-intrinsics" title="Permalink to this headline">¶</a></h3>
+<p>LLVM provides intrinsics for fast arithmetic overflow checking.</p>
+<p>Each of these intrinsics returns a two-element struct. The first
+element of this struct contains the result of the corresponding
+arithmetic operation modulo 2<sup>n</sup>, where n is the bit width of
+the result. Therefore, for example, the first element of the struct
+returned by <tt class="docutils literal"><span class="pre">llvm.sadd.with.overflow.i32</span></tt> is always the same as the
+result of a 32-bit <tt class="docutils literal"><span class="pre">add</span></tt> instruction with the same operands, where
+the <tt class="docutils literal"><span class="pre">add</span></tt> is <em>not</em> modified by an <tt class="docutils literal"><span class="pre">nsw</span></tt> or <tt class="docutils literal"><span class="pre">nuw</span></tt> flag.</p>
+<p>The second element of the result is an <tt class="docutils literal"><span class="pre">i1</span></tt> that is 1 if the
+arithmetic operation overflowed and 0 otherwise. An operation
+overflows if, for any values of its operands <tt class="docutils literal"><span class="pre">A</span></tt> and <tt class="docutils literal"><span class="pre">B</span></tt> and for
+any <tt class="docutils literal"><span class="pre">N</span></tt> larger than the operands’ width, <tt class="docutils literal"><span class="pre">ext(A</span> <span class="pre">op</span> <span class="pre">B)</span> <span class="pre">to</span> <span class="pre">iN</span></tt> is
+not equal to <tt class="docutils literal"><span class="pre">(ext(A)</span> <span class="pre">to</span> <span class="pre">iN)</span> <span class="pre">op</span> <span class="pre">(ext(B)</span> <span class="pre">to</span> <span class="pre">iN)</span></tt> where <tt class="docutils literal"><span class="pre">ext</span></tt> is
+<tt class="docutils literal"><span class="pre">sext</span></tt> for signed overflow and <tt class="docutils literal"><span class="pre">zext</span></tt> for unsigned overflow, and
+<tt class="docutils literal"><span class="pre">op</span></tt> is the underlying arithmetic operation.</p>
+<p>The behavior of these intrinsics is well-defined for all argument
+values.</p>
+<div class="section" id="llvm-sadd-with-overflow-intrinsics">
+<h4><a class="toc-backref" href="#id1593">‘<tt class="docutils literal"><span class="pre">llvm.sadd.with.overflow.*</span></tt>‘ Intrinsics</a><a class="headerlink" href="#llvm-sadd-with-overflow-intrinsics" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id527">
+<h5><a class="toc-backref" href="#id1594">Syntax:</a><a class="headerlink" href="#id527" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.sadd.with.overflow</span></tt>
+on any integer bit width.</p>
+<div class="highlight-python"><pre>declare {i16, i1} @llvm.sadd.with.overflow.i16(i16 %a, i16 %b)
+declare {i32, i1} @llvm.sadd.with.overflow.i32(i32 %a, i32 %b)
+declare {i64, i1} @llvm.sadd.with.overflow.i64(i64 %a, i64 %b)</pre>
+</div>
+</div>
+<div class="section" id="id528">
+<h5><a class="toc-backref" href="#id1595">Overview:</a><a class="headerlink" href="#id528" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.sadd.with.overflow</span></tt>‘ family of intrinsic functions perform
+a signed addition of the two arguments, and indicate whether an overflow
+occurred during the signed summation.</p>
+</div>
+<div class="section" id="id529">
+<h5><a class="toc-backref" href="#id1596">Arguments:</a><a class="headerlink" href="#id529" title="Permalink to this headline">¶</a></h5>
+<p>The arguments (%a and %b) and the first element of the result structure
+may be of integer types of any bit width, but they must have the same
+bit width. The second element of the result structure must be of type
+<tt class="docutils literal"><span class="pre">i1</span></tt>. <tt class="docutils literal"><span class="pre">%a</span></tt> and <tt class="docutils literal"><span class="pre">%b</span></tt> are the two values that will undergo signed
+addition.</p>
+</div>
+<div class="section" id="id530">
+<h5><a class="toc-backref" href="#id1597">Semantics:</a><a class="headerlink" href="#id530" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.sadd.with.overflow</span></tt>‘ family of intrinsic functions perform
+a signed addition of the two variables. They return a structure — the
+first element of which is the signed summation, and the second element
+of which is a bit specifying if the signed summation resulted in an
+overflow.</p>
+</div>
+<div class="section" id="id531">
+<h5><a class="toc-backref" href="#id1598">Examples:</a><a class="headerlink" href="#id531" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%res</span> <span class="p">=</span> <span class="k">call</span> <span class="p">{</span><span class="k">i32</span><span class="p">,</span> <span class="k">i1</span><span class="p">}</span> <span class="vg">@llvm.sadd.with.overflow.i32</span><span class="p">(</span><span class="k">i32</span> <span class="nv">%a</span><span class="p">,</span> <span class="k">i32</span> <span class="nv">%b</span><span class="p">)</span>
+<span class="nv">%sum</span> <span class="p">=</span> <span class="k">extractvalue</span> <span class="p">{</span><span class="k">i32</span><span class="p">,</span> <span class="k">i1</span><span class="p">}</span> <span class="nv">%res</span><span class="p">,</span> <span class="m">0</span>
+<span class="nv">%obit</span> <span class="p">=</span> <span class="k">extractvalue</span> <span class="p">{</span><span class="k">i32</span><span class="p">,</span> <span class="k">i1</span><span class="p">}</span> <span class="nv">%res</span><span class="p">,</span> <span class="m">1</span>
+<span class="k">br</span> <span class="k">i1</span> <span class="nv">%obit</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%overflow</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%normal</span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="llvm-uadd-with-overflow-intrinsics">
+<h4><a class="toc-backref" href="#id1599">‘<tt class="docutils literal"><span class="pre">llvm.uadd.with.overflow.*</span></tt>‘ Intrinsics</a><a class="headerlink" href="#llvm-uadd-with-overflow-intrinsics" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id532">
+<h5><a class="toc-backref" href="#id1600">Syntax:</a><a class="headerlink" href="#id532" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.uadd.with.overflow</span></tt>
+on any integer bit width.</p>
+<div class="highlight-python"><pre>declare {i16, i1} @llvm.uadd.with.overflow.i16(i16 %a, i16 %b)
+declare {i32, i1} @llvm.uadd.with.overflow.i32(i32 %a, i32 %b)
+declare {i64, i1} @llvm.uadd.with.overflow.i64(i64 %a, i64 %b)</pre>
+</div>
+</div>
+<div class="section" id="id533">
+<h5><a class="toc-backref" href="#id1601">Overview:</a><a class="headerlink" href="#id533" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.uadd.with.overflow</span></tt>‘ family of intrinsic functions perform
+an unsigned addition of the two arguments, and indicate whether a carry
+occurred during the unsigned summation.</p>
+</div>
+<div class="section" id="id534">
+<h5><a class="toc-backref" href="#id1602">Arguments:</a><a class="headerlink" href="#id534" title="Permalink to this headline">¶</a></h5>
+<p>The arguments (%a and %b) and the first element of the result structure
+may be of integer types of any bit width, but they must have the same
+bit width. The second element of the result structure must be of type
+<tt class="docutils literal"><span class="pre">i1</span></tt>. <tt class="docutils literal"><span class="pre">%a</span></tt> and <tt class="docutils literal"><span class="pre">%b</span></tt> are the two values that will undergo unsigned
+addition.</p>
+</div>
+<div class="section" id="id535">
+<h5><a class="toc-backref" href="#id1603">Semantics:</a><a class="headerlink" href="#id535" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.uadd.with.overflow</span></tt>‘ family of intrinsic functions perform
+an unsigned addition of the two arguments. They return a structure — the
+first element of which is the sum, and the second element of which is a
+bit specifying if the unsigned summation resulted in a carry.</p>
+</div>
+<div class="section" id="id536">
+<h5><a class="toc-backref" href="#id1604">Examples:</a><a class="headerlink" href="#id536" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%res</span> <span class="p">=</span> <span class="k">call</span> <span class="p">{</span><span class="k">i32</span><span class="p">,</span> <span class="k">i1</span><span class="p">}</span> <span class="vg">@llvm.uadd.with.overflow.i32</span><span class="p">(</span><span class="k">i32</span> <span class="nv">%a</span><span class="p">,</span> <span class="k">i32</span> <span class="nv">%b</span><span class="p">)</span>
+<span class="nv">%sum</span> <span class="p">=</span> <span class="k">extractvalue</span> <span class="p">{</span><span class="k">i32</span><span class="p">,</span> <span class="k">i1</span><span class="p">}</span> <span class="nv">%res</span><span class="p">,</span> <span class="m">0</span>
+<span class="nv">%obit</span> <span class="p">=</span> <span class="k">extractvalue</span> <span class="p">{</span><span class="k">i32</span><span class="p">,</span> <span class="k">i1</span><span class="p">}</span> <span class="nv">%res</span><span class="p">,</span> <span class="m">1</span>
+<span class="k">br</span> <span class="k">i1</span> <span class="nv">%obit</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%carry</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%normal</span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="llvm-ssub-with-overflow-intrinsics">
+<h4><a class="toc-backref" href="#id1605">‘<tt class="docutils literal"><span class="pre">llvm.ssub.with.overflow.*</span></tt>‘ Intrinsics</a><a class="headerlink" href="#llvm-ssub-with-overflow-intrinsics" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id537">
+<h5><a class="toc-backref" href="#id1606">Syntax:</a><a class="headerlink" href="#id537" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.ssub.with.overflow</span></tt>
+on any integer bit width.</p>
+<div class="highlight-python"><pre>declare {i16, i1} @llvm.ssub.with.overflow.i16(i16 %a, i16 %b)
+declare {i32, i1} @llvm.ssub.with.overflow.i32(i32 %a, i32 %b)
+declare {i64, i1} @llvm.ssub.with.overflow.i64(i64 %a, i64 %b)</pre>
+</div>
+</div>
+<div class="section" id="id538">
+<h5><a class="toc-backref" href="#id1607">Overview:</a><a class="headerlink" href="#id538" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.ssub.with.overflow</span></tt>‘ family of intrinsic functions perform
+a signed subtraction of the two arguments, and indicate whether an
+overflow occurred during the signed subtraction.</p>
+</div>
+<div class="section" id="id539">
+<h5><a class="toc-backref" href="#id1608">Arguments:</a><a class="headerlink" href="#id539" title="Permalink to this headline">¶</a></h5>
+<p>The arguments (%a and %b) and the first element of the result structure
+may be of integer types of any bit width, but they must have the same
+bit width. The second element of the result structure must be of type
+<tt class="docutils literal"><span class="pre">i1</span></tt>. <tt class="docutils literal"><span class="pre">%a</span></tt> and <tt class="docutils literal"><span class="pre">%b</span></tt> are the two values that will undergo signed
+subtraction.</p>
+</div>
+<div class="section" id="id540">
+<h5><a class="toc-backref" href="#id1609">Semantics:</a><a class="headerlink" href="#id540" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.ssub.with.overflow</span></tt>‘ family of intrinsic functions perform
+a signed subtraction of the two arguments. They return a structure — the
+first element of which is the subtraction, and the second element of
+which is a bit specifying if the signed subtraction resulted in an
+overflow.</p>
+</div>
+<div class="section" id="id541">
+<h5><a class="toc-backref" href="#id1610">Examples:</a><a class="headerlink" href="#id541" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%res</span> <span class="p">=</span> <span class="k">call</span> <span class="p">{</span><span class="k">i32</span><span class="p">,</span> <span class="k">i1</span><span class="p">}</span> <span class="vg">@llvm.ssub.with.overflow.i32</span><span class="p">(</span><span class="k">i32</span> <span class="nv">%a</span><span class="p">,</span> <span class="k">i32</span> <span class="nv">%b</span><span class="p">)</span>
+<span class="nv">%sum</span> <span class="p">=</span> <span class="k">extractvalue</span> <span class="p">{</span><span class="k">i32</span><span class="p">,</span> <span class="k">i1</span><span class="p">}</span> <span class="nv">%res</span><span class="p">,</span> <span class="m">0</span>
+<span class="nv">%obit</span> <span class="p">=</span> <span class="k">extractvalue</span> <span class="p">{</span><span class="k">i32</span><span class="p">,</span> <span class="k">i1</span><span class="p">}</span> <span class="nv">%res</span><span class="p">,</span> <span class="m">1</span>
+<span class="k">br</span> <span class="k">i1</span> <span class="nv">%obit</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%overflow</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%normal</span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="llvm-usub-with-overflow-intrinsics">
+<h4><a class="toc-backref" href="#id1611">‘<tt class="docutils literal"><span class="pre">llvm.usub.with.overflow.*</span></tt>‘ Intrinsics</a><a class="headerlink" href="#llvm-usub-with-overflow-intrinsics" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id542">
+<h5><a class="toc-backref" href="#id1612">Syntax:</a><a class="headerlink" href="#id542" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.usub.with.overflow</span></tt>
+on any integer bit width.</p>
+<div class="highlight-python"><pre>declare {i16, i1} @llvm.usub.with.overflow.i16(i16 %a, i16 %b)
+declare {i32, i1} @llvm.usub.with.overflow.i32(i32 %a, i32 %b)
+declare {i64, i1} @llvm.usub.with.overflow.i64(i64 %a, i64 %b)</pre>
+</div>
+</div>
+<div class="section" id="id543">
+<h5><a class="toc-backref" href="#id1613">Overview:</a><a class="headerlink" href="#id543" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.usub.with.overflow</span></tt>‘ family of intrinsic functions perform
+an unsigned subtraction of the two arguments, and indicate whether an
+overflow occurred during the unsigned subtraction.</p>
+</div>
+<div class="section" id="id544">
+<h5><a class="toc-backref" href="#id1614">Arguments:</a><a class="headerlink" href="#id544" title="Permalink to this headline">¶</a></h5>
+<p>The arguments (%a and %b) and the first element of the result structure
+may be of integer types of any bit width, but they must have the same
+bit width. The second element of the result structure must be of type
+<tt class="docutils literal"><span class="pre">i1</span></tt>. <tt class="docutils literal"><span class="pre">%a</span></tt> and <tt class="docutils literal"><span class="pre">%b</span></tt> are the two values that will undergo unsigned
+subtraction.</p>
+</div>
+<div class="section" id="id545">
+<h5><a class="toc-backref" href="#id1615">Semantics:</a><a class="headerlink" href="#id545" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.usub.with.overflow</span></tt>‘ family of intrinsic functions perform
+an unsigned subtraction of the two arguments. They return a structure —
+the first element of which is the subtraction, and the second element of
+which is a bit specifying if the unsigned subtraction resulted in an
+overflow.</p>
+</div>
+<div class="section" id="id546">
+<h5><a class="toc-backref" href="#id1616">Examples:</a><a class="headerlink" href="#id546" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%res</span> <span class="p">=</span> <span class="k">call</span> <span class="p">{</span><span class="k">i32</span><span class="p">,</span> <span class="k">i1</span><span class="p">}</span> <span class="vg">@llvm.usub.with.overflow.i32</span><span class="p">(</span><span class="k">i32</span> <span class="nv">%a</span><span class="p">,</span> <span class="k">i32</span> <span class="nv">%b</span><span class="p">)</span>
+<span class="nv">%sum</span> <span class="p">=</span> <span class="k">extractvalue</span> <span class="p">{</span><span class="k">i32</span><span class="p">,</span> <span class="k">i1</span><span class="p">}</span> <span class="nv">%res</span><span class="p">,</span> <span class="m">0</span>
+<span class="nv">%obit</span> <span class="p">=</span> <span class="k">extractvalue</span> <span class="p">{</span><span class="k">i32</span><span class="p">,</span> <span class="k">i1</span><span class="p">}</span> <span class="nv">%res</span><span class="p">,</span> <span class="m">1</span>
+<span class="k">br</span> <span class="k">i1</span> <span class="nv">%obit</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%overflow</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%normal</span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="llvm-smul-with-overflow-intrinsics">
+<h4><a class="toc-backref" href="#id1617">‘<tt class="docutils literal"><span class="pre">llvm.smul.with.overflow.*</span></tt>‘ Intrinsics</a><a class="headerlink" href="#llvm-smul-with-overflow-intrinsics" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id547">
+<h5><a class="toc-backref" href="#id1618">Syntax:</a><a class="headerlink" href="#id547" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.smul.with.overflow</span></tt>
+on any integer bit width.</p>
+<div class="highlight-python"><pre>declare {i16, i1} @llvm.smul.with.overflow.i16(i16 %a, i16 %b)
+declare {i32, i1} @llvm.smul.with.overflow.i32(i32 %a, i32 %b)
+declare {i64, i1} @llvm.smul.with.overflow.i64(i64 %a, i64 %b)</pre>
+</div>
+</div>
+<div class="section" id="id548">
+<h5><a class="toc-backref" href="#id1619">Overview:</a><a class="headerlink" href="#id548" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.smul.with.overflow</span></tt>‘ family of intrinsic functions perform
+a signed multiplication of the two arguments, and indicate whether an
+overflow occurred during the signed multiplication.</p>
+</div>
+<div class="section" id="id549">
+<h5><a class="toc-backref" href="#id1620">Arguments:</a><a class="headerlink" href="#id549" title="Permalink to this headline">¶</a></h5>
+<p>The arguments (%a and %b) and the first element of the result structure
+may be of integer types of any bit width, but they must have the same
+bit width. The second element of the result structure must be of type
+<tt class="docutils literal"><span class="pre">i1</span></tt>. <tt class="docutils literal"><span class="pre">%a</span></tt> and <tt class="docutils literal"><span class="pre">%b</span></tt> are the two values that will undergo signed
+multiplication.</p>
+</div>
+<div class="section" id="id550">
+<h5><a class="toc-backref" href="#id1621">Semantics:</a><a class="headerlink" href="#id550" title="Permalink to this headline">¶</a></h5>
+<p>The ‘<tt class="docutils literal"><span class="pre">llvm.smul.with.overflow</span></tt>‘ family of intrinsic functions perform
+a signed multiplication of the two arguments. They return a structure —
+the first element of which is the multiplication, and the second element
+of which is a bit specifying if the signed multiplication resulted in an
+overflow.</p>
+</div>
+<div class="section" id="id551">
+<h5><a class="toc-backref" href="#id1622">Examples:</a><a class="headerlink" href="#id551" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre><span class="nv">%res</span> <span class="p">=</span> <span class="k">call</span> <span class="p">{</span><span class="k">i32</span><span class="p">,</span> <span class="k">i1</span><span class="p">}</span> <span class="vg">@llvm.smul.with.overflow.i32</span><span class="p">(</span><span class="k">i32</span> <span class="nv">%a</span><span class="p">,</span> <span class="k">i32</span> <span class="nv">%b</span><span class="p">)</span>
+<span class="nv">%sum</span> <span class="p">=</span> <span class="k">extractvalue</span> <span class="p">{</span><span class="k">i32</span><span class="p">,</span> <span class="k">i1</span><span class="p">}</span> <span class="nv">%res</span><span class="p">,</span> <span class="m">0</span>
+<span class="nv">%obit</span> <span class="p">=</span> <span class="k">extractvalue</span> <span class="p">{</span><span class="k">i32</span><span class="p">,</span> <span class="k">i1</span><span class="p">}</span> <span class="nv">%res</span><span class="p">,</span> <span class="m">1</span>
+<span class="k">br</span> <span class="k">i1</span> <span class="nv">%obit</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%overflow</span><span class="p">,</span> <span class="kt">label</span> <span class="nv">%normal</span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="llvm-umul-with-overflow-intrinsics">
+<h4><a class="toc-backref" href="#id1623">‘<tt class="docutils literal"><span class="pre">llvm.umul.with.overflow.*</span></tt>‘ Intrinsics</a><a class="headerlink" href="#llvm-umul-with-overflow-intrinsics" title="Permalink to this headline">¶</a></h4>
+<div class="section" id="id552">
+<h5><a class="toc-backref" href="#id1624">Syntax:</a><a class="headerlink" href="#id552" title="Permalink to this headline">¶</a></h5>
+<p>This is an overloaded intrinsic. You can use <tt class="docutils literal"><span class="pre">llvm.umul.with.overflow</span></tt>
+on any integer bit width.</p>
+<div class="highlight-python"><pre>declare {i16, i1} @llvm.umul.with.overflow.i16(i16 %a, i16 %b)
+declare {i32, i1} @llvm.umul.with.overflow.i32(i32 %a, i32 %b)
+declare {i64, i1} @llvm.umul.with.overflow.i64(i64 %a, i64 %b)</pre>
+</div>
+</div>
+<div class="section" id="id553">
+<h5><a class="toc-backref" href="#id1625">Overview:</a><a class="headerlink" href="#id553" title="Permalink to this headline">¶</a></h5>

[... 2293 lines stripped ...]



More information about the llvm-commits mailing list