[www-releases] r280493 - Add 3.9.0 source, docs and binaries

Hans Wennborg via llvm-commits llvm-commits at lists.llvm.org
Fri Sep 2 08:56:56 PDT 2016


Added: www-releases/trunk/3.9.0/docs/LangRef.html
URL: http://llvm.org/viewvc/llvm-project/www-releases/trunk/3.9.0/docs/LangRef.html?rev=280493&view=auto
==============================================================================
--- www-releases/trunk/3.9.0/docs/LangRef.html (added)
+++ www-releases/trunk/3.9.0/docs/LangRef.html Fri Sep  2 10:56:46 2016
@@ -0,0 +1,12586 @@
+
+<!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 3.9 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:     '3.9',
+        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 3.9 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="id667">Abstract</a></li>
+<li><a class="reference internal" href="#introduction" id="id668">Introduction</a><ul>
+<li><a class="reference internal" href="#well-formedness" id="id669">Well-Formedness</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#identifiers" id="id670">Identifiers</a></li>
+<li><a class="reference internal" href="#high-level-structure" id="id671">High Level Structure</a><ul>
+<li><a class="reference internal" href="#module-structure" id="id672">Module Structure</a></li>
+<li><a class="reference internal" href="#linkage-types" id="id673">Linkage Types</a></li>
+<li><a class="reference internal" href="#calling-conventions" id="id674">Calling Conventions</a></li>
+<li><a class="reference internal" href="#visibility-styles" id="id675">Visibility Styles</a></li>
+<li><a class="reference internal" href="#dll-storage-classes" id="id676">DLL Storage Classes</a></li>
+<li><a class="reference internal" href="#thread-local-storage-models" id="id677">Thread Local Storage Models</a></li>
+<li><a class="reference internal" href="#structure-types" id="id678">Structure Types</a></li>
+<li><a class="reference internal" href="#global-variables" id="id679">Global Variables</a></li>
+<li><a class="reference internal" href="#functions" id="id680">Functions</a></li>
+<li><a class="reference internal" href="#aliases" id="id681">Aliases</a></li>
+<li><a class="reference internal" href="#ifuncs" id="id682">IFuncs</a></li>
+<li><a class="reference internal" href="#comdats" id="id683">Comdats</a></li>
+<li><a class="reference internal" href="#named-metadata" id="id684">Named Metadata</a></li>
+<li><a class="reference internal" href="#parameter-attributes" id="id685">Parameter Attributes</a></li>
+<li><a class="reference internal" href="#garbage-collector-strategy-names" id="id686">Garbage Collector Strategy Names</a></li>
+<li><a class="reference internal" href="#prefix-data" id="id687">Prefix Data</a></li>
+<li><a class="reference internal" href="#prologue-data" id="id688">Prologue Data</a></li>
+<li><a class="reference internal" href="#personality-function" id="id689">Personality Function</a></li>
+<li><a class="reference internal" href="#attribute-groups" id="id690">Attribute Groups</a></li>
+<li><a class="reference internal" href="#function-attributes" id="id691">Function Attributes</a></li>
+<li><a class="reference internal" href="#operand-bundles" id="id692">Operand Bundles</a><ul>
+<li><a class="reference internal" href="#deoptimization-operand-bundles" id="id693">Deoptimization Operand Bundles</a></li>
+<li><a class="reference internal" href="#funclet-operand-bundles" id="id694">Funclet Operand Bundles</a></li>
+<li><a class="reference internal" href="#gc-transition-operand-bundles" id="id695">GC Transition Operand Bundles</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#module-level-inline-assembly" id="id696">Module-Level Inline Assembly</a></li>
+<li><a class="reference internal" href="#data-layout" id="id697">Data Layout</a></li>
+<li><a class="reference internal" href="#target-triple" id="id698">Target Triple</a></li>
+<li><a class="reference internal" href="#pointer-aliasing-rules" id="id699">Pointer Aliasing Rules</a></li>
+<li><a class="reference internal" href="#volatile-memory-accesses" id="id700">Volatile Memory Accesses</a></li>
+<li><a class="reference internal" href="#memory-model-for-concurrent-operations" id="id701">Memory Model for Concurrent Operations</a></li>
+<li><a class="reference internal" href="#atomic-memory-ordering-constraints" id="id702">Atomic Memory Ordering Constraints</a></li>
+<li><a class="reference internal" href="#fast-math-flags" id="id703">Fast-Math Flags</a></li>
+<li><a class="reference internal" href="#use-list-order-directives" id="id704">Use-list Order Directives</a></li>
+<li><a class="reference internal" href="#source-filename" id="id705">Source Filename</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#type-system" id="id706">Type System</a><ul>
+<li><a class="reference internal" href="#void-type" id="id707">Void Type</a></li>
+<li><a class="reference internal" href="#function-type" id="id708">Function Type</a></li>
+<li><a class="reference internal" href="#first-class-types" id="id709">First Class Types</a><ul>
+<li><a class="reference internal" href="#single-value-types" id="id710">Single Value Types</a><ul>
+<li><a class="reference internal" href="#integer-type" id="id711">Integer Type</a></li>
+<li><a class="reference internal" href="#floating-point-types" id="id712">Floating Point Types</a></li>
+<li><a class="reference internal" href="#x86-mmx-type" id="id713">X86_mmx Type</a></li>
+<li><a class="reference internal" href="#pointer-type" id="id714">Pointer Type</a></li>
+<li><a class="reference internal" href="#vector-type" id="id715">Vector Type</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#label-type" id="id716">Label Type</a></li>
+<li><a class="reference internal" href="#token-type" id="id717">Token Type</a></li>
+<li><a class="reference internal" href="#metadata-type" id="id718">Metadata Type</a></li>
+<li><a class="reference internal" href="#aggregate-types" id="id719">Aggregate Types</a><ul>
+<li><a class="reference internal" href="#array-type" id="id720">Array Type</a></li>
+<li><a class="reference internal" href="#structure-type" id="id721">Structure Type</a></li>
+<li><a class="reference internal" href="#opaque-structure-types" id="id722">Opaque Structure Types</a></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#constants" id="id723">Constants</a><ul>
+<li><a class="reference internal" href="#simple-constants" id="id724">Simple Constants</a></li>
+<li><a class="reference internal" href="#complex-constants" id="id725">Complex Constants</a></li>
+<li><a class="reference internal" href="#global-variable-and-function-addresses" id="id726">Global Variable and Function Addresses</a></li>
+<li><a class="reference internal" href="#undefined-values" id="id727">Undefined Values</a></li>
+<li><a class="reference internal" href="#poison-values" id="id728">Poison Values</a></li>
+<li><a class="reference internal" href="#addresses-of-basic-blocks" id="id729">Addresses of Basic Blocks</a></li>
+<li><a class="reference internal" href="#constant-expressions" id="id730">Constant Expressions</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#other-values" id="id731">Other Values</a><ul>
+<li><a class="reference internal" href="#inline-assembler-expressions" id="id732">Inline Assembler Expressions</a><ul>
+<li><a class="reference internal" href="#inline-asm-constraint-string" id="id733">Inline Asm Constraint String</a><ul>
+<li><a class="reference internal" href="#output-constraints" id="id734">Output constraints</a></li>
+<li><a class="reference internal" href="#input-constraints" id="id735">Input constraints</a></li>
+<li><a class="reference internal" href="#indirect-inputs-and-outputs" id="id736">Indirect inputs and outputs</a></li>
+<li><a class="reference internal" href="#clobber-constraints" id="id737">Clobber constraints</a></li>
+<li><a class="reference internal" href="#constraint-codes" id="id738">Constraint Codes</a></li>
+<li><a class="reference internal" href="#supported-constraint-code-list" id="id739">Supported Constraint Code List</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#asm-template-argument-modifiers" id="id740">Asm template argument modifiers</a></li>
+<li><a class="reference internal" href="#inline-asm-metadata" id="id741">Inline Asm Metadata</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#metadata" id="id742">Metadata</a><ul>
+<li><a class="reference internal" href="#metadata-nodes-and-metadata-strings" id="id743">Metadata Nodes and Metadata Strings</a><ul>
+<li><a class="reference internal" href="#specialized-metadata-nodes" id="id744">Specialized Metadata Nodes</a><ul>
+<li><a class="reference internal" href="#dicompileunit" id="id745">DICompileUnit</a></li>
+<li><a class="reference internal" href="#difile" id="id746">DIFile</a></li>
+<li><a class="reference internal" href="#dibasictype" id="id747">DIBasicType</a></li>
+<li><a class="reference internal" href="#disubroutinetype" id="id748">DISubroutineType</a></li>
+<li><a class="reference internal" href="#diderivedtype" id="id749">DIDerivedType</a></li>
+<li><a class="reference internal" href="#dicompositetype" id="id750">DICompositeType</a></li>
+<li><a class="reference internal" href="#disubrange" id="id751">DISubrange</a></li>
+<li><a class="reference internal" href="#dienumerator" id="id752">DIEnumerator</a></li>
+<li><a class="reference internal" href="#ditemplatetypeparameter" id="id753">DITemplateTypeParameter</a></li>
+<li><a class="reference internal" href="#ditemplatevalueparameter" id="id754">DITemplateValueParameter</a></li>
+<li><a class="reference internal" href="#dinamespace" id="id755">DINamespace</a></li>
+<li><a class="reference internal" href="#diglobalvariable" id="id756">DIGlobalVariable</a></li>
+<li><a class="reference internal" href="#disubprogram" id="id757">DISubprogram</a></li>
+<li><a class="reference internal" href="#dilexicalblock" id="id758">DILexicalBlock</a></li>
+<li><a class="reference internal" href="#dilexicalblockfile" id="id759">DILexicalBlockFile</a></li>
+<li><a class="reference internal" href="#dilocation" id="id760">DILocation</a></li>
+<li><a class="reference internal" href="#dilocalvariable" id="id761">DILocalVariable</a></li>
+<li><a class="reference internal" href="#diexpression" id="id762">DIExpression</a></li>
+<li><a class="reference internal" href="#diobjcproperty" id="id763">DIObjCProperty</a></li>
+<li><a class="reference internal" href="#diimportedentity" id="id764">DIImportedEntity</a></li>
+<li><a class="reference internal" href="#dimacro" id="id765">DIMacro</a></li>
+<li><a class="reference internal" href="#dimacrofile" id="id766">DIMacroFile</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#tbaa-metadata" id="id767">‘<tt class="docutils literal"><span class="pre">tbaa</span></tt>‘ Metadata</a></li>
+<li><a class="reference internal" href="#tbaa-struct-metadata" id="id768">‘<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="id769">‘<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="id770">‘<tt class="docutils literal"><span class="pre">fpmath</span></tt>‘ Metadata</a></li>
+<li><a class="reference internal" href="#range-metadata" id="id771">‘<tt class="docutils literal"><span class="pre">range</span></tt>‘ Metadata</a></li>
+<li><a class="reference internal" href="#unpredictable-metadata" id="id772">‘<tt class="docutils literal"><span class="pre">unpredictable</span></tt>‘ Metadata</a></li>
+<li><a class="reference internal" href="#llvm-loop" id="id773">‘<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="id774">‘<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="id775">‘<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="id776">‘<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="id777">‘<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="id778">‘<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="id779">‘<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="id780">‘<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="id781">‘<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="id782">‘<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="id783">‘<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="id784">‘<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="id785">‘<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="id786">‘<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="id787">‘<tt class="docutils literal"><span class="pre">llvm.mem.parallel_loop_access</span></tt>‘ Metadata</a></li>
+<li><a class="reference internal" href="#invariant-group-metadata" id="id788">‘<tt class="docutils literal"><span class="pre">invariant.group</span></tt>‘ Metadata</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#module-flags-metadata" id="id789">Module Flags Metadata</a><ul>
+<li><a class="reference internal" href="#objective-c-garbage-collection-module-flags-metadata" id="id790">Objective-C Garbage Collection Module Flags Metadata</a></li>
+<li><a class="reference internal" href="#automatic-linker-flags-module-flags-metadata" id="id791">Automatic Linker Flags Module Flags Metadata</a></li>
+<li><a class="reference internal" href="#c-type-width-module-flags-metadata" id="id792">C type width Module Flags Metadata</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#intrinsic-global-variables" id="id793">Intrinsic Global Variables</a><ul>
+<li><a class="reference internal" href="#the-llvm-used-global-variable" id="id794">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="id795">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="id796">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="id797">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="id798">Instruction Reference</a><ul>
+<li><a class="reference internal" href="#terminator-instructions" id="id799">Terminator Instructions</a><ul>
+<li><a class="reference internal" href="#ret-instruction" id="id800">‘<tt class="docutils literal"><span class="pre">ret</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#syntax" id="id801">Syntax:</a></li>
+<li><a class="reference internal" href="#overview" id="id802">Overview:</a></li>
+<li><a class="reference internal" href="#arguments" id="id803">Arguments:</a></li>
+<li><a class="reference internal" href="#semantics" id="id804">Semantics:</a></li>
+<li><a class="reference internal" href="#example" id="id805">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#br-instruction" id="id806">‘<tt class="docutils literal"><span class="pre">br</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id20" id="id807">Syntax:</a></li>
+<li><a class="reference internal" href="#id21" id="id808">Overview:</a></li>
+<li><a class="reference internal" href="#id22" id="id809">Arguments:</a></li>
+<li><a class="reference internal" href="#id23" id="id810">Semantics:</a></li>
+<li><a class="reference internal" href="#id24" id="id811">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#switch-instruction" id="id812">‘<tt class="docutils literal"><span class="pre">switch</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id25" id="id813">Syntax:</a></li>
+<li><a class="reference internal" href="#id26" id="id814">Overview:</a></li>
+<li><a class="reference internal" href="#id27" id="id815">Arguments:</a></li>
+<li><a class="reference internal" href="#id28" id="id816">Semantics:</a></li>
+<li><a class="reference internal" href="#implementation" id="id817">Implementation:</a></li>
+<li><a class="reference internal" href="#id29" id="id818">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#indirectbr-instruction" id="id819">‘<tt class="docutils literal"><span class="pre">indirectbr</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id30" id="id820">Syntax:</a></li>
+<li><a class="reference internal" href="#id31" id="id821">Overview:</a></li>
+<li><a class="reference internal" href="#id32" id="id822">Arguments:</a></li>
+<li><a class="reference internal" href="#id33" id="id823">Semantics:</a></li>
+<li><a class="reference internal" href="#id34" id="id824">Implementation:</a></li>
+<li><a class="reference internal" href="#id35" id="id825">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#invoke-instruction" id="id826">‘<tt class="docutils literal"><span class="pre">invoke</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id36" id="id827">Syntax:</a></li>
+<li><a class="reference internal" href="#id37" id="id828">Overview:</a></li>
+<li><a class="reference internal" href="#id38" id="id829">Arguments:</a></li>
+<li><a class="reference internal" href="#id39" id="id830">Semantics:</a></li>
+<li><a class="reference internal" href="#id40" id="id831">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#resume-instruction" id="id832">‘<tt class="docutils literal"><span class="pre">resume</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id41" id="id833">Syntax:</a></li>
+<li><a class="reference internal" href="#id42" id="id834">Overview:</a></li>
+<li><a class="reference internal" href="#id43" id="id835">Arguments:</a></li>
+<li><a class="reference internal" href="#id44" id="id836">Semantics:</a></li>
+<li><a class="reference internal" href="#id45" id="id837">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#catchswitch-instruction" id="id838">‘<tt class="docutils literal"><span class="pre">catchswitch</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id46" id="id839">Syntax:</a></li>
+<li><a class="reference internal" href="#id47" id="id840">Overview:</a></li>
+<li><a class="reference internal" href="#id48" id="id841">Arguments:</a></li>
+<li><a class="reference internal" href="#id49" id="id842">Semantics:</a></li>
+<li><a class="reference internal" href="#id50" id="id843">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#catchret-instruction" id="id844">‘<tt class="docutils literal"><span class="pre">catchret</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id51" id="id845">Syntax:</a></li>
+<li><a class="reference internal" href="#id52" id="id846">Overview:</a></li>
+<li><a class="reference internal" href="#id53" id="id847">Arguments:</a></li>
+<li><a class="reference internal" href="#id54" id="id848">Semantics:</a></li>
+<li><a class="reference internal" href="#id55" id="id849">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#cleanupret-instruction" id="id850">‘<tt class="docutils literal"><span class="pre">cleanupret</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id56" id="id851">Syntax:</a></li>
+<li><a class="reference internal" href="#id57" id="id852">Overview:</a></li>
+<li><a class="reference internal" href="#id58" id="id853">Arguments:</a></li>
+<li><a class="reference internal" href="#id61" id="id854">Semantics:</a></li>
+<li><a class="reference internal" href="#id62" id="id855">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#unreachable-instruction" id="id856">‘<tt class="docutils literal"><span class="pre">unreachable</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id63" id="id857">Syntax:</a></li>
+<li><a class="reference internal" href="#id64" id="id858">Overview:</a></li>
+<li><a class="reference internal" href="#id65" id="id859">Semantics:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#binary-operations" id="id860">Binary Operations</a><ul>
+<li><a class="reference internal" href="#add-instruction" id="id861">‘<tt class="docutils literal"><span class="pre">add</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id66" id="id862">Syntax:</a></li>
+<li><a class="reference internal" href="#id67" id="id863">Overview:</a></li>
+<li><a class="reference internal" href="#id68" id="id864">Arguments:</a></li>
+<li><a class="reference internal" href="#id69" id="id865">Semantics:</a></li>
+<li><a class="reference internal" href="#id70" id="id866">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#fadd-instruction" id="id867">‘<tt class="docutils literal"><span class="pre">fadd</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id71" id="id868">Syntax:</a></li>
+<li><a class="reference internal" href="#id72" id="id869">Overview:</a></li>
+<li><a class="reference internal" href="#id73" id="id870">Arguments:</a></li>
+<li><a class="reference internal" href="#id74" id="id871">Semantics:</a></li>
+<li><a class="reference internal" href="#id75" id="id872">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#sub-instruction" id="id873">‘<tt class="docutils literal"><span class="pre">sub</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id76" id="id874">Syntax:</a></li>
+<li><a class="reference internal" href="#id77" id="id875">Overview:</a></li>
+<li><a class="reference internal" href="#id78" id="id876">Arguments:</a></li>
+<li><a class="reference internal" href="#id79" id="id877">Semantics:</a></li>
+<li><a class="reference internal" href="#id80" id="id878">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#fsub-instruction" id="id879">‘<tt class="docutils literal"><span class="pre">fsub</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id81" id="id880">Syntax:</a></li>
+<li><a class="reference internal" href="#id82" id="id881">Overview:</a></li>
+<li><a class="reference internal" href="#id83" id="id882">Arguments:</a></li>
+<li><a class="reference internal" href="#id84" id="id883">Semantics:</a></li>
+<li><a class="reference internal" href="#id85" id="id884">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#mul-instruction" id="id885">‘<tt class="docutils literal"><span class="pre">mul</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id86" id="id886">Syntax:</a></li>
+<li><a class="reference internal" href="#id87" id="id887">Overview:</a></li>
+<li><a class="reference internal" href="#id88" id="id888">Arguments:</a></li>
+<li><a class="reference internal" href="#id89" id="id889">Semantics:</a></li>
+<li><a class="reference internal" href="#id90" id="id890">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#fmul-instruction" id="id891">‘<tt class="docutils literal"><span class="pre">fmul</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id91" id="id892">Syntax:</a></li>
+<li><a class="reference internal" href="#id92" id="id893">Overview:</a></li>
+<li><a class="reference internal" href="#id93" id="id894">Arguments:</a></li>
+<li><a class="reference internal" href="#id94" id="id895">Semantics:</a></li>
+<li><a class="reference internal" href="#id95" id="id896">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#udiv-instruction" id="id897">‘<tt class="docutils literal"><span class="pre">udiv</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id96" id="id898">Syntax:</a></li>
+<li><a class="reference internal" href="#id97" id="id899">Overview:</a></li>
+<li><a class="reference internal" href="#id98" id="id900">Arguments:</a></li>
+<li><a class="reference internal" href="#id99" id="id901">Semantics:</a></li>
+<li><a class="reference internal" href="#id100" id="id902">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#sdiv-instruction" id="id903">‘<tt class="docutils literal"><span class="pre">sdiv</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id101" id="id904">Syntax:</a></li>
+<li><a class="reference internal" href="#id102" id="id905">Overview:</a></li>
+<li><a class="reference internal" href="#id103" id="id906">Arguments:</a></li>
+<li><a class="reference internal" href="#id104" id="id907">Semantics:</a></li>
+<li><a class="reference internal" href="#id105" id="id908">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#fdiv-instruction" id="id909">‘<tt class="docutils literal"><span class="pre">fdiv</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id106" id="id910">Syntax:</a></li>
+<li><a class="reference internal" href="#id107" id="id911">Overview:</a></li>
+<li><a class="reference internal" href="#id108" id="id912">Arguments:</a></li>
+<li><a class="reference internal" href="#id109" id="id913">Semantics:</a></li>
+<li><a class="reference internal" href="#id110" id="id914">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#urem-instruction" id="id915">‘<tt class="docutils literal"><span class="pre">urem</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id111" id="id916">Syntax:</a></li>
+<li><a class="reference internal" href="#id112" id="id917">Overview:</a></li>
+<li><a class="reference internal" href="#id113" id="id918">Arguments:</a></li>
+<li><a class="reference internal" href="#id114" id="id919">Semantics:</a></li>
+<li><a class="reference internal" href="#id115" id="id920">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#srem-instruction" id="id921">‘<tt class="docutils literal"><span class="pre">srem</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id116" id="id922">Syntax:</a></li>
+<li><a class="reference internal" href="#id117" id="id923">Overview:</a></li>
+<li><a class="reference internal" href="#id118" id="id924">Arguments:</a></li>
+<li><a class="reference internal" href="#id119" id="id925">Semantics:</a></li>
+<li><a class="reference internal" href="#id120" id="id926">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#frem-instruction" id="id927">‘<tt class="docutils literal"><span class="pre">frem</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id121" id="id928">Syntax:</a></li>
+<li><a class="reference internal" href="#id122" id="id929">Overview:</a></li>
+<li><a class="reference internal" href="#id123" id="id930">Arguments:</a></li>
+<li><a class="reference internal" href="#id124" id="id931">Semantics:</a></li>
+<li><a class="reference internal" href="#id125" id="id932">Example:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#bitwise-binary-operations" id="id933">Bitwise Binary Operations</a><ul>
+<li><a class="reference internal" href="#shl-instruction" id="id934">‘<tt class="docutils literal"><span class="pre">shl</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id126" id="id935">Syntax:</a></li>
+<li><a class="reference internal" href="#id127" id="id936">Overview:</a></li>
+<li><a class="reference internal" href="#id128" id="id937">Arguments:</a></li>
+<li><a class="reference internal" href="#id129" id="id938">Semantics:</a></li>
+<li><a class="reference internal" href="#id130" id="id939">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#lshr-instruction" id="id940">‘<tt class="docutils literal"><span class="pre">lshr</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id131" id="id941">Syntax:</a></li>
+<li><a class="reference internal" href="#id132" id="id942">Overview:</a></li>
+<li><a class="reference internal" href="#id133" id="id943">Arguments:</a></li>
+<li><a class="reference internal" href="#id134" id="id944">Semantics:</a></li>
+<li><a class="reference internal" href="#id135" id="id945">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#ashr-instruction" id="id946">‘<tt class="docutils literal"><span class="pre">ashr</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id136" id="id947">Syntax:</a></li>
+<li><a class="reference internal" href="#id137" id="id948">Overview:</a></li>
+<li><a class="reference internal" href="#id138" id="id949">Arguments:</a></li>
+<li><a class="reference internal" href="#id139" id="id950">Semantics:</a></li>
+<li><a class="reference internal" href="#id140" id="id951">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#and-instruction" id="id952">‘<tt class="docutils literal"><span class="pre">and</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id141" id="id953">Syntax:</a></li>
+<li><a class="reference internal" href="#id142" id="id954">Overview:</a></li>
+<li><a class="reference internal" href="#id143" id="id955">Arguments:</a></li>
+<li><a class="reference internal" href="#id144" id="id956">Semantics:</a></li>
+<li><a class="reference internal" href="#id145" id="id957">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#or-instruction" id="id958">‘<tt class="docutils literal"><span class="pre">or</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id146" id="id959">Syntax:</a></li>
+<li><a class="reference internal" href="#id147" id="id960">Overview:</a></li>
+<li><a class="reference internal" href="#id148" id="id961">Arguments:</a></li>
+<li><a class="reference internal" href="#id149" id="id962">Semantics:</a></li>
+<li><a class="reference internal" href="#id150" id="id963">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#xor-instruction" id="id964">‘<tt class="docutils literal"><span class="pre">xor</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id151" id="id965">Syntax:</a></li>
+<li><a class="reference internal" href="#id152" id="id966">Overview:</a></li>
+<li><a class="reference internal" href="#id153" id="id967">Arguments:</a></li>
+<li><a class="reference internal" href="#id154" id="id968">Semantics:</a></li>
+<li><a class="reference internal" href="#id155" id="id969">Example:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#vector-operations" id="id970">Vector Operations</a><ul>
+<li><a class="reference internal" href="#extractelement-instruction" id="id971">‘<tt class="docutils literal"><span class="pre">extractelement</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id156" id="id972">Syntax:</a></li>
+<li><a class="reference internal" href="#id157" id="id973">Overview:</a></li>
+<li><a class="reference internal" href="#id158" id="id974">Arguments:</a></li>
+<li><a class="reference internal" href="#id159" id="id975">Semantics:</a></li>
+<li><a class="reference internal" href="#id160" id="id976">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#insertelement-instruction" id="id977">‘<tt class="docutils literal"><span class="pre">insertelement</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id161" id="id978">Syntax:</a></li>
+<li><a class="reference internal" href="#id162" id="id979">Overview:</a></li>
+<li><a class="reference internal" href="#id163" id="id980">Arguments:</a></li>
+<li><a class="reference internal" href="#id164" id="id981">Semantics:</a></li>
+<li><a class="reference internal" href="#id165" id="id982">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#shufflevector-instruction" id="id983">‘<tt class="docutils literal"><span class="pre">shufflevector</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id166" id="id984">Syntax:</a></li>
+<li><a class="reference internal" href="#id167" id="id985">Overview:</a></li>
+<li><a class="reference internal" href="#id168" id="id986">Arguments:</a></li>
+<li><a class="reference internal" href="#id169" id="id987">Semantics:</a></li>
+<li><a class="reference internal" href="#id170" id="id988">Example:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#aggregate-operations" id="id989">Aggregate Operations</a><ul>
+<li><a class="reference internal" href="#extractvalue-instruction" id="id990">‘<tt class="docutils literal"><span class="pre">extractvalue</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id171" id="id991">Syntax:</a></li>
+<li><a class="reference internal" href="#id172" id="id992">Overview:</a></li>
+<li><a class="reference internal" href="#id173" id="id993">Arguments:</a></li>
+<li><a class="reference internal" href="#id174" id="id994">Semantics:</a></li>
+<li><a class="reference internal" href="#id175" id="id995">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#insertvalue-instruction" id="id996">‘<tt class="docutils literal"><span class="pre">insertvalue</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id176" id="id997">Syntax:</a></li>
+<li><a class="reference internal" href="#id177" id="id998">Overview:</a></li>
+<li><a class="reference internal" href="#id178" id="id999">Arguments:</a></li>
+<li><a class="reference internal" href="#id179" id="id1000">Semantics:</a></li>
+<li><a class="reference internal" href="#id180" id="id1001">Example:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#memory-access-and-addressing-operations" id="id1002">Memory Access and Addressing Operations</a><ul>
+<li><a class="reference internal" href="#alloca-instruction" id="id1003">‘<tt class="docutils literal"><span class="pre">alloca</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id181" id="id1004">Syntax:</a></li>
+<li><a class="reference internal" href="#id182" id="id1005">Overview:</a></li>
+<li><a class="reference internal" href="#id183" id="id1006">Arguments:</a></li>
+<li><a class="reference internal" href="#id184" id="id1007">Semantics:</a></li>
+<li><a class="reference internal" href="#id185" id="id1008">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#load-instruction" id="id1009">‘<tt class="docutils literal"><span class="pre">load</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id186" id="id1010">Syntax:</a></li>
+<li><a class="reference internal" href="#id187" id="id1011">Overview:</a></li>
+<li><a class="reference internal" href="#id188" id="id1012">Arguments:</a></li>
+<li><a class="reference internal" href="#id189" id="id1013">Semantics:</a></li>
+<li><a class="reference internal" href="#id190" id="id1014">Examples:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#store-instruction" id="id1015">‘<tt class="docutils literal"><span class="pre">store</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id191" id="id1016">Syntax:</a></li>
+<li><a class="reference internal" href="#id192" id="id1017">Overview:</a></li>
+<li><a class="reference internal" href="#id193" id="id1018">Arguments:</a></li>
+<li><a class="reference internal" href="#id194" id="id1019">Semantics:</a></li>
+<li><a class="reference internal" href="#id195" id="id1020">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#fence-instruction" id="id1021">‘<tt class="docutils literal"><span class="pre">fence</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id196" id="id1022">Syntax:</a></li>
+<li><a class="reference internal" href="#id197" id="id1023">Overview:</a></li>
+<li><a class="reference internal" href="#id198" id="id1024">Arguments:</a></li>
+<li><a class="reference internal" href="#id199" id="id1025">Semantics:</a></li>
+<li><a class="reference internal" href="#id200" id="id1026">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#cmpxchg-instruction" id="id1027">‘<tt class="docutils literal"><span class="pre">cmpxchg</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id201" id="id1028">Syntax:</a></li>
+<li><a class="reference internal" href="#id202" id="id1029">Overview:</a></li>
+<li><a class="reference internal" href="#id203" id="id1030">Arguments:</a></li>
+<li><a class="reference internal" href="#id204" id="id1031">Semantics:</a></li>
+<li><a class="reference internal" href="#id205" id="id1032">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#atomicrmw-instruction" id="id1033">‘<tt class="docutils literal"><span class="pre">atomicrmw</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id206" id="id1034">Syntax:</a></li>
+<li><a class="reference internal" href="#id207" id="id1035">Overview:</a></li>
+<li><a class="reference internal" href="#id208" id="id1036">Arguments:</a></li>
+<li><a class="reference internal" href="#id209" id="id1037">Semantics:</a></li>
+<li><a class="reference internal" href="#id210" id="id1038">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#getelementptr-instruction" id="id1039">‘<tt class="docutils literal"><span class="pre">getelementptr</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id211" id="id1040">Syntax:</a></li>
+<li><a class="reference internal" href="#id212" id="id1041">Overview:</a></li>
+<li><a class="reference internal" href="#id213" id="id1042">Arguments:</a></li>
+<li><a class="reference internal" href="#id214" id="id1043">Semantics:</a></li>
+<li><a class="reference internal" href="#id215" id="id1044">Example:</a></li>
+<li><a class="reference internal" href="#vector-of-pointers" id="id1045">Vector of pointers:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#conversion-operations" id="id1046">Conversion Operations</a><ul>
+<li><a class="reference internal" href="#trunc-to-instruction" id="id1047">‘<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="#id216" id="id1048">Syntax:</a></li>
+<li><a class="reference internal" href="#id217" id="id1049">Overview:</a></li>
+<li><a class="reference internal" href="#id218" id="id1050">Arguments:</a></li>
+<li><a class="reference internal" href="#id219" id="id1051">Semantics:</a></li>
+<li><a class="reference internal" href="#id220" id="id1052">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#zext-to-instruction" id="id1053">‘<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="#id221" id="id1054">Syntax:</a></li>
+<li><a class="reference internal" href="#id222" id="id1055">Overview:</a></li>
+<li><a class="reference internal" href="#id223" id="id1056">Arguments:</a></li>
+<li><a class="reference internal" href="#id224" id="id1057">Semantics:</a></li>
+<li><a class="reference internal" href="#id225" id="id1058">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#sext-to-instruction" id="id1059">‘<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="#id226" id="id1060">Syntax:</a></li>
+<li><a class="reference internal" href="#id227" id="id1061">Overview:</a></li>
+<li><a class="reference internal" href="#id228" id="id1062">Arguments:</a></li>
+<li><a class="reference internal" href="#id229" id="id1063">Semantics:</a></li>
+<li><a class="reference internal" href="#id230" id="id1064">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#fptrunc-to-instruction" id="id1065">‘<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="#id231" id="id1066">Syntax:</a></li>
+<li><a class="reference internal" href="#id232" id="id1067">Overview:</a></li>
+<li><a class="reference internal" href="#id233" id="id1068">Arguments:</a></li>
+<li><a class="reference internal" href="#id234" id="id1069">Semantics:</a></li>
+<li><a class="reference internal" href="#id235" id="id1070">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#fpext-to-instruction" id="id1071">‘<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="#id236" id="id1072">Syntax:</a></li>
+<li><a class="reference internal" href="#id237" id="id1073">Overview:</a></li>
+<li><a class="reference internal" href="#id238" id="id1074">Arguments:</a></li>
+<li><a class="reference internal" href="#id239" id="id1075">Semantics:</a></li>
+<li><a class="reference internal" href="#id240" id="id1076">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#fptoui-to-instruction" id="id1077">‘<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="#id241" id="id1078">Syntax:</a></li>
+<li><a class="reference internal" href="#id242" id="id1079">Overview:</a></li>
+<li><a class="reference internal" href="#id243" id="id1080">Arguments:</a></li>
+<li><a class="reference internal" href="#id244" id="id1081">Semantics:</a></li>
+<li><a class="reference internal" href="#id245" id="id1082">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#fptosi-to-instruction" id="id1083">‘<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="#id246" id="id1084">Syntax:</a></li>
+<li><a class="reference internal" href="#id247" id="id1085">Overview:</a></li>
+<li><a class="reference internal" href="#id248" id="id1086">Arguments:</a></li>
+<li><a class="reference internal" href="#id249" id="id1087">Semantics:</a></li>
+<li><a class="reference internal" href="#id250" id="id1088">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#uitofp-to-instruction" id="id1089">‘<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="#id251" id="id1090">Syntax:</a></li>
+<li><a class="reference internal" href="#id252" id="id1091">Overview:</a></li>
+<li><a class="reference internal" href="#id253" id="id1092">Arguments:</a></li>
+<li><a class="reference internal" href="#id254" id="id1093">Semantics:</a></li>
+<li><a class="reference internal" href="#id255" id="id1094">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#sitofp-to-instruction" id="id1095">‘<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="#id256" id="id1096">Syntax:</a></li>
+<li><a class="reference internal" href="#id257" id="id1097">Overview:</a></li>
+<li><a class="reference internal" href="#id258" id="id1098">Arguments:</a></li>
+<li><a class="reference internal" href="#id259" id="id1099">Semantics:</a></li>
+<li><a class="reference internal" href="#id260" id="id1100">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#ptrtoint-to-instruction" id="id1101">‘<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="#id261" id="id1102">Syntax:</a></li>
+<li><a class="reference internal" href="#id262" id="id1103">Overview:</a></li>
+<li><a class="reference internal" href="#id263" id="id1104">Arguments:</a></li>
+<li><a class="reference internal" href="#id264" id="id1105">Semantics:</a></li>
+<li><a class="reference internal" href="#id265" id="id1106">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#inttoptr-to-instruction" id="id1107">‘<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="#id266" id="id1108">Syntax:</a></li>
+<li><a class="reference internal" href="#id267" id="id1109">Overview:</a></li>
+<li><a class="reference internal" href="#id268" id="id1110">Arguments:</a></li>
+<li><a class="reference internal" href="#id269" id="id1111">Semantics:</a></li>
+<li><a class="reference internal" href="#id270" id="id1112">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#bitcast-to-instruction" id="id1113">‘<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="#id271" id="id1114">Syntax:</a></li>
+<li><a class="reference internal" href="#id272" id="id1115">Overview:</a></li>
+<li><a class="reference internal" href="#id273" id="id1116">Arguments:</a></li>
+<li><a class="reference internal" href="#id274" id="id1117">Semantics:</a></li>
+<li><a class="reference internal" href="#id275" id="id1118">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#addrspacecast-to-instruction" id="id1119">‘<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="#id276" id="id1120">Syntax:</a></li>
+<li><a class="reference internal" href="#id277" id="id1121">Overview:</a></li>
+<li><a class="reference internal" href="#id278" id="id1122">Arguments:</a></li>
+<li><a class="reference internal" href="#id279" id="id1123">Semantics:</a></li>
+<li><a class="reference internal" href="#id280" id="id1124">Example:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#other-operations" id="id1125">Other Operations</a><ul>
+<li><a class="reference internal" href="#icmp-instruction" id="id1126">‘<tt class="docutils literal"><span class="pre">icmp</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id281" id="id1127">Syntax:</a></li>
+<li><a class="reference internal" href="#id282" id="id1128">Overview:</a></li>
+<li><a class="reference internal" href="#id283" id="id1129">Arguments:</a></li>
+<li><a class="reference internal" href="#id284" id="id1130">Semantics:</a></li>
+<li><a class="reference internal" href="#id285" id="id1131">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#fcmp-instruction" id="id1132">‘<tt class="docutils literal"><span class="pre">fcmp</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id286" id="id1133">Syntax:</a></li>
+<li><a class="reference internal" href="#id287" id="id1134">Overview:</a></li>
+<li><a class="reference internal" href="#id288" id="id1135">Arguments:</a></li>
+<li><a class="reference internal" href="#id289" id="id1136">Semantics:</a></li>
+<li><a class="reference internal" href="#id290" id="id1137">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#phi-instruction" id="id1138">‘<tt class="docutils literal"><span class="pre">phi</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id291" id="id1139">Syntax:</a></li>
+<li><a class="reference internal" href="#id292" id="id1140">Overview:</a></li>
+<li><a class="reference internal" href="#id293" id="id1141">Arguments:</a></li>
+<li><a class="reference internal" href="#id294" id="id1142">Semantics:</a></li>
+<li><a class="reference internal" href="#id295" id="id1143">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#select-instruction" id="id1144">‘<tt class="docutils literal"><span class="pre">select</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id296" id="id1145">Syntax:</a></li>
+<li><a class="reference internal" href="#id297" id="id1146">Overview:</a></li>
+<li><a class="reference internal" href="#id298" id="id1147">Arguments:</a></li>
+<li><a class="reference internal" href="#id299" id="id1148">Semantics:</a></li>
+<li><a class="reference internal" href="#id300" id="id1149">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#call-instruction" id="id1150">‘<tt class="docutils literal"><span class="pre">call</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id301" id="id1151">Syntax:</a></li>
+<li><a class="reference internal" href="#id302" id="id1152">Overview:</a></li>
+<li><a class="reference internal" href="#id303" id="id1153">Arguments:</a></li>
+<li><a class="reference internal" href="#id304" id="id1154">Semantics:</a></li>
+<li><a class="reference internal" href="#id305" id="id1155">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#va-arg-instruction" id="id1156">‘<tt class="docutils literal"><span class="pre">va_arg</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id306" id="id1157">Syntax:</a></li>
+<li><a class="reference internal" href="#id307" id="id1158">Overview:</a></li>
+<li><a class="reference internal" href="#id308" id="id1159">Arguments:</a></li>
+<li><a class="reference internal" href="#id309" id="id1160">Semantics:</a></li>
+<li><a class="reference internal" href="#id310" id="id1161">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#landingpad-instruction" id="id1162">‘<tt class="docutils literal"><span class="pre">landingpad</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id311" id="id1163">Syntax:</a></li>
+<li><a class="reference internal" href="#id312" id="id1164">Overview:</a></li>
+<li><a class="reference internal" href="#id314" id="id1165">Arguments:</a></li>
+<li><a class="reference internal" href="#id315" id="id1166">Semantics:</a></li>
+<li><a class="reference internal" href="#id316" id="id1167">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#catchpad-instruction" id="id1168">‘<tt class="docutils literal"><span class="pre">catchpad</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id317" id="id1169">Syntax:</a></li>
+<li><a class="reference internal" href="#id318" id="id1170">Overview:</a></li>
+<li><a class="reference internal" href="#id320" id="id1171">Arguments:</a></li>
+<li><a class="reference internal" href="#id321" id="id1172">Semantics:</a></li>
+<li><a class="reference internal" href="#id323" id="id1173">Example:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#cleanuppad-instruction" id="id1174">‘<tt class="docutils literal"><span class="pre">cleanuppad</span></tt>‘ Instruction</a><ul>
+<li><a class="reference internal" href="#id324" id="id1175">Syntax:</a></li>
+<li><a class="reference internal" href="#id325" id="id1176">Overview:</a></li>
+<li><a class="reference internal" href="#id327" id="id1177">Arguments:</a></li>
+<li><a class="reference internal" href="#id328" id="id1178">Semantics:</a></li>
+<li><a class="reference internal" href="#id330" id="id1179">Example:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#intrinsic-functions" id="id1180">Intrinsic Functions</a><ul>
+<li><a class="reference internal" href="#variable-argument-handling-intrinsics" id="id1181">Variable Argument Handling Intrinsics</a><ul>
+<li><a class="reference internal" href="#llvm-va-start-intrinsic" id="id1182">‘<tt class="docutils literal"><span class="pre">llvm.va_start</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id331" id="id1183">Syntax:</a></li>
+<li><a class="reference internal" href="#id332" id="id1184">Overview:</a></li>
+<li><a class="reference internal" href="#id333" id="id1185">Arguments:</a></li>
+<li><a class="reference internal" href="#id334" id="id1186">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-va-end-intrinsic" id="id1187">‘<tt class="docutils literal"><span class="pre">llvm.va_end</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id335" id="id1188">Syntax:</a></li>
+<li><a class="reference internal" href="#id336" id="id1189">Overview:</a></li>
+<li><a class="reference internal" href="#id337" id="id1190">Arguments:</a></li>
+<li><a class="reference internal" href="#id338" id="id1191">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-va-copy-intrinsic" id="id1192">‘<tt class="docutils literal"><span class="pre">llvm.va_copy</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id339" id="id1193">Syntax:</a></li>
+<li><a class="reference internal" href="#id340" id="id1194">Overview:</a></li>
+<li><a class="reference internal" href="#id341" id="id1195">Arguments:</a></li>
+<li><a class="reference internal" href="#id342" id="id1196">Semantics:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#accurate-garbage-collection-intrinsics" id="id1197">Accurate Garbage Collection Intrinsics</a><ul>
+<li><a class="reference internal" href="#experimental-statepoint-intrinsics" id="id1198">Experimental Statepoint Intrinsics</a></li>
+<li><a class="reference internal" href="#llvm-gcroot-intrinsic" id="id1199">‘<tt class="docutils literal"><span class="pre">llvm.gcroot</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id344" id="id1200">Syntax:</a></li>
+<li><a class="reference internal" href="#id345" id="id1201">Overview:</a></li>
+<li><a class="reference internal" href="#id346" id="id1202">Arguments:</a></li>
+<li><a class="reference internal" href="#id347" id="id1203">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-gcread-intrinsic" id="id1204">‘<tt class="docutils literal"><span class="pre">llvm.gcread</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id348" id="id1205">Syntax:</a></li>
+<li><a class="reference internal" href="#id349" id="id1206">Overview:</a></li>
+<li><a class="reference internal" href="#id350" id="id1207">Arguments:</a></li>
+<li><a class="reference internal" href="#id351" id="id1208">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-gcwrite-intrinsic" id="id1209">‘<tt class="docutils literal"><span class="pre">llvm.gcwrite</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id352" id="id1210">Syntax:</a></li>
+<li><a class="reference internal" href="#id353" id="id1211">Overview:</a></li>
+<li><a class="reference internal" href="#id354" id="id1212">Arguments:</a></li>
+<li><a class="reference internal" href="#id355" id="id1213">Semantics:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#code-generator-intrinsics" id="id1214">Code Generator Intrinsics</a><ul>
+<li><a class="reference internal" href="#llvm-returnaddress-intrinsic" id="id1215">‘<tt class="docutils literal"><span class="pre">llvm.returnaddress</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id356" id="id1216">Syntax:</a></li>
+<li><a class="reference internal" href="#id357" id="id1217">Overview:</a></li>
+<li><a class="reference internal" href="#id358" id="id1218">Arguments:</a></li>
+<li><a class="reference internal" href="#id359" id="id1219">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-frameaddress-intrinsic" id="id1220">‘<tt class="docutils literal"><span class="pre">llvm.frameaddress</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id360" id="id1221">Syntax:</a></li>
+<li><a class="reference internal" href="#id361" id="id1222">Overview:</a></li>
+<li><a class="reference internal" href="#id362" id="id1223">Arguments:</a></li>
+<li><a class="reference internal" href="#id363" id="id1224">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-localescape-and-llvm-localrecover-intrinsics" id="id1225">‘<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="#id364" id="id1226">Syntax:</a></li>
+<li><a class="reference internal" href="#id365" id="id1227">Overview:</a></li>
+<li><a class="reference internal" href="#id366" id="id1228">Arguments:</a></li>
+<li><a class="reference internal" href="#id367" id="id1229">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-read-register-and-llvm-write-register-intrinsics" id="id1230">‘<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="#id368" id="id1231">Syntax:</a></li>
+<li><a class="reference internal" href="#id369" id="id1232">Overview:</a></li>
+<li><a class="reference internal" href="#id370" id="id1233">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-stacksave-intrinsic" id="id1234">‘<tt class="docutils literal"><span class="pre">llvm.stacksave</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id371" id="id1235">Syntax:</a></li>
+<li><a class="reference internal" href="#id372" id="id1236">Overview:</a></li>
+<li><a class="reference internal" href="#id373" id="id1237">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-stackrestore-intrinsic" id="id1238">‘<tt class="docutils literal"><span class="pre">llvm.stackrestore</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id374" id="id1239">Syntax:</a></li>
+<li><a class="reference internal" href="#id375" id="id1240">Overview:</a></li>
+<li><a class="reference internal" href="#id376" id="id1241">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-get-dynamic-area-offset-intrinsic" id="id1242">‘<tt class="docutils literal"><span class="pre">llvm.get.dynamic.area.offset</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id377" id="id1243">Syntax:</a></li>
+<li><a class="reference internal" href="#id378" id="id1244">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-prefetch-intrinsic" id="id1245">‘<tt class="docutils literal"><span class="pre">llvm.prefetch</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id379" id="id1246">Syntax:</a></li>
+<li><a class="reference internal" href="#id380" id="id1247">Overview:</a></li>
+<li><a class="reference internal" href="#id381" id="id1248">Arguments:</a></li>
+<li><a class="reference internal" href="#id382" id="id1249">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-pcmarker-intrinsic" id="id1250">‘<tt class="docutils literal"><span class="pre">llvm.pcmarker</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id383" id="id1251">Syntax:</a></li>
+<li><a class="reference internal" href="#id384" id="id1252">Overview:</a></li>
+<li><a class="reference internal" href="#id385" id="id1253">Arguments:</a></li>
+<li><a class="reference internal" href="#id386" id="id1254">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-readcyclecounter-intrinsic" id="id1255">‘<tt class="docutils literal"><span class="pre">llvm.readcyclecounter</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id387" id="id1256">Syntax:</a></li>
+<li><a class="reference internal" href="#id388" id="id1257">Overview:</a></li>
+<li><a class="reference internal" href="#id389" id="id1258">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-clear-cache-intrinsic" id="id1259">‘<tt class="docutils literal"><span class="pre">llvm.clear_cache</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id390" id="id1260">Syntax:</a></li>
+<li><a class="reference internal" href="#id391" id="id1261">Overview:</a></li>
+<li><a class="reference internal" href="#id392" id="id1262">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-instrprof-increment-intrinsic" id="id1263">‘<tt class="docutils literal"><span class="pre">llvm.instrprof_increment</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id393" id="id1264">Syntax:</a></li>
+<li><a class="reference internal" href="#id394" id="id1265">Overview:</a></li>
+<li><a class="reference internal" href="#id395" id="id1266">Arguments:</a></li>
+<li><a class="reference internal" href="#id396" id="id1267">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-instrprof-value-profile-intrinsic" id="id1268">‘<tt class="docutils literal"><span class="pre">llvm.instrprof_value_profile</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id397" id="id1269">Syntax:</a></li>
+<li><a class="reference internal" href="#id398" id="id1270">Overview:</a></li>
+<li><a class="reference internal" href="#id399" id="id1271">Arguments:</a></li>
+<li><a class="reference internal" href="#id400" id="id1272">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-thread-pointer-intrinsic" id="id1273">‘<tt class="docutils literal"><span class="pre">llvm.thread.pointer</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id401" id="id1274">Syntax:</a></li>
+<li><a class="reference internal" href="#id402" id="id1275">Overview:</a></li>
+<li><a class="reference internal" href="#id403" id="id1276">Semantics:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#standard-c-library-intrinsics" id="id1277">Standard C Library Intrinsics</a><ul>
+<li><a class="reference internal" href="#llvm-memcpy-intrinsic" id="id1278">‘<tt class="docutils literal"><span class="pre">llvm.memcpy</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id404" id="id1279">Syntax:</a></li>
+<li><a class="reference internal" href="#id405" id="id1280">Overview:</a></li>
+<li><a class="reference internal" href="#id406" id="id1281">Arguments:</a></li>
+<li><a class="reference internal" href="#id407" id="id1282">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-memmove-intrinsic" id="id1283">‘<tt class="docutils literal"><span class="pre">llvm.memmove</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id408" id="id1284">Syntax:</a></li>
+<li><a class="reference internal" href="#id409" id="id1285">Overview:</a></li>
+<li><a class="reference internal" href="#id410" id="id1286">Arguments:</a></li>
+<li><a class="reference internal" href="#id411" id="id1287">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-memset-intrinsics" id="id1288">‘<tt class="docutils literal"><span class="pre">llvm.memset.*</span></tt>‘ Intrinsics</a><ul>
+<li><a class="reference internal" href="#id412" id="id1289">Syntax:</a></li>
+<li><a class="reference internal" href="#id413" id="id1290">Overview:</a></li>
+<li><a class="reference internal" href="#id414" id="id1291">Arguments:</a></li>
+<li><a class="reference internal" href="#id415" id="id1292">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-sqrt-intrinsic" id="id1293">‘<tt class="docutils literal"><span class="pre">llvm.sqrt.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id416" id="id1294">Syntax:</a></li>
+<li><a class="reference internal" href="#id417" id="id1295">Overview:</a></li>
+<li><a class="reference internal" href="#id418" id="id1296">Arguments:</a></li>
+<li><a class="reference internal" href="#id419" id="id1297">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-powi-intrinsic" id="id1298">‘<tt class="docutils literal"><span class="pre">llvm.powi.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id420" id="id1299">Syntax:</a></li>
+<li><a class="reference internal" href="#id421" id="id1300">Overview:</a></li>
+<li><a class="reference internal" href="#id422" id="id1301">Arguments:</a></li>
+<li><a class="reference internal" href="#id423" id="id1302">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-sin-intrinsic" id="id1303">‘<tt class="docutils literal"><span class="pre">llvm.sin.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id424" id="id1304">Syntax:</a></li>
+<li><a class="reference internal" href="#id425" id="id1305">Overview:</a></li>
+<li><a class="reference internal" href="#id426" id="id1306">Arguments:</a></li>
+<li><a class="reference internal" href="#id427" id="id1307">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-cos-intrinsic" id="id1308">‘<tt class="docutils literal"><span class="pre">llvm.cos.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id428" id="id1309">Syntax:</a></li>
+<li><a class="reference internal" href="#id429" id="id1310">Overview:</a></li>
+<li><a class="reference internal" href="#id430" id="id1311">Arguments:</a></li>
+<li><a class="reference internal" href="#id431" id="id1312">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-pow-intrinsic" id="id1313">‘<tt class="docutils literal"><span class="pre">llvm.pow.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id432" id="id1314">Syntax:</a></li>
+<li><a class="reference internal" href="#id433" id="id1315">Overview:</a></li>
+<li><a class="reference internal" href="#id434" id="id1316">Arguments:</a></li>
+<li><a class="reference internal" href="#id435" id="id1317">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-exp-intrinsic" id="id1318">‘<tt class="docutils literal"><span class="pre">llvm.exp.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id436" id="id1319">Syntax:</a></li>
+<li><a class="reference internal" href="#id437" id="id1320">Overview:</a></li>
+<li><a class="reference internal" href="#id438" id="id1321">Arguments:</a></li>
+<li><a class="reference internal" href="#id439" id="id1322">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-exp2-intrinsic" id="id1323">‘<tt class="docutils literal"><span class="pre">llvm.exp2.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id440" id="id1324">Syntax:</a></li>
+<li><a class="reference internal" href="#id441" id="id1325">Overview:</a></li>
+<li><a class="reference internal" href="#id442" id="id1326">Arguments:</a></li>
+<li><a class="reference internal" href="#id443" id="id1327">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-log-intrinsic" id="id1328">‘<tt class="docutils literal"><span class="pre">llvm.log.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id444" id="id1329">Syntax:</a></li>
+<li><a class="reference internal" href="#id445" id="id1330">Overview:</a></li>
+<li><a class="reference internal" href="#id446" id="id1331">Arguments:</a></li>
+<li><a class="reference internal" href="#id447" id="id1332">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-log10-intrinsic" id="id1333">‘<tt class="docutils literal"><span class="pre">llvm.log10.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id448" id="id1334">Syntax:</a></li>
+<li><a class="reference internal" href="#id449" id="id1335">Overview:</a></li>
+<li><a class="reference internal" href="#id450" id="id1336">Arguments:</a></li>
+<li><a class="reference internal" href="#id451" id="id1337">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-log2-intrinsic" id="id1338">‘<tt class="docutils literal"><span class="pre">llvm.log2.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id452" id="id1339">Syntax:</a></li>
+<li><a class="reference internal" href="#id453" id="id1340">Overview:</a></li>
+<li><a class="reference internal" href="#id454" id="id1341">Arguments:</a></li>
+<li><a class="reference internal" href="#id455" id="id1342">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-fma-intrinsic" id="id1343">‘<tt class="docutils literal"><span class="pre">llvm.fma.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id456" id="id1344">Syntax:</a></li>
+<li><a class="reference internal" href="#id457" id="id1345">Overview:</a></li>
+<li><a class="reference internal" href="#id458" id="id1346">Arguments:</a></li>
+<li><a class="reference internal" href="#id459" id="id1347">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-fabs-intrinsic" id="id1348">‘<tt class="docutils literal"><span class="pre">llvm.fabs.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id460" id="id1349">Syntax:</a></li>
+<li><a class="reference internal" href="#id461" id="id1350">Overview:</a></li>
+<li><a class="reference internal" href="#id462" id="id1351">Arguments:</a></li>
+<li><a class="reference internal" href="#id463" id="id1352">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-minnum-intrinsic" id="id1353">‘<tt class="docutils literal"><span class="pre">llvm.minnum.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id464" id="id1354">Syntax:</a></li>
+<li><a class="reference internal" href="#id465" id="id1355">Overview:</a></li>
+<li><a class="reference internal" href="#id466" id="id1356">Arguments:</a></li>
+<li><a class="reference internal" href="#id467" id="id1357">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-maxnum-intrinsic" id="id1358">‘<tt class="docutils literal"><span class="pre">llvm.maxnum.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id468" id="id1359">Syntax:</a></li>
+<li><a class="reference internal" href="#id469" id="id1360">Overview:</a></li>
+<li><a class="reference internal" href="#id470" id="id1361">Arguments:</a></li>
+<li><a class="reference internal" href="#id471" id="id1362">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-copysign-intrinsic" id="id1363">‘<tt class="docutils literal"><span class="pre">llvm.copysign.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id472" id="id1364">Syntax:</a></li>
+<li><a class="reference internal" href="#id473" id="id1365">Overview:</a></li>
+<li><a class="reference internal" href="#id474" id="id1366">Arguments:</a></li>
+<li><a class="reference internal" href="#id475" id="id1367">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-floor-intrinsic" id="id1368">‘<tt class="docutils literal"><span class="pre">llvm.floor.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id476" id="id1369">Syntax:</a></li>
+<li><a class="reference internal" href="#id477" id="id1370">Overview:</a></li>
+<li><a class="reference internal" href="#id478" id="id1371">Arguments:</a></li>
+<li><a class="reference internal" href="#id479" id="id1372">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-ceil-intrinsic" id="id1373">‘<tt class="docutils literal"><span class="pre">llvm.ceil.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id480" id="id1374">Syntax:</a></li>
+<li><a class="reference internal" href="#id481" id="id1375">Overview:</a></li>
+<li><a class="reference internal" href="#id482" id="id1376">Arguments:</a></li>
+<li><a class="reference internal" href="#id483" id="id1377">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-trunc-intrinsic" id="id1378">‘<tt class="docutils literal"><span class="pre">llvm.trunc.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id484" id="id1379">Syntax:</a></li>
+<li><a class="reference internal" href="#id485" id="id1380">Overview:</a></li>
+<li><a class="reference internal" href="#id486" id="id1381">Arguments:</a></li>
+<li><a class="reference internal" href="#id487" id="id1382">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-rint-intrinsic" id="id1383">‘<tt class="docutils literal"><span class="pre">llvm.rint.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id488" id="id1384">Syntax:</a></li>
+<li><a class="reference internal" href="#id489" id="id1385">Overview:</a></li>
+<li><a class="reference internal" href="#id490" id="id1386">Arguments:</a></li>
+<li><a class="reference internal" href="#id491" id="id1387">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-nearbyint-intrinsic" id="id1388">‘<tt class="docutils literal"><span class="pre">llvm.nearbyint.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id492" id="id1389">Syntax:</a></li>
+<li><a class="reference internal" href="#id493" id="id1390">Overview:</a></li>
+<li><a class="reference internal" href="#id494" id="id1391">Arguments:</a></li>
+<li><a class="reference internal" href="#id495" id="id1392">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-round-intrinsic" id="id1393">‘<tt class="docutils literal"><span class="pre">llvm.round.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id496" id="id1394">Syntax:</a></li>
+<li><a class="reference internal" href="#id497" id="id1395">Overview:</a></li>
+<li><a class="reference internal" href="#id498" id="id1396">Arguments:</a></li>
+<li><a class="reference internal" href="#id499" id="id1397">Semantics:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#bit-manipulation-intrinsics" id="id1398">Bit Manipulation Intrinsics</a><ul>
+<li><a class="reference internal" href="#llvm-bitreverse-intrinsics" id="id1399">‘<tt class="docutils literal"><span class="pre">llvm.bitreverse.*</span></tt>‘ Intrinsics</a><ul>
+<li><a class="reference internal" href="#id500" id="id1400">Syntax:</a></li>
+<li><a class="reference internal" href="#id501" id="id1401">Overview:</a></li>
+<li><a class="reference internal" href="#id502" id="id1402">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-bswap-intrinsics" id="id1403">‘<tt class="docutils literal"><span class="pre">llvm.bswap.*</span></tt>‘ Intrinsics</a><ul>
+<li><a class="reference internal" href="#id503" id="id1404">Syntax:</a></li>
+<li><a class="reference internal" href="#id504" id="id1405">Overview:</a></li>
+<li><a class="reference internal" href="#id505" id="id1406">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-ctpop-intrinsic" id="id1407">‘<tt class="docutils literal"><span class="pre">llvm.ctpop.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id506" id="id1408">Syntax:</a></li>
+<li><a class="reference internal" href="#id507" id="id1409">Overview:</a></li>
+<li><a class="reference internal" href="#id508" id="id1410">Arguments:</a></li>
+<li><a class="reference internal" href="#id509" id="id1411">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-ctlz-intrinsic" id="id1412">‘<tt class="docutils literal"><span class="pre">llvm.ctlz.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id510" id="id1413">Syntax:</a></li>
+<li><a class="reference internal" href="#id511" id="id1414">Overview:</a></li>
+<li><a class="reference internal" href="#id512" id="id1415">Arguments:</a></li>
+<li><a class="reference internal" href="#id513" id="id1416">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-cttz-intrinsic" id="id1417">‘<tt class="docutils literal"><span class="pre">llvm.cttz.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id514" id="id1418">Syntax:</a></li>
+<li><a class="reference internal" href="#id515" id="id1419">Overview:</a></li>
+<li><a class="reference internal" href="#id516" id="id1420">Arguments:</a></li>
+<li><a class="reference internal" href="#id517" id="id1421">Semantics:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#arithmetic-with-overflow-intrinsics" id="id1422">Arithmetic with Overflow Intrinsics</a><ul>
+<li><a class="reference internal" href="#llvm-sadd-with-overflow-intrinsics" id="id1423">‘<tt class="docutils literal"><span class="pre">llvm.sadd.with.overflow.*</span></tt>‘ Intrinsics</a><ul>
+<li><a class="reference internal" href="#id518" id="id1424">Syntax:</a></li>
+<li><a class="reference internal" href="#id519" id="id1425">Overview:</a></li>
+<li><a class="reference internal" href="#id520" id="id1426">Arguments:</a></li>
+<li><a class="reference internal" href="#id521" id="id1427">Semantics:</a></li>
+<li><a class="reference internal" href="#id522" id="id1428">Examples:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-uadd-with-overflow-intrinsics" id="id1429">‘<tt class="docutils literal"><span class="pre">llvm.uadd.with.overflow.*</span></tt>‘ Intrinsics</a><ul>
+<li><a class="reference internal" href="#id523" id="id1430">Syntax:</a></li>
+<li><a class="reference internal" href="#id524" id="id1431">Overview:</a></li>
+<li><a class="reference internal" href="#id525" id="id1432">Arguments:</a></li>
+<li><a class="reference internal" href="#id526" id="id1433">Semantics:</a></li>
+<li><a class="reference internal" href="#id527" id="id1434">Examples:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-ssub-with-overflow-intrinsics" id="id1435">‘<tt class="docutils literal"><span class="pre">llvm.ssub.with.overflow.*</span></tt>‘ Intrinsics</a><ul>
+<li><a class="reference internal" href="#id528" id="id1436">Syntax:</a></li>
+<li><a class="reference internal" href="#id529" id="id1437">Overview:</a></li>
+<li><a class="reference internal" href="#id530" id="id1438">Arguments:</a></li>
+<li><a class="reference internal" href="#id531" id="id1439">Semantics:</a></li>
+<li><a class="reference internal" href="#id532" id="id1440">Examples:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-usub-with-overflow-intrinsics" id="id1441">‘<tt class="docutils literal"><span class="pre">llvm.usub.with.overflow.*</span></tt>‘ Intrinsics</a><ul>
+<li><a class="reference internal" href="#id533" id="id1442">Syntax:</a></li>
+<li><a class="reference internal" href="#id534" id="id1443">Overview:</a></li>
+<li><a class="reference internal" href="#id535" id="id1444">Arguments:</a></li>
+<li><a class="reference internal" href="#id536" id="id1445">Semantics:</a></li>
+<li><a class="reference internal" href="#id537" id="id1446">Examples:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-smul-with-overflow-intrinsics" id="id1447">‘<tt class="docutils literal"><span class="pre">llvm.smul.with.overflow.*</span></tt>‘ Intrinsics</a><ul>
+<li><a class="reference internal" href="#id538" id="id1448">Syntax:</a></li>
+<li><a class="reference internal" href="#id539" id="id1449">Overview:</a></li>
+<li><a class="reference internal" href="#id540" id="id1450">Arguments:</a></li>
+<li><a class="reference internal" href="#id541" id="id1451">Semantics:</a></li>
+<li><a class="reference internal" href="#id542" id="id1452">Examples:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-umul-with-overflow-intrinsics" id="id1453">‘<tt class="docutils literal"><span class="pre">llvm.umul.with.overflow.*</span></tt>‘ Intrinsics</a><ul>
+<li><a class="reference internal" href="#id543" id="id1454">Syntax:</a></li>
+<li><a class="reference internal" href="#id544" id="id1455">Overview:</a></li>
+<li><a class="reference internal" href="#id545" id="id1456">Arguments:</a></li>
+<li><a class="reference internal" href="#id546" id="id1457">Semantics:</a></li>
+<li><a class="reference internal" href="#id547" id="id1458">Examples:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#specialised-arithmetic-intrinsics" id="id1459">Specialised Arithmetic Intrinsics</a><ul>
+<li><a class="reference internal" href="#llvm-canonicalize-intrinsic" id="id1460">‘<tt class="docutils literal"><span class="pre">llvm.canonicalize.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id548" id="id1461">Syntax:</a></li>
+<li><a class="reference internal" href="#id549" id="id1462">Overview:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-fmuladd-intrinsic" id="id1463">‘<tt class="docutils literal"><span class="pre">llvm.fmuladd.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id550" id="id1464">Syntax:</a></li>
+<li><a class="reference internal" href="#id551" id="id1465">Overview:</a></li>
+<li><a class="reference internal" href="#id552" id="id1466">Arguments:</a></li>
+<li><a class="reference internal" href="#id553" id="id1467">Semantics:</a></li>
+<li><a class="reference internal" href="#id554" id="id1468">Examples:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#half-precision-floating-point-intrinsics" id="id1469">Half Precision Floating Point Intrinsics</a><ul>
+<li><a class="reference internal" href="#llvm-convert-to-fp16-intrinsic" id="id1470">‘<tt class="docutils literal"><span class="pre">llvm.convert.to.fp16</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id555" id="id1471">Syntax:</a></li>
+<li><a class="reference internal" href="#id556" id="id1472">Overview:</a></li>
+<li><a class="reference internal" href="#id557" id="id1473">Arguments:</a></li>
+<li><a class="reference internal" href="#id558" id="id1474">Semantics:</a></li>
+<li><a class="reference internal" href="#id559" id="id1475">Examples:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-convert-from-fp16-intrinsic" id="id1476">‘<tt class="docutils literal"><span class="pre">llvm.convert.from.fp16</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id560" id="id1477">Syntax:</a></li>
+<li><a class="reference internal" href="#id561" id="id1478">Overview:</a></li>
+<li><a class="reference internal" href="#id562" id="id1479">Arguments:</a></li>
+<li><a class="reference internal" href="#id563" id="id1480">Semantics:</a></li>
+<li><a class="reference internal" href="#id564" id="id1481">Examples:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#debugger-intrinsics" id="id1482">Debugger Intrinsics</a></li>
+<li><a class="reference internal" href="#exception-handling-intrinsics" id="id1483">Exception Handling Intrinsics</a></li>
+<li><a class="reference internal" href="#trampoline-intrinsics" id="id1484">Trampoline Intrinsics</a><ul>
+<li><a class="reference internal" href="#llvm-init-trampoline-intrinsic" id="id1485">‘<tt class="docutils literal"><span class="pre">llvm.init.trampoline</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id565" id="id1486">Syntax:</a></li>
+<li><a class="reference internal" href="#id566" id="id1487">Overview:</a></li>
+<li><a class="reference internal" href="#id567" id="id1488">Arguments:</a></li>
+<li><a class="reference internal" href="#id568" id="id1489">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-adjust-trampoline-intrinsic" id="id1490">‘<tt class="docutils literal"><span class="pre">llvm.adjust.trampoline</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id569" id="id1491">Syntax:</a></li>
+<li><a class="reference internal" href="#id570" id="id1492">Overview:</a></li>
+<li><a class="reference internal" href="#id571" id="id1493">Arguments:</a></li>
+<li><a class="reference internal" href="#id572" id="id1494">Semantics:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#masked-vector-load-and-store-intrinsics" id="id1495">Masked Vector Load and Store Intrinsics</a><ul>
+<li><a class="reference internal" href="#llvm-masked-load-intrinsics" id="id1496">‘<tt class="docutils literal"><span class="pre">llvm.masked.load.*</span></tt>‘ Intrinsics</a><ul>
+<li><a class="reference internal" href="#id573" id="id1497">Syntax:</a></li>
+<li><a class="reference internal" href="#id574" id="id1498">Overview:</a></li>
+<li><a class="reference internal" href="#id575" id="id1499">Arguments:</a></li>
+<li><a class="reference internal" href="#id576" id="id1500">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-masked-store-intrinsics" id="id1501">‘<tt class="docutils literal"><span class="pre">llvm.masked.store.*</span></tt>‘ Intrinsics</a><ul>
+<li><a class="reference internal" href="#id577" id="id1502">Syntax:</a></li>
+<li><a class="reference internal" href="#id578" id="id1503">Overview:</a></li>
+<li><a class="reference internal" href="#id579" id="id1504">Arguments:</a></li>
+<li><a class="reference internal" href="#id580" id="id1505">Semantics:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#masked-vector-gather-and-scatter-intrinsics" id="id1506">Masked Vector Gather and Scatter Intrinsics</a><ul>
+<li><a class="reference internal" href="#llvm-masked-gather-intrinsics" id="id1507">‘<tt class="docutils literal"><span class="pre">llvm.masked.gather.*</span></tt>‘ Intrinsics</a><ul>
+<li><a class="reference internal" href="#id581" id="id1508">Syntax:</a></li>
+<li><a class="reference internal" href="#id582" id="id1509">Overview:</a></li>
+<li><a class="reference internal" href="#id583" id="id1510">Arguments:</a></li>
+<li><a class="reference internal" href="#id584" id="id1511">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-masked-scatter-intrinsics" id="id1512">‘<tt class="docutils literal"><span class="pre">llvm.masked.scatter.*</span></tt>‘ Intrinsics</a><ul>
+<li><a class="reference internal" href="#id585" id="id1513">Syntax:</a></li>
+<li><a class="reference internal" href="#id586" id="id1514">Overview:</a></li>
+<li><a class="reference internal" href="#id587" id="id1515">Arguments:</a></li>
+<li><a class="reference internal" href="#id588" id="id1516">Semantics:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#memory-use-markers" id="id1517">Memory Use Markers</a><ul>
+<li><a class="reference internal" href="#llvm-lifetime-start-intrinsic" id="id1518">‘<tt class="docutils literal"><span class="pre">llvm.lifetime.start</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id589" id="id1519">Syntax:</a></li>
+<li><a class="reference internal" href="#id590" id="id1520">Overview:</a></li>
+<li><a class="reference internal" href="#id591" id="id1521">Arguments:</a></li>
+<li><a class="reference internal" href="#id592" id="id1522">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-lifetime-end-intrinsic" id="id1523">‘<tt class="docutils literal"><span class="pre">llvm.lifetime.end</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id593" id="id1524">Syntax:</a></li>
+<li><a class="reference internal" href="#id594" id="id1525">Overview:</a></li>
+<li><a class="reference internal" href="#id595" id="id1526">Arguments:</a></li>
+<li><a class="reference internal" href="#id596" id="id1527">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-invariant-start-intrinsic" id="id1528">‘<tt class="docutils literal"><span class="pre">llvm.invariant.start</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id597" id="id1529">Syntax:</a></li>
+<li><a class="reference internal" href="#id598" id="id1530">Overview:</a></li>
+<li><a class="reference internal" href="#id599" id="id1531">Arguments:</a></li>
+<li><a class="reference internal" href="#id600" id="id1532">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-invariant-end-intrinsic" id="id1533">‘<tt class="docutils literal"><span class="pre">llvm.invariant.end</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id601" id="id1534">Syntax:</a></li>
+<li><a class="reference internal" href="#id602" id="id1535">Overview:</a></li>
+<li><a class="reference internal" href="#id603" id="id1536">Arguments:</a></li>
+<li><a class="reference internal" href="#id604" id="id1537">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-invariant-group-barrier-intrinsic" id="id1538">‘<tt class="docutils literal"><span class="pre">llvm.invariant.group.barrier</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id605" id="id1539">Syntax:</a></li>
+<li><a class="reference internal" href="#id606" id="id1540">Overview:</a></li>
+<li><a class="reference internal" href="#id607" id="id1541">Arguments:</a></li>
+<li><a class="reference internal" href="#id608" id="id1542">Semantics:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#general-intrinsics" id="id1543">General Intrinsics</a><ul>
+<li><a class="reference internal" href="#llvm-var-annotation-intrinsic" id="id1544">‘<tt class="docutils literal"><span class="pre">llvm.var.annotation</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id609" id="id1545">Syntax:</a></li>
+<li><a class="reference internal" href="#id610" id="id1546">Overview:</a></li>
+<li><a class="reference internal" href="#id611" id="id1547">Arguments:</a></li>
+<li><a class="reference internal" href="#id612" id="id1548">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-ptr-annotation-intrinsic" id="id1549">‘<tt class="docutils literal"><span class="pre">llvm.ptr.annotation.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id613" id="id1550">Syntax:</a></li>
+<li><a class="reference internal" href="#id614" id="id1551">Overview:</a></li>
+<li><a class="reference internal" href="#id615" id="id1552">Arguments:</a></li>
+<li><a class="reference internal" href="#id616" id="id1553">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-annotation-intrinsic" id="id1554">‘<tt class="docutils literal"><span class="pre">llvm.annotation.*</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id617" id="id1555">Syntax:</a></li>
+<li><a class="reference internal" href="#id618" id="id1556">Overview:</a></li>
+<li><a class="reference internal" href="#id619" id="id1557">Arguments:</a></li>
+<li><a class="reference internal" href="#id620" id="id1558">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-trap-intrinsic" id="id1559">‘<tt class="docutils literal"><span class="pre">llvm.trap</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id621" id="id1560">Syntax:</a></li>
+<li><a class="reference internal" href="#id622" id="id1561">Overview:</a></li>
+<li><a class="reference internal" href="#id623" id="id1562">Arguments:</a></li>
+<li><a class="reference internal" href="#id624" id="id1563">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-debugtrap-intrinsic" id="id1564">‘<tt class="docutils literal"><span class="pre">llvm.debugtrap</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id625" id="id1565">Syntax:</a></li>
+<li><a class="reference internal" href="#id626" id="id1566">Overview:</a></li>
+<li><a class="reference internal" href="#id627" id="id1567">Arguments:</a></li>
+<li><a class="reference internal" href="#id628" id="id1568">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-stackprotector-intrinsic" id="id1569">‘<tt class="docutils literal"><span class="pre">llvm.stackprotector</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id629" id="id1570">Syntax:</a></li>
+<li><a class="reference internal" href="#id630" id="id1571">Overview:</a></li>
+<li><a class="reference internal" href="#id631" id="id1572">Arguments:</a></li>
+<li><a class="reference internal" href="#id632" id="id1573">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-stackguard-intrinsic" id="id1574">‘<tt class="docutils literal"><span class="pre">llvm.stackguard</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id633" id="id1575">Syntax:</a></li>
+<li><a class="reference internal" href="#id634" id="id1576">Overview:</a></li>
+<li><a class="reference internal" href="#id635" id="id1577">Arguments:</a></li>
+<li><a class="reference internal" href="#id636" id="id1578">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-objectsize-intrinsic" id="id1579">‘<tt class="docutils literal"><span class="pre">llvm.objectsize</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id637" id="id1580">Syntax:</a></li>
+<li><a class="reference internal" href="#id638" id="id1581">Overview:</a></li>
+<li><a class="reference internal" href="#id639" id="id1582">Arguments:</a></li>
+<li><a class="reference internal" href="#id640" id="id1583">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-expect-intrinsic" id="id1584">‘<tt class="docutils literal"><span class="pre">llvm.expect</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id641" id="id1585">Syntax:</a></li>
+<li><a class="reference internal" href="#id642" id="id1586">Overview:</a></li>
+<li><a class="reference internal" href="#id643" id="id1587">Arguments:</a></li>
+<li><a class="reference internal" href="#id644" id="id1588">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-assume-intrinsic" id="id1589">‘<tt class="docutils literal"><span class="pre">llvm.assume</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id645" id="id1590">Syntax:</a></li>
+<li><a class="reference internal" href="#id646" id="id1591">Overview:</a></li>
+<li><a class="reference internal" href="#id647" id="id1592">Arguments:</a></li>
+<li><a class="reference internal" href="#id648" id="id1593">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-type-test-intrinsic" id="id1594">‘<tt class="docutils literal"><span class="pre">llvm.type.test</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id649" id="id1595">Syntax:</a></li>
+<li><a class="reference internal" href="#id650" id="id1596">Arguments:</a></li>
+<li><a class="reference internal" href="#id651" id="id1597">Overview:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-type-checked-load-intrinsic" id="id1598">‘<tt class="docutils literal"><span class="pre">llvm.type.checked.load</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id652" id="id1599">Syntax:</a></li>
+<li><a class="reference internal" href="#id653" id="id1600">Arguments:</a></li>
+<li><a class="reference internal" href="#id654" id="id1601">Overview:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-donothing-intrinsic" id="id1602">‘<tt class="docutils literal"><span class="pre">llvm.donothing</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id655" id="id1603">Syntax:</a></li>
+<li><a class="reference internal" href="#id656" id="id1604">Overview:</a></li>
+<li><a class="reference internal" href="#id657" id="id1605">Arguments:</a></li>
+<li><a class="reference internal" href="#id658" id="id1606">Semantics:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-deoptimize-intrinsic" id="id1607">‘<tt class="docutils literal"><span class="pre">llvm.experimental.deoptimize</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id659" id="id1608">Syntax:</a></li>
+<li><a class="reference internal" href="#id660" id="id1609">Overview:</a></li>
+<li><a class="reference internal" href="#id661" id="id1610">Arguments:</a></li>
+<li><a class="reference internal" href="#id662" id="id1611">Semantics:</a></li>
+<li><a class="reference internal" href="#lowering" id="id1612">Lowering:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-experimental-guard-intrinsic" id="id1613">‘<tt class="docutils literal"><span class="pre">llvm.experimental.guard</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id663" id="id1614">Syntax:</a></li>
+<li><a class="reference internal" href="#id664" id="id1615">Overview:</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#llvm-load-relative-intrinsic" id="id1616">‘<tt class="docutils literal"><span class="pre">llvm.load.relative</span></tt>‘ Intrinsic</a><ul>
+<li><a class="reference internal" href="#id665" id="id1617">Syntax:</a></li>
+<li><a class="reference internal" href="#id666" id="id1618">Overview:</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#stack-map-intrinsics" id="id1619">Stack Map Intrinsics</a></li>
+</ul>
+</li>
+</ul>
+</div>
+<div class="section" id="abstract">
+<h2><a class="toc-backref" href="#id667">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="#id668">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="#id669">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="#id670">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="#id671">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="#id672">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"><div class="highlight"><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>
+</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="#id673">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 an 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="#id674">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="#id675">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="#id676">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="#id677">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="structure-types">
+<span id="namedtypes"></span><h3><a class="toc-backref" href="#id678">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="global-variables">
+<span id="globalvars"></span><h3><a class="toc-backref" href="#id679">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.</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>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> 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"><div class="highlight"><pre>@<GlobalVarName> = [Linkage] [Visibility] [DLLStorageClass] [ThreadLocal]
+                   [(unnamed_addr|local_unnamed_addr)] [AddrSpace]
+                   [ExternallyInitialized]
+                   <global | constant> <Type> [<InitializerConstant>]
+                   [, section "name"] [, comdat [($name)]]
+                   [, align <Alignment>] (, !name !N)*
+</pre></div>
+</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"><div class="highlight"><pre>@G = thread_local(initialexec) global i32 0, align 4
+</pre></div>
+</div>
+</div>
+<div class="section" id="functions">
+<span id="functionstructure"></span><h3><a class="toc-backref" href="#id680">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="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"><div class="highlight"><pre>define [linkage] [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>
+</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"><div class="highlight"><pre><type> [parameter Attrs] [name]
+</pre></div>
+</div>
+</div>
+<div class="section" id="aliases">
+<span id="langref-aliases"></span><h3><a class="toc-backref" href="#id681">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="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"><div class="highlight"><pre>@<Name> = [Linkage] [Visibility] [DLLStorageClass] [ThreadLocal] [(unnamed_addr|local_unnamed_addr)] alias <AliaseeTy>, <AliaseeTy>* @<Aliasee>
+</pre></div>
+</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="#id682">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"><div class="highlight"><pre>@<Name> = [Linkage] [Visibility] ifunc <IFuncTy>, <ResolverTy>* @<Resolver>
+</pre></div>
+</div>
+</div>
+<div class="section" id="comdats">
+<span id="langref-comdats"></span><h3><a class="toc-backref" href="#id683">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"><div class="highlight"><pre>$<Name> = comdat SelectionKind
+</pre></div>
+</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="#id684">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"><div class="highlight"><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>
+<div class="section" id="parameter-attributes">
+<span id="paramattrs"></span><h3><a class="toc-backref" href="#id685">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 may only be applied to
+the first parameter. 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. 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="#id686">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="#id687">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"><div class="highlight"><pre>define void @f() prefix i32 123 { ... }
+</pre></div>
+</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="#id688">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="#id689">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="#id690">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"><div class="highlight"><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>
+<div class="section" id="function-attributes">
+<span id="fnattrs"></span><h3><a class="toc-backref" href="#id691">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">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">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 that it cannot unwind exceptions by calling
+the <tt class="docutils literal"><span class="pre">C++</span></tt> exception throwing methods.</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. It cannot
+unwind an exception by calling the <tt class="docutils literal"><span class="pre">C++</span></tt> exception throwing
+methods.</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">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">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">"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="operand-bundles">
+<span id="opbundles"></span><h3><a class="toc-backref" href="#id692">Operand Bundles</a><a class="headerlink" href="#operand-bundles" title="Permalink to this headline">¶</a></h3>
+<p>Note: operand bundles are a work in progress, and they should be
+considered experimental at this time.</p>
+<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"><div class="highlight"><pre>operand bundle set ::= '[' operand bundle (, operand bundle )* ']'
+operand bundle ::= tag '(' [ bundle operand ] (, bundle operand )* ')'
+bundle operand ::= SSA value
+tag ::= string constant
+</pre></div>
+</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="#id693">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="#id694">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="#id695">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="#id696">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="#id697">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">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>
+</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="#id698">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="#id699">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 <tt class="docutils literal"><span class="pre">getelementptr</span></tt> operation is <em>based</em>
+on the first value 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="#id700">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="#id701">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="#id702">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="singlethread">If an atomic operation is marked <tt class="docutils literal"><span class="pre">singlethread</span></tt>, it only <em>synchronizes
+with</em> or participates in modification and seq_cst total orderings with
+other operations running in the same thread (for example, in signal
+handlers).</p>
+</div>
+<div class="section" id="fast-math-flags">
+<span id="fastmath"></span><h3><a class="toc-backref" href="#id703">Fast-Math Flags</a><a class="headerlink" href="#fast-math-flags" title="Permalink to this headline">¶</a></h3>
+<p>LLVM IR floating-point binary ops (<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>) have the following flags that can
+be set to enable otherwise unsafe floating point operations</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">fast</span></tt></dt>
+<dd>Fast - Allow algebraically equivalent transformations that may
+dramatically change results in floating point (e.g. reassociate). This
+flag implies all the others.</dd>
+</dl>
+</div>
+<div class="section" id="use-list-order-directives">
+<span id="uselistorder"></span><h3><a class="toc-backref" href="#id704">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"><div class="highlight"><pre>uselistorder <ty> <value>, { <order-indexes> }
+uselistorder_bb @function, %block { <order-indexes> }
+</pre></div>
+</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"><div class="highlight"><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>
+<div class="section" id="source-filename">
+<span id="id3"></span><h3><a class="toc-backref" href="#id705">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="#id706">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="#id707">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="#id708">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"><div class="highlight"><pre><returntype> (<parameter list>)
+</pre></div>
+</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="#id709">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="#id710">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="#id711">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="#id712">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="#id713">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="#id714">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"><div class="highlight"><pre><type> *
+</pre></div>
+</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="#id715">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"><div class="highlight"><pre>< <# elements> x <elementtype> >
+</pre></div>
+</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="#id716">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="#id717">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="#id718">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="#id719">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="#id720">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"><div class="highlight"><pre>[<# elements> x <elementtype>]
+</pre></div>
+</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="#id721">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"><div class="highlight"><pre>%T1 = type { <type list> }     ; Identified normal struct type
+%T2 = type <{ <type list> }>   ; Identified packed struct type
+</pre></div>
+</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="#id722">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"><div class="highlight"><pre>%X = type opaque
+%52 = type opaque
+</pre></div>
+</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="#id723">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="#id724">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="#id725">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="#id726">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="#id727">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">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="#id728">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="#id729">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="#id730">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>Truncate a constant to another type. The bit size of CST must be
+larger than the bit size of TYPE. Both types must be integers.</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>Zero extend a constant to another type. The bit size of CST must be
+smaller than the bit size of TYPE. Both types must be integers.</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>Sign extend a constant to another type. The bit size of CST must be
+smaller than the bit size of TYPE. Both types must be integers.</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>Convert a pointer typed constant to the corresponding integer
+constant. <tt class="docutils literal"><span class="pre">TYPE</span></tt> must be an integer type. <tt class="docutils literal"><span class="pre">CST</span></tt> must be of
+pointer type. The <tt class="docutils literal"><span class="pre">CST</span></tt> value is zero extended, truncated, or
+unchanged to make it fit in <tt class="docutils literal"><span class="pre">TYPE</span></tt>.</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>Convert an integer constant to a pointer constant. TYPE must be a
+pointer type. CST must be of integer type. The CST value is zero
+extended, truncated, or unchanged to make it fit in a pointer size.
+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 zero 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>Performs 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>Performs 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="#id731">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="#id732">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’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"><div class="highlight"><pre>call void asm alignstack "eieio", ""()
+</pre></div>
+</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"><div class="highlight"><pre>call void asm inteldialect "eieio", ""()
+</pre></div>
+</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="#id733">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="#id734">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="#id735">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="#id736">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="#id737">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>
+</div>
+<div class="section" id="constraint-codes">
+<h5><a class="toc-backref" href="#id738">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="#id739">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>
+</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="#id740">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="#id741">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="#id742">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="#id743">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 <tt class="docutils literal"><span class="pre">llvm.dbg.value</span></tt>
+function is using two 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="k">i64</span> <span class="m">0</span><span class="p">,</span> <span class="kt">metadata</span> <span class="nv-Anonymous">!25</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 definition. Here metadata <tt class="docutils literal"><span class="pre">!22</span></tt>
+is attached to the <tt class="docutils literal"><span class="pre">foo</span></tt> function 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">define</span> <span class="kt">void</span> <span class="vg">@foo</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>
+</pre></div>
+</div>
+<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="#id744">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="#id745">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">subprograms:</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).</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, subprograms: !4,
+                    globals: !5, imports: !6, macros: !7, 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 <tt class="docutils literal"><span class="pre">!llvm.dbg.cu</span></tt>. They
+keep track of subprograms, 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="#id746">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-llvm"><div class="highlight"><pre><span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="nv">!DIFile</span><span class="p">(</span><span class="nl">filename:</span> <span class="s">"path/to/file"</span><span class="p">,</span> <span class="nl">directory:</span> <span class="s">"/path/to/dir"</span><span class="p">)</span>
+</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.</p>
+</div>
+<div class="section" id="dibasictype">
+<span id="id8"></span><h5><a class="toc-backref" href="#id747">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="#id748">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="#id749">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
+</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> and <tt class="docutils literal"><span class="pre">DW_TAG_restrict_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="#id750">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="#id751">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"><div class="highlight"><pre><span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="nv">!DISubrange</span><span class="p">(</span><span class="nl">count:</span> <span class="m">5</span><span class="p">,</span> <span class="nl">lowerBound:</span> <span class="m">0</span><span class="p">)</span> <span class="c">; array counting from 0</span>
+<span class="nv-Anonymous">!1</span> <span class="p">=</span> <span class="nv">!DISubrange</span><span class="p">(</span><span class="nl">count:</span> <span class="m">5</span><span class="p">,</span> <span class="nl">lowerBound:</span> <span class="m">1</span><span class="p">)</span> <span class="c">; array counting from 1</span>
+<span class="nv-Anonymous">!2</span> <span class="p">=</span> <span class="nv">!DISubrange</span><span class="p">(</span><span class="nl">count:</span> <span class="m">-1</span><span class="p">)</span> <span class="c">; empty array.</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="dienumerator">
+<span id="id13"></span><h5><a class="toc-backref" href="#id752">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"><div class="highlight"><pre><span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="nv">!DIEnumerator</span><span class="p">(</span><span class="nl">name:</span> <span class="s">"SixKind"</span><span class="p">,</span> <span class="nl">value:</span> <span class="m">7</span><span class="p">)</span>
+<span class="nv-Anonymous">!1</span> <span class="p">=</span> <span class="nv">!DIEnumerator</span><span class="p">(</span><span class="nl">name:</span> <span class="s">"SevenKind"</span><span class="p">,</span> <span class="nl">value:</span> <span class="m">7</span><span class="p">)</span>
+<span class="nv-Anonymous">!2</span> <span class="p">=</span> <span class="nv">!DIEnumerator</span><span class="p">(</span><span class="nl">name:</span> <span class="s">"NegEightKind"</span><span class="p">,</span> <span class="nl">value:</span> <span class="m">-8</span><span class="p">)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="ditemplatetypeparameter">
+<h5><a class="toc-backref" href="#id753">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"><div class="highlight"><pre><span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="nv">!DITemplateTypeParameter</span><span class="p">(</span><span class="nl">name:</span> <span class="s">"Ty"</span><span class="p">,</span> <span class="nl">type:</span> <span class="nv-Anonymous">!1</span><span class="p">)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="ditemplatevalueparameter">
+<h5><a class="toc-backref" href="#id754">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"><div class="highlight"><pre><span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="nv">!DITemplateValueParameter</span><span class="p">(</span><span class="nl">name:</span> <span class="s">"Ty"</span><span class="p">,</span> <span class="nl">type:</span> <span class="nv-Anonymous">!1</span><span class="p">,</span> <span class="nl">value:</span> <span class="k">i32</span> <span class="m">7</span><span class="p">)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="dinamespace">
+<h5><a class="toc-backref" href="#id755">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"><div class="highlight"><pre><span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="nv">!DINamespace</span><span class="p">(</span><span class="nl">name:</span> <span class="s">"myawesomeproject"</span><span class="p">,</span> <span class="nl">scope:</span> <span class="nv-Anonymous">!1</span><span class="p">,</span> <span class="nl">file:</span> <span class="nv-Anonymous">!2</span><span class="p">,</span> <span class="nl">line:</span> <span class="m">7</span><span class="p">)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="diglobalvariable">
+<h5><a class="toc-backref" href="#id756">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"><div class="highlight"><pre><span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="nv">!DIGlobalVariable</span><span class="p">(</span><span class="nl">name:</span> <span class="s">"foo"</span><span class="p">,</span> <span class="nl">linkageName:</span> <span class="s">"foo"</span><span class="p">,</span> <span class="nl">scope:</span> <span class="nv-Anonymous">!1</span><span class="p">,</span>
+                       <span class="nl">file:</span> <span class="nv-Anonymous">!2</span><span class="p">,</span> <span class="nl">line:</span> <span class="m">7</span><span class="p">,</span> <span class="nl">type:</span> <span class="nv-Anonymous">!3</span><span class="p">,</span> <span class="nl">isLocal:</span> <span class="k">true</span><span class="p">,</span>
+                       <span class="nl">isDefinition:</span> <span class="k">false</span><span class="p">,</span> <span class="nl">variable:</span> <span class="k">i32</span><span class="p">*</span> <span class="vg">@foo</span><span class="p">,</span>
+                       <span class="nl">declaration:</span> <span class="nv-Anonymous">!4</span><span class="p">)</span>
+</pre></div>
+</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="#id757">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, templateParams: !5,
+                            declaration: !6, variables: !7)
+</pre></div>
+</div>
+</div>
+<div class="section" id="dilexicalblock">
+<span id="id15"></span><h5><a class="toc-backref" href="#id758">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="#id759">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"><div class="highlight"><pre><span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="nv">!DILexicalBlock</span><span class="p">(</span><span class="nl">scope:</span> <span class="nv-Anonymous">!3</span><span class="p">,</span> <span class="nl">file:</span> <span class="nv-Anonymous">!4</span><span class="p">,</span> <span class="nl">line:</span> <span class="m">7</span><span class="p">,</span> <span class="nl">column:</span> <span class="m">35</span><span class="p">)</span>
+<span class="nv-Anonymous">!1</span> <span class="p">=</span> <span class="nv">!DILexicalBlockFile</span><span class="p">(</span><span class="nl">scope:</span> <span class="nv-Anonymous">!0</span><span class="p">,</span> <span class="nl">file:</span> <span class="nv-Anonymous">!4</span><span class="p">,</span> <span class="nl">discriminator:</span> <span class="m">0</span><span class="p">)</span>
+<span class="nv-Anonymous">!2</span> <span class="p">=</span> <span class="nv">!DILexicalBlockFile</span><span class="p">(</span><span class="nl">scope:</span> <span class="nv-Anonymous">!0</span><span class="p">,</span> <span class="nl">file:</span> <span class="nv-Anonymous">!4</span><span class="p">,</span> <span class="nl">discriminator:</span> <span class="m">1</span><span class="p">)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="dilocation">
+<span id="id17"></span><h5><a class="toc-backref" href="#id760">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"><div class="highlight"><pre><span class="nv-Anonymous">!0</span> <span class="p">=</span> <span class="nv">!DILocation</span><span class="p">(</span><span class="nl">line:</span> <span class="m">2900</span><span class="p">,</span> <span class="nl">column:</span> <span class="m">42</span><span class="p">,</span> <span class="nl">scope:</span> <span class="nv-Anonymous">!1</span><span class="p">,</span> <span class="nl">inlinedAt:</span> <span class="nv-Anonymous">!2</span><span class="p">)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="dilocalvariable">
+<span id="id18"></span><h5><a class="toc-backref" href="#id761">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="#id762">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 DWARF expression sequences. 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>) 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 working expression.</li>
+<li><tt class="docutils literal"><span class="pre">DW_OP_plus,</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_bit_piece,</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 piece from the working expression.</li>
+</ul>
+<div class="highlight-text"><div class="highlight"><pre>!0 = !DIExpression(DW_OP_deref)
+!1 = !DIExpression(DW_OP_plus, 3)
+!2 = !DIExpression(DW_OP_bit_piece, 3, 7)
+!3 = !DIExpression(DW_OP_deref, DW_OP_plus, 3, DW_OP_bit_piece, 3, 7)
+</pre></div>
+</div>
+</div>
+<div class="section" id="diobjcproperty">
+<h5><a class="toc-backref" href="#id763">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"><div class="highlight"><pre><span class="nv-Anonymous">!3</span> <span class="p">=</span> <span class="nv">!DIObjCProperty</span><span class="p">(</span><span class="nl">name:</span> <span class="s">"foo"</span><span class="p">,</span> <span class="nl">file:</span> <span class="nv-Anonymous">!1</span><span class="p">,</span> <span class="nl">line:</span> <span class="m">7</span><span class="p">,</span> <span class="nl">setter:</span> <span class="s">"setFoo"</span><span class="p">,</span>
+                     <span class="nl">getter:</span> <span class="s">"getFoo"</span><span class="p">,</span> <span class="nl">attributes:</span> <span class="m">7</span><span class="p">,</span> <span class="nl">type:</span> <span class="nv-Anonymous">!2</span><span class="p">)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="diimportedentity">
+<h5><a class="toc-backref" href="#id764">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="#id765">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="#id766">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="#id767">‘<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 TBAA. Instead, metadata is added to the IR to
+describe a type system of a higher level language. This can be used to
+implement typical C/C++ TBAA, but it can also be used to implement
+custom alias analysis behavior for other languages.</p>
+<p>The current metadata format is very simple. TBAA metadata nodes have up
+to three fields, e.g.:</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">!"an example type tree"</span> <span class="p">}</span>
+<span class="nv-Anonymous">!1</span> <span class="p">=</span> <span class="p">!{</span> <span class="nv">!"int"</span><span class="p">,</span> <span class="nv-Anonymous">!0</span> <span class="p">}</span>
+<span class="nv-Anonymous">!2</span> <span class="p">=</span> <span class="p">!{</span> <span class="nv">!"float"</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">!"const float"</span><span class="p">,</span> <span class="nv-Anonymous">!2</span><span class="p">,</span> <span class="k">i64</span> <span class="m">1</span> <span class="p">}</span>
+</pre></div>
+</div>
+<p>The first field is an identity field. It can be any value, usually a
+metadata string, which uniquely identifies the type. The most important
+name in the tree is the name of the root node. Two trees with different
+root node names are entirely disjoint, even if they have leaves with
+common names.</p>
+<p>The second field identifies the type’s parent node in the tree, or is
+null or omitted for a root node. A type is considered to alias all of
+its descendants and all of its ancestors in the tree. Also, a type is
+considered to alias all types in other trees, so that bitcode produced
+from multiple front-ends is handled conservatively.</p>
+<p>If the third field is present, it’s an integer which if equal to 1
+indicates that the type 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>).</p>
+</div>
+<div class="section" id="tbaa-struct-metadata">
+<h4><a class="toc-backref" href="#id768">‘<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="#id769">‘<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="#id770">‘<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="#id771">‘<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="unpredictable-metadata">
+<h4><a class="toc-backref" href="#id772">‘<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="#id773">‘<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="#id774">‘<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="#id775">‘<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="#id776">‘<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="#id777">‘<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="#id778">‘<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="#id779">‘<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="#id780">‘<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="#id781">‘<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="#id782">‘<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="#id783">‘<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="#id784">‘<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="#id785">‘<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 atempt 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="#id786">‘<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="#id787">‘<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="invariant-group-metadata">
+<h4><a class="toc-backref" href="#id788">‘<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).</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>
+</div>
+</div>
+</div>
+<div class="section" id="module-flags-metadata">
+<h2><a class="toc-backref" href="#id789">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>
+</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"><div class="highlight"><pre>!{ !"foo", i32 1 }
+</pre></div>
+</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="#id790">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="automatic-linker-flags-module-flags-metadata">
+<h3><a class="toc-backref" href="#id791">Automatic Linker Flags Module Flags Metadata</a><a class="headerlink" href="#automatic-linker-flags-module-flags-metadata" title="Permalink to this headline">¶</a></h3>
+<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 metadata in the module flags section,
+using the <tt class="docutils literal"><span class="pre">Linker</span> <span class="pre">Options</span></tt> key. The merge behavior for this flag is required
+to be <tt class="docutils literal"><span class="pre">AppendUnique</span></tt>, and the value for the key 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"><div class="highlight"><pre>!0 = !{ i32 6, !"Linker Options",
+   !{
+      !{ !"-lz" },
+      !{ !"-framework", !"Cocoa" } } }
+!llvm.module.flags = !{ !0 }
+</pre></div>
+</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="c-type-width-module-flags-metadata">
+<h3><a class="toc-backref" href="#id792">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"><div class="highlight"><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>
+<div class="section" id="intrinsic-global-variables">
+<span id="intrinsicglobalvariables"></span><h2><a class="toc-backref" href="#id793">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="#id794">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="#id795">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="#id796">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="#id797">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="#id798">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="#id799">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="#id800">‘<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="#id801">Syntax:</a><a class="headerlink" href="#syntax" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre>ret <type> <value>       ; Return a value from a non-void function
+ret void                 ; Return from void function
+</pre></div>
+</div>
+</div>
+<div class="section" id="overview">
+<h5><a class="toc-backref" href="#id802">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="#id803">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="semantics">
+<h5><a class="toc-backref" href="#id804">Semantics:</a><a class="headerlink" href="#semantics" 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="#id805">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="#id806">‘<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="id20">
+<h5><a class="toc-backref" href="#id807">Syntax:</a><a class="headerlink" href="#id20" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre>br i1 <cond>, label <iftrue>, label <iffalse>
+br label <dest>          ; Unconditional branch
+</pre></div>
+</div>
+</div>
+<div class="section" id="id21">
+<h5><a class="toc-backref" href="#id808">Overview:</a><a class="headerlink" href="#id21" 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="id22">
+<h5><a class="toc-backref" href="#id809">Arguments:</a><a class="headerlink" href="#id22" 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="id23">
+<h5><a class="toc-backref" href="#id810">Semantics:</a><a class="headerlink" href="#id23" 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="id24">
+<h5><a class="toc-backref" href="#id811">Example:</a><a class="headerlink" href="#id24" 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="#id812">‘<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="id25">
+<h5><a class="toc-backref" href="#id813">Syntax:</a><a class="headerlink" href="#id25" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre>switch <intty> <value>, label <defaultdest> [ <intty> <val>, label <dest> ... ]
+</pre></div>
+</div>
+</div>
+<div class="section" id="id26">
+<h5><a class="toc-backref" href="#id814">Overview:</a><a class="headerlink" href="#id26" 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="id27">
+<h5><a class="toc-backref" href="#id815">Arguments:</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 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="id28">
+<h5><a class="toc-backref" href="#id816">Semantics:</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 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="#id817">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="id29">
+<h5><a class="toc-backref" href="#id818">Example:</a><a class="headerlink" href="#id29" 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="#id819">‘<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="id30">
+<h5><a class="toc-backref" href="#id820">Syntax:</a><a class="headerlink" href="#id30" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre>indirectbr <somety>* <address>, [ label <dest1>, label <dest2>, ... ]
+</pre></div>
+</div>
+</div>
+<div class="section" id="id31">
+<h5><a class="toc-backref" href="#id821">Overview:</a><a class="headerlink" href="#id31" 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="id32">
+<h5><a class="toc-backref" href="#id822">Arguments:</a><a class="headerlink" href="#id32" 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="id33">
+<h5><a class="toc-backref" href="#id823">Semantics:</a><a class="headerlink" href="#id33" 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="id34">
+<h5><a class="toc-backref" href="#id824">Implementation:</a><a class="headerlink" href="#id34" title="Permalink to this headline">¶</a></h5>
+<p>This is typically implemented with a jump through a register.</p>
+</div>
+<div class="section" id="id35">
+<h5><a class="toc-backref" href="#id825">Example:</a><a class="headerlink" href="#id35" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre>indirectbr i8* %Addr, [ label %bb1, label %bb2, label %bb3 ]
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="invoke-instruction">
+<span id="i-invoke"></span><h4><a class="toc-backref" href="#id826">‘<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="id36">
+<h5><a class="toc-backref" href="#id827">Syntax:</a><a class="headerlink" href="#id36" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><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>
+<div class="section" id="id37">
+<h5><a class="toc-backref" href="#id828">Overview:</a><a class="headerlink" href="#id37" 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="id38">
+<h5><a class="toc-backref" href="#id829">Arguments:</a><a class="headerlink" href="#id38" 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. Only
+‘<tt class="docutils literal"><span class="pre">noreturn</span></tt>‘, ‘<tt class="docutils literal"><span class="pre">nounwind</span></tt>‘, ‘<tt class="docutils literal"><span class="pre">readonly</span></tt>‘ and ‘<tt class="docutils literal"><span class="pre">readnone</span></tt>‘
+attributes are valid here.</li>
+<li>The optional <a class="reference internal" href="#opbundles"><em>operand bundles</em></a> list.</li>
+</ol>
+</div>
+<div class="section" id="id39">
+<h5><a class="toc-backref" href="#id830">Semantics:</a><a class="headerlink" href="#id39" 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="id40">
+<h5><a class="toc-backref" href="#id831">Example:</a><a class="headerlink" href="#id40" 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="#id832">‘<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="id41">
+<h5><a class="toc-backref" href="#id833">Syntax:</a><a class="headerlink" href="#id41" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre>resume <type> <value>
+</pre></div>
+</div>
+</div>
+<div class="section" id="id42">
+<h5><a class="toc-backref" href="#id834">Overview:</a><a class="headerlink" href="#id42" 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="id43">
+<h5><a class="toc-backref" href="#id835">Arguments:</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 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="id44">
+<h5><a class="toc-backref" href="#id836">Semantics:</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 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="id45">
+<h5><a class="toc-backref" href="#id837">Example:</a><a class="headerlink" href="#id45" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre>resume { i8*, i32 } %exn
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="catchswitch-instruction">
+<span id="i-catchswitch"></span><h4><a class="toc-backref" href="#id838">‘<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="id46">
+<h5><a class="toc-backref" href="#id839">Syntax:</a><a class="headerlink" href="#id46" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><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>
+<div class="section" id="id47">
+<h5><a class="toc-backref" href="#id840">Overview:</a><a class="headerlink" href="#id47" 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="id48">
+<h5><a class="toc-backref" href="#id841">Arguments:</a><a class="headerlink" href="#id48" 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="id49">
+<h5><a class="toc-backref" href="#id842">Semantics:</a><a class="headerlink" href="#id49" 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="id50">
+<h5><a class="toc-backref" href="#id843">Example:</a><a class="headerlink" href="#id50" 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="#id844">‘<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="id51">
+<h5><a class="toc-backref" href="#id845">Syntax:</a><a class="headerlink" href="#id51" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre>catchret from <token> to label <normal>
+</pre></div>
+</div>
+</div>
+<div class="section" id="id52">
+<h5><a class="toc-backref" href="#id846">Overview:</a><a class="headerlink" href="#id52" 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="id53">
+<h5><a class="toc-backref" href="#id847">Arguments:</a><a class="headerlink" href="#id53" 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="id54">
+<h5><a class="toc-backref" href="#id848">Semantics:</a><a class="headerlink" href="#id54" 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="id55">
+<h5><a class="toc-backref" href="#id849">Example:</a><a class="headerlink" href="#id55" 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="#id850">‘<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="id56">
+<h5><a class="toc-backref" href="#id851">Syntax:</a><a class="headerlink" href="#id56" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre>cleanupret from <value> unwind label <continue>
+cleanupret from <value> unwind to caller
+</pre></div>
+</div>
+</div>
+<div class="section" id="id57">
+<h5><a class="toc-backref" href="#id852">Overview:</a><a class="headerlink" href="#id57" 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="id58">
+<h5><a class="toc-backref" href="#id853">Arguments:</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 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="id61">
+<h5><a class="toc-backref" href="#id854">Semantics:</a><a class="headerlink" href="#id61" 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="id62">
+<h5><a class="toc-backref" href="#id855">Example:</a><a class="headerlink" href="#id62" 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="#id856">‘<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="id63">
+<h5><a class="toc-backref" href="#id857">Syntax:</a><a class="headerlink" href="#id63" 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="id64">
+<h5><a class="toc-backref" href="#id858">Overview:</a><a class="headerlink" href="#id64" 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="id65">
+<h5><a class="toc-backref" href="#id859">Semantics:</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.</p>
+</div>
+</div>
+</div>
+<div class="section" id="binary-operations">
+<span id="binaryops"></span><h3><a class="toc-backref" href="#id860">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="#id861">‘<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="id66">
+<h5><a class="toc-backref" href="#id862">Syntax:</a><a class="headerlink" href="#id66" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><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>
+<div class="section" id="id67">
+<h5><a class="toc-backref" href="#id863">Overview:</a><a class="headerlink" href="#id67" 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="id68">
+<h5><a class="toc-backref" href="#id864">Arguments:</a><a class="headerlink" href="#id68" 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="id69">
+<h5><a class="toc-backref" href="#id865">Semantics:</a><a class="headerlink" href="#id69" 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="id70">
+<h5><a class="toc-backref" href="#id866">Example:</a><a class="headerlink" href="#id70" 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="#id867">‘<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="id71">
+<h5><a class="toc-backref" href="#id868">Syntax:</a><a class="headerlink" href="#id71" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = fadd [fast-math flags]* <ty> <op1>, <op2>   ; yields ty:result
+</pre></div>
+</div>
+</div>
+<div class="section" id="id72">
+<h5><a class="toc-backref" href="#id869">Overview:</a><a class="headerlink" href="#id72" 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="id73">
+<h5><a class="toc-backref" href="#id870">Arguments:</a><a class="headerlink" href="#id73" 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="id74">
+<h5><a class="toc-backref" href="#id871">Semantics:</a><a class="headerlink" href="#id74" 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="id75">
+<h5><a class="toc-backref" href="#id872">Example:</a><a class="headerlink" href="#id75" 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="#id873">‘<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="id76">
+<h5><a class="toc-backref" href="#id874">Syntax:</a><a class="headerlink" href="#id76" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><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>
+<div class="section" id="id77">
+<h5><a class="toc-backref" href="#id875">Overview:</a><a class="headerlink" href="#id77" 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="id78">
+<h5><a class="toc-backref" href="#id876">Arguments:</a><a class="headerlink" href="#id78" 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="id79">
+<h5><a class="toc-backref" href="#id877">Semantics:</a><a class="headerlink" href="#id79" 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="id80">
+<h5><a class="toc-backref" href="#id878">Example:</a><a class="headerlink" href="#id80" 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="#id879">‘<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="id81">
+<h5><a class="toc-backref" href="#id880">Syntax:</a><a class="headerlink" href="#id81" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = fsub [fast-math flags]* <ty> <op1>, <op2>   ; yields ty:result
+</pre></div>
+</div>
+</div>
+<div class="section" id="id82">
+<h5><a class="toc-backref" href="#id881">Overview:</a><a class="headerlink" href="#id82" 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="id83">
+<h5><a class="toc-backref" href="#id882">Arguments:</a><a class="headerlink" href="#id83" 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="id84">
+<h5><a class="toc-backref" href="#id883">Semantics:</a><a class="headerlink" href="#id84" 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="id85">
+<h5><a class="toc-backref" href="#id884">Example:</a><a class="headerlink" href="#id85" 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="#id885">‘<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="id86">
+<h5><a class="toc-backref" href="#id886">Syntax:</a><a class="headerlink" href="#id86" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><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>
+<div class="section" id="id87">
+<h5><a class="toc-backref" href="#id887">Overview:</a><a class="headerlink" href="#id87" 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="id88">
+<h5><a class="toc-backref" href="#id888">Arguments:</a><a class="headerlink" href="#id88" 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="id89">
+<h5><a class="toc-backref" href="#id889">Semantics:</a><a class="headerlink" href="#id89" 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="id90">
+<h5><a class="toc-backref" href="#id890">Example:</a><a class="headerlink" href="#id90" 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="#id891">‘<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="id91">
+<h5><a class="toc-backref" href="#id892">Syntax:</a><a class="headerlink" href="#id91" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = fmul [fast-math flags]* <ty> <op1>, <op2>   ; yields ty:result
+</pre></div>
+</div>
+</div>
+<div class="section" id="id92">
+<h5><a class="toc-backref" href="#id893">Overview:</a><a class="headerlink" href="#id92" 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="id93">
+<h5><a class="toc-backref" href="#id894">Arguments:</a><a class="headerlink" href="#id93" 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="id94">
+<h5><a class="toc-backref" href="#id895">Semantics:</a><a class="headerlink" href="#id94" 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="id95">
+<h5><a class="toc-backref" href="#id896">Example:</a><a class="headerlink" href="#id95" 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="#id897">‘<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="id96">
+<h5><a class="toc-backref" href="#id898">Syntax:</a><a class="headerlink" href="#id96" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = udiv <ty> <op1>, <op2>         ; yields ty:result
+<result> = udiv exact <ty> <op1>, <op2>   ; yields ty:result
+</pre></div>
+</div>
+</div>
+<div class="section" id="id97">
+<h5><a class="toc-backref" href="#id899">Overview:</a><a class="headerlink" href="#id97" 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="id98">
+<h5><a class="toc-backref" href="#id900">Arguments:</a><a class="headerlink" href="#id98" 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="id99">
+<h5><a class="toc-backref" href="#id901">Semantics:</a><a class="headerlink" href="#id99" 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 leads to 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="id100">
+<h5><a class="toc-backref" href="#id902">Example:</a><a class="headerlink" href="#id100" 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="#id903">‘<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="id101">
+<h5><a class="toc-backref" href="#id904">Syntax:</a><a class="headerlink" href="#id101" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = sdiv <ty> <op1>, <op2>         ; yields ty:result
+<result> = sdiv exact <ty> <op1>, <op2>   ; yields ty:result
+</pre></div>
+</div>
+</div>
+<div class="section" id="id102">
+<h5><a class="toc-backref" href="#id905">Overview:</a><a class="headerlink" href="#id102" 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="id103">
+<h5><a class="toc-backref" href="#id906">Arguments:</a><a class="headerlink" href="#id103" 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="id104">
+<h5><a class="toc-backref" href="#id907">Semantics:</a><a class="headerlink" href="#id104" 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 leads to 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="id105">
+<h5><a class="toc-backref" href="#id908">Example:</a><a class="headerlink" href="#id105" 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="#id909">‘<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="id106">
+<h5><a class="toc-backref" href="#id910">Syntax:</a><a class="headerlink" href="#id106" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = fdiv [fast-math flags]* <ty> <op1>, <op2>   ; yields ty:result
+</pre></div>
+</div>
+</div>
+<div class="section" id="id107">
+<h5><a class="toc-backref" href="#id911">Overview:</a><a class="headerlink" href="#id107" 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="id108">
+<h5><a class="toc-backref" href="#id912">Arguments:</a><a class="headerlink" href="#id108" 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="id109">
+<h5><a class="toc-backref" href="#id913">Semantics:</a><a class="headerlink" href="#id109" 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="id110">
+<h5><a class="toc-backref" href="#id914">Example:</a><a class="headerlink" href="#id110" 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="#id915">‘<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="id111">
+<h5><a class="toc-backref" href="#id916">Syntax:</a><a class="headerlink" href="#id111" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = urem <ty> <op1>, <op2>   ; yields ty:result
+</pre></div>
+</div>
+</div>
+<div class="section" id="id112">
+<h5><a class="toc-backref" href="#id917">Overview:</a><a class="headerlink" href="#id112" 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="id113">
+<h5><a class="toc-backref" href="#id918">Arguments:</a><a class="headerlink" href="#id113" 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="id114">
+<h5><a class="toc-backref" href="#id919">Semantics:</a><a class="headerlink" href="#id114" 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 leads to undefined behavior.</p>
+</div>
+<div class="section" id="id115">
+<h5><a class="toc-backref" href="#id920">Example:</a><a class="headerlink" href="#id115" 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="#id921">‘<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="id116">
+<h5><a class="toc-backref" href="#id922">Syntax:</a><a class="headerlink" href="#id116" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = srem <ty> <op1>, <op2>   ; yields ty:result
+</pre></div>
+</div>
+</div>
+<div class="section" id="id117">
+<h5><a class="toc-backref" href="#id923">Overview:</a><a class="headerlink" href="#id117" 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="id118">
+<h5><a class="toc-backref" href="#id924">Arguments:</a><a class="headerlink" href="#id118" 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="id119">
+<h5><a class="toc-backref" href="#id925">Semantics:</a><a class="headerlink" href="#id119" 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 leads to 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="id120">
+<h5><a class="toc-backref" href="#id926">Example:</a><a class="headerlink" href="#id120" 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="#id927">‘<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="id121">
+<h5><a class="toc-backref" href="#id928">Syntax:</a><a class="headerlink" href="#id121" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = frem [fast-math flags]* <ty> <op1>, <op2>   ; yields ty:result
+</pre></div>
+</div>
+</div>
+<div class="section" id="id122">
+<h5><a class="toc-backref" href="#id929">Overview:</a><a class="headerlink" href="#id122" 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="id123">
+<h5><a class="toc-backref" href="#id930">Arguments:</a><a class="headerlink" href="#id123" 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="id124">
+<h5><a class="toc-backref" href="#id931">Semantics:</a><a class="headerlink" href="#id124" title="Permalink to this headline">¶</a></h5>
+<p>This instruction returns the <em>remainder</em> of a division. 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="id125">
+<h5><a class="toc-backref" href="#id932">Example:</a><a class="headerlink" href="#id125" 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="#id933">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="#id934">‘<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="id126">
+<h5><a class="toc-backref" href="#id935">Syntax:</a><a class="headerlink" href="#id126" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><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>
+<div class="section" id="id127">
+<h5><a class="toc-backref" href="#id936">Overview:</a><a class="headerlink" href="#id127" 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="id128">
+<h5><a class="toc-backref" href="#id937">Arguments:</a><a class="headerlink" href="#id128" 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="id129">
+<h5><a class="toc-backref" href="#id938">Semantics:</a><a class="headerlink" href="#id129" 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>, the result is undefined. 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 <a class="reference internal" href="#poisonvalues"><em>poison
+value</em></a> 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 <a class="reference internal" href="#poisonvalues"><em>poison
+value</em></a> if it shifts out any bits that disagree with the
+resultant sign bit. As such, NUW/NSW have the same semantics as they
+would if the shift were expressed as a mul instruction with the same
+nsw/nuw bits in (mul %op1, (shl 1, %op2)).</p>
+</div>
+<div class="section" id="id130">
+<h5><a class="toc-backref" href="#id939">Example:</a><a class="headerlink" href="#id130" 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="#id940">‘<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="id131">
+<h5><a class="toc-backref" href="#id941">Syntax:</a><a class="headerlink" href="#id131" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = lshr <ty> <op1>, <op2>         ; yields ty:result
+<result> = lshr exact <ty> <op1>, <op2>   ; yields ty:result
+</pre></div>
+</div>
+</div>
+<div class="section" id="id132">
+<h5><a class="toc-backref" href="#id942">Overview:</a><a class="headerlink" href="#id132" 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="id133">
+<h5><a class="toc-backref" href="#id943">Arguments:</a><a class="headerlink" href="#id133" 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="id134">
+<h5><a class="toc-backref" href="#id944">Semantics:</a><a class="headerlink" href="#id134" 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>, the result is undefined. 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 <a class="reference internal" href="#poisonvalues"><em>poison value</em></a> if any of the bits shifted out are
+non-zero.</p>
+</div>
+<div class="section" id="id135">
+<h5><a class="toc-backref" href="#id945">Example:</a><a class="headerlink" href="#id135" 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="#id946">‘<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="id136">
+<h5><a class="toc-backref" href="#id947">Syntax:</a><a class="headerlink" href="#id136" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = ashr <ty> <op1>, <op2>         ; yields ty:result
+<result> = ashr exact <ty> <op1>, <op2>   ; yields ty:result
+</pre></div>
+</div>
+</div>
+<div class="section" id="id137">
+<h5><a class="toc-backref" href="#id948">Overview:</a><a class="headerlink" href="#id137" 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="id138">
+<h5><a class="toc-backref" href="#id949">Arguments:</a><a class="headerlink" href="#id138" 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="id139">
+<h5><a class="toc-backref" href="#id950">Semantics:</a><a class="headerlink" href="#id139" 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>, the result is undefined. 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 <a class="reference internal" href="#poisonvalues"><em>poison value</em></a> if any of the bits shifted out are
+non-zero.</p>
+</div>
+<div class="section" id="id140">
+<h5><a class="toc-backref" href="#id951">Example:</a><a class="headerlink" href="#id140" 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="#id952">‘<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="id141">
+<h5><a class="toc-backref" href="#id953">Syntax:</a><a class="headerlink" href="#id141" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = and <ty> <op1>, <op2>   ; yields ty:result
+</pre></div>
+</div>
+</div>
+<div class="section" id="id142">
+<h5><a class="toc-backref" href="#id954">Overview:</a><a class="headerlink" href="#id142" 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="id143">
+<h5><a class="toc-backref" href="#id955">Arguments:</a><a class="headerlink" href="#id143" 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="id144">
+<h5><a class="toc-backref" href="#id956">Semantics:</a><a class="headerlink" href="#id144" 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="id145">
+<h5><a class="toc-backref" href="#id957">Example:</a><a class="headerlink" href="#id145" 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="#id958">‘<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="id146">
+<h5><a class="toc-backref" href="#id959">Syntax:</a><a class="headerlink" href="#id146" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = or <ty> <op1>, <op2>   ; yields ty:result
+</pre></div>
+</div>
+</div>
+<div class="section" id="id147">
+<h5><a class="toc-backref" href="#id960">Overview:</a><a class="headerlink" href="#id147" 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="id148">
+<h5><a class="toc-backref" href="#id961">Arguments:</a><a class="headerlink" href="#id148" 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="id149">
+<h5><a class="toc-backref" href="#id962">Semantics:</a><a class="headerlink" href="#id149" 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="id150">
+<h5><a class="toc-backref" href="#id963">Example:</a><a class="headerlink" href="#id150" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><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>
+<div class="section" id="xor-instruction">
+<h4><a class="toc-backref" href="#id964">‘<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="id151">
+<h5><a class="toc-backref" href="#id965">Syntax:</a><a class="headerlink" href="#id151" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = xor <ty> <op1>, <op2>   ; yields ty:result
+</pre></div>
+</div>
+</div>
+<div class="section" id="id152">
+<h5><a class="toc-backref" href="#id966">Overview:</a><a class="headerlink" href="#id152" 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="id153">
+<h5><a class="toc-backref" href="#id967">Arguments:</a><a class="headerlink" href="#id153" 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="id154">
+<h5><a class="toc-backref" href="#id968">Semantics:</a><a class="headerlink" href="#id154" 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="id155">
+<h5><a class="toc-backref" href="#id969">Example:</a><a class="headerlink" href="#id155" 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="#id970">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="#id971">‘<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="id156">
+<h5><a class="toc-backref" href="#id972">Syntax:</a><a class="headerlink" href="#id156" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = extractelement <n x <ty>> <val>, <ty2> <idx>  ; yields <ty>
+</pre></div>
+</div>
+</div>
+<div class="section" id="id157">
+<h5><a class="toc-backref" href="#id973">Overview:</a><a class="headerlink" href="#id157" 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="id158">
+<h5><a class="toc-backref" href="#id974">Arguments:</a><a class="headerlink" href="#id158" 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="id159">
+<h5><a class="toc-backref" href="#id975">Semantics:</a><a class="headerlink" href="#id159" 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="id160">
+<h5><a class="toc-backref" href="#id976">Example:</a><a class="headerlink" href="#id160" 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="#id977">‘<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="id161">
+<h5><a class="toc-backref" href="#id978">Syntax:</a><a class="headerlink" href="#id161" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = insertelement <n x <ty>> <val>, <ty> <elt>, <ty2> <idx>    ; yields <n x <ty>>
+</pre></div>
+</div>
+</div>
+<div class="section" id="id162">
+<h5><a class="toc-backref" href="#id979">Overview:</a><a class="headerlink" href="#id162" 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="id163">
+<h5><a class="toc-backref" href="#id980">Arguments:</a><a class="headerlink" href="#id163" 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="id164">
+<h5><a class="toc-backref" href="#id981">Semantics:</a><a class="headerlink" href="#id164" 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="id165">
+<h5><a class="toc-backref" href="#id982">Example:</a><a class="headerlink" href="#id165" 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="#id983">‘<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="id166">
+<h5><a class="toc-backref" href="#id984">Syntax:</a><a class="headerlink" href="#id166" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = shufflevector <n x <ty>> <v1>, <n x <ty>> <v2>, <m x i32> <mask>    ; yields <m x <ty>>
+</pre></div>
+</div>
+</div>
+<div class="section" id="id167">
+<h5><a class="toc-backref" href="#id985">Overview:</a><a class="headerlink" href="#id167" 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="id168">
+<h5><a class="toc-backref" href="#id986">Arguments:</a><a class="headerlink" href="#id168" 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="id169">
+<h5><a class="toc-backref" href="#id987">Semantics:</a><a class="headerlink" href="#id169" 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. The element selector may be undef (meaning “don’t
+care”) and the second operand may be undef if performing a shuffle from
+only one vector.</p>
+</div>
+<div class="section" id="id170">
+<h5><a class="toc-backref" href="#id988">Example:</a><a class="headerlink" href="#id170" 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="#id989">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="#id990">‘<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="id171">
+<h5><a class="toc-backref" href="#id991">Syntax:</a><a class="headerlink" href="#id171" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = extractvalue <aggregate type> <val>, <idx>{, <idx>}*
+</pre></div>
+</div>
+</div>
+<div class="section" id="id172">
+<h5><a class="toc-backref" href="#id992">Overview:</a><a class="headerlink" href="#id172" 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="id173">
+<h5><a class="toc-backref" href="#id993">Arguments:</a><a class="headerlink" href="#id173" 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="id174">
+<h5><a class="toc-backref" href="#id994">Semantics:</a><a class="headerlink" href="#id174" 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="id175">
+<h5><a class="toc-backref" href="#id995">Example:</a><a class="headerlink" href="#id175" 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="#id996">‘<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="id176">
+<h5><a class="toc-backref" href="#id997">Syntax:</a><a class="headerlink" href="#id176" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = insertvalue <aggregate type> <val>, <ty> <elt>, <idx>{, <idx>}*    ; yields <aggregate type>
+</pre></div>
+</div>
+</div>
+<div class="section" id="id177">
+<h5><a class="toc-backref" href="#id998">Overview:</a><a class="headerlink" href="#id177" 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="id178">
+<h5><a class="toc-backref" href="#id999">Arguments:</a><a class="headerlink" href="#id178" 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="id179">
+<h5><a class="toc-backref" href="#id1000">Semantics:</a><a class="headerlink" href="#id179" 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="id180">
+<h5><a class="toc-backref" href="#id1001">Example:</a><a class="headerlink" href="#id180" 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="#id1002">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="#id1003">‘<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="id181">
+<h5><a class="toc-backref" href="#id1004">Syntax:</a><a class="headerlink" href="#id181" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = alloca [inalloca] <type> [, <ty> <NumElements>] [, align <alignment>]     ; yields type*:result
+</pre></div>
+</div>
+</div>
+<div class="section" id="id182">
+<h5><a class="toc-backref" href="#id1005">Overview:</a><a class="headerlink" href="#id182" 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
+generic address space (address space zero).</p>
+</div>
+<div class="section" id="id183">
+<h5><a class="toc-backref" href="#id1006">Arguments:</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 <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="id184">
+<h5><a class="toc-backref" href="#id1007">Semantics:</a><a class="headerlink" href="#id184" 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="id185">
+<h5><a class="toc-backref" href="#id1008">Example:</a><a class="headerlink" href="#id185" 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="#id1009">‘<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="id186">
+<h5><a class="toc-backref" href="#id1010">Syntax:</a><a class="headerlink" href="#id186" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><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> [singlethread] <ordering>, align <alignment> [, !invariant.group !<index>]
+!<index> = !{ i32 1 }
+!<deref_bytes_node> = !{i64 <dereferenceable_bytes>}
+!<align_node> = !{ i64 <value_alignment> }
+</pre></div>
+</div>
+</div>
+<div class="section" id="id187">
+<h5><a class="toc-backref" href="#id1011">Overview:</a><a class="headerlink" href="#id187" 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="id188">
+<h5><a class="toc-backref" href="#id1012">Arguments:</a><a class="headerlink" href="#id188" 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">singlethread</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. The existence of the <tt class="docutils literal"><span class="pre">!invariant.load</span></tt> metadata on the
+instruction tells the optimizer and code generator that the address
+operand to this load points to memory which can be assumed unchanged.
+Being invariant does not imply that a location is dereferenceable,
+but it does imply that once the location is known dereferenceable
+its value is henceforth unchanging.</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="id189">
+<h5><a class="toc-backref" href="#id1013">Semantics:</a><a class="headerlink" href="#id189" 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="id190">
+<h5><a class="toc-backref" href="#id1014">Examples:</a><a class="headerlink" href="#id190" 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="#id1015">‘<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="id191">
+<h5><a class="toc-backref" href="#id1016">Syntax:</a><a class="headerlink" href="#id191" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre>store [volatile] <ty> <value>, <ty>* <pointer>[, align <alignment>][, !nontemporal !<index>][, !invariant.group !<index>]        ; yields void
+store atomic [volatile] <ty> <value>, <ty>* <pointer> [singlethread] <ordering>, align <alignment> [, !invariant.group !<index>] ; yields void
+</pre></div>
+</div>
+</div>
+<div class="section" id="id192">
+<h5><a class="toc-backref" href="#id1017">Overview:</a><a class="headerlink" href="#id192" 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="id193">
+<h5><a class="toc-backref" href="#id1018">Arguments:</a><a class="headerlink" href="#id193" 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">singlethread</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="id194">
+<h5><a class="toc-backref" href="#id1019">Semantics:</a><a class="headerlink" href="#id194" 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="id195">
+<h5><a class="toc-backref" href="#id1020">Example:</a><a class="headerlink" href="#id195" 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="#id1021">‘<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="id196">
+<h5><a class="toc-backref" href="#id1022">Syntax:</a><a class="headerlink" href="#id196" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre>fence [singlethread] <ordering>                   ; yields void
+</pre></div>
+</div>
+</div>
+<div class="section" id="id197">
+<h5><a class="toc-backref" href="#id1023">Overview:</a><a class="headerlink" href="#id197" 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="id198">
+<h5><a class="toc-backref" href="#id1024">Arguments:</a><a class="headerlink" href="#id198" 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="id199">
+<h5><a class="toc-backref" href="#id1025">Semantics:</a><a class="headerlink" href="#id199" 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>The optional “<a class="reference internal" href="#singlethread"><em>singlethread</em></a>” argument specifies
+that the fence only synchronizes with other fences in the same thread.
+(This is useful for interacting with signal handlers.)</p>
+</div>
+<div class="section" id="id200">
+<h5><a class="toc-backref" href="#id1026">Example:</a><a class="headerlink" href="#id200" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre>fence acquire                          ; yields void
+fence singlethread 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="#id1027">‘<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="id201">
+<h5><a class="toc-backref" href="#id1028">Syntax:</a><a class="headerlink" href="#id201" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre>cmpxchg [weak] [volatile] <ty>* <pointer>, <ty> <cmp>, <ty> <new> [singlethread] <success ordering> <failure ordering> ; yields  { ty, i1 }
+</pre></div>
+</div>
+</div>
+<div class="section" id="id202">
+<h5><a class="toc-backref" href="#id1029">Overview:</a><a class="headerlink" href="#id202" 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="id203">
+<h5><a class="toc-backref" href="#id1030">Arguments:</a><a class="headerlink" href="#id203" 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>The optional “<tt class="docutils literal"><span class="pre">singlethread</span></tt>” argument declares that the <tt class="docutils literal"><span class="pre">cmpxchg</span></tt>
+is only atomic with respect to code (usually signal handlers) running in
+the same thread as the <tt class="docutils literal"><span class="pre">cmpxchg</span></tt>. Otherwise the cmpxchg is atomic with
+respect to all other code in the system.</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="id204">
+<h5><a class="toc-backref" href="#id1031">Semantics:</a><a class="headerlink" href="#id204" 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 read value is the equal, the
+‘<tt class="docutils literal"><span class="pre"><new></span></tt>‘ is written. 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="id205">
+<h5><a class="toc-backref" href="#id1032">Example:</a><a class="headerlink" href="#id205" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><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>
+<div class="section" id="atomicrmw-instruction">
+<span id="i-atomicrmw"></span><h4><a class="toc-backref" href="#id1033">‘<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="id206">
+<h5><a class="toc-backref" href="#id1034">Syntax:</a><a class="headerlink" href="#id206" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre>atomicrmw [volatile] <operation> <ty>* <pointer>, <ty> <value> [singlethread] <ordering>                   ; yields ty
+</pre></div>
+</div>
+</div>
+<div class="section" id="id207">
+<h5><a class="toc-backref" href="#id1035">Overview:</a><a class="headerlink" href="#id207" 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="id208">
+<h5><a class="toc-backref" href="#id1036">Arguments:</a><a class="headerlink" href="#id208" 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>
+</div>
+<div class="section" id="id209">
+<h5><a class="toc-backref" href="#id1037">Semantics:</a><a class="headerlink" href="#id209" 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="id210">
+<h5><a class="toc-backref" href="#id1038">Example:</a><a class="headerlink" href="#id210" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><pre>%old = atomicrmw add i32* %ptr, i32 1 acquire                        ; yields i32
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="getelementptr-instruction">
+<span id="i-getelementptr"></span><h4><a class="toc-backref" href="#id1039">‘<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="id211">
+<h5><a class="toc-backref" href="#id1040">Syntax:</a><a class="headerlink" href="#id211" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = getelementptr <ty>, <ty>* <ptrval>{, <ty> <idx>}*
+<result> = getelementptr inbounds <ty>, <ty>* <ptrval>{, <ty> <idx>}*
+<result> = getelementptr <ty>, <ptr vector> <ptrval>, <vector index type> <idx>
+</pre></div>
+</div>
+</div>
+<div class="section" id="id212">
+<h5><a class="toc-backref" href="#id1041">Overview:</a><a class="headerlink" href="#id212" 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="id213">
+<h5><a class="toc-backref" href="#id1042">Arguments:</a><a class="headerlink" href="#id213" 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
+first 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"><div class="highlight"><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>
+<div class="section" id="id214">
+<h5><a class="toc-backref" href="#id1043">Semantics:</a><a class="headerlink" href="#id214" 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. 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>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="id215">
+<h5><a class="toc-backref" href="#id1044">Example:</a><a class="headerlink" href="#id215" 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="#id1045">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="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</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="#id1046">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">
+<h4><a class="toc-backref" href="#id1047">‘<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="id216">
+<h5><a class="toc-backref" href="#id1048">Syntax:</a><a class="headerlink" href="#id216" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = trunc <ty> <value> to <ty2>             ; yields ty2
+</pre></div>
+</div>
+</div>
+<div class="section" id="id217">
+<h5><a class="toc-backref" href="#id1049">Overview:</a><a class="headerlink" href="#id217" 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="id218">
+<h5><a class="toc-backref" href="#id1050">Arguments:</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 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="id219">
+<h5><a class="toc-backref" href="#id1051">Semantics:</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 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="id220">
+<h5><a class="toc-backref" href="#id1052">Example:</a><a class="headerlink" href="#id220" 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">
+<h4><a class="toc-backref" href="#id1053">‘<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="id221">
+<h5><a class="toc-backref" href="#id1054">Syntax:</a><a class="headerlink" href="#id221" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = zext <ty> <value> to <ty2>             ; yields ty2
+</pre></div>
+</div>
+</div>
+<div class="section" id="id222">
+<h5><a class="toc-backref" href="#id1055">Overview:</a><a class="headerlink" href="#id222" 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="id223">
+<h5><a class="toc-backref" href="#id1056">Arguments:</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 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="id224">
+<h5><a class="toc-backref" href="#id1057">Semantics:</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> 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="id225">
+<h5><a class="toc-backref" href="#id1058">Example:</a><a class="headerlink" href="#id225" 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">
+<h4><a class="toc-backref" href="#id1059">‘<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="id226">
+<h5><a class="toc-backref" href="#id1060">Syntax:</a><a class="headerlink" href="#id226" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = sext <ty> <value> to <ty2>             ; yields ty2
+</pre></div>
+</div>
+</div>
+<div class="section" id="id227">
+<h5><a class="toc-backref" href="#id1061">Overview:</a><a class="headerlink" href="#id227" 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="id228">
+<h5><a class="toc-backref" href="#id1062">Arguments:</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>‘ 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="id229">
+<h5><a class="toc-backref" href="#id1063">Semantics:</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 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="id230">
+<h5><a class="toc-backref" href="#id1064">Example:</a><a class="headerlink" href="#id230" 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="#id1065">‘<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="id231">
+<h5><a class="toc-backref" href="#id1066">Syntax:</a><a class="headerlink" href="#id231" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = fptrunc <ty> <value> to <ty2>             ; yields ty2
+</pre></div>
+</div>
+</div>
+<div class="section" id="id232">
+<h5><a class="toc-backref" href="#id1067">Overview:</a><a class="headerlink" href="#id232" 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="id233">
+<h5><a class="toc-backref" href="#id1068">Arguments:</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 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="id234">
+<h5><a class="toc-backref" href="#id1069">Semantics:</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 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="id235">
+<h5><a class="toc-backref" href="#id1070">Example:</a><a class="headerlink" href="#id235" 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="#id1071">‘<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="id236">
+<h5><a class="toc-backref" href="#id1072">Syntax:</a><a class="headerlink" href="#id236" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = fpext <ty> <value> to <ty2>             ; yields ty2
+</pre></div>
+</div>
+</div>
+<div class="section" id="id237">
+<h5><a class="toc-backref" href="#id1073">Overview:</a><a class="headerlink" href="#id237" 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="id238">
+<h5><a class="toc-backref" href="#id1074">Arguments:</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>‘ 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="id239">
+<h5><a class="toc-backref" href="#id1075">Semantics:</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 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="id240">
+<h5><a class="toc-backref" href="#id1076">Example:</a><a class="headerlink" href="#id240" 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="#id1077">‘<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="id241">
+<h5><a class="toc-backref" href="#id1078">Syntax:</a><a class="headerlink" href="#id241" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = fptoui <ty> <value> to <ty2>             ; yields ty2
+</pre></div>
+</div>
+</div>
+<div class="section" id="id242">
+<h5><a class="toc-backref" href="#id1079">Overview:</a><a class="headerlink" href="#id242" 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="id243">
+<h5><a class="toc-backref" href="#id1080">Arguments:</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>‘ 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="id244">
+<h5><a class="toc-backref" href="#id1081">Semantics:</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 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="id245">
+<h5><a class="toc-backref" href="#id1082">Example:</a><a class="headerlink" href="#id245" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><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>
+<div class="section" id="fptosi-to-instruction">
+<h4><a class="toc-backref" href="#id1083">‘<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="id246">
+<h5><a class="toc-backref" href="#id1084">Syntax:</a><a class="headerlink" href="#id246" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = fptosi <ty> <value> to <ty2>             ; yields ty2
+</pre></div>
+</div>
+</div>
+<div class="section" id="id247">
+<h5><a class="toc-backref" href="#id1085">Overview:</a><a class="headerlink" href="#id247" 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="id248">
+<h5><a class="toc-backref" href="#id1086">Arguments:</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 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="id249">
+<h5><a class="toc-backref" href="#id1087">Semantics:</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 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="id250">
+<h5><a class="toc-backref" href="#id1088">Example:</a><a class="headerlink" href="#id250" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-llvm"><div class="highlight"><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>
+<div class="section" id="uitofp-to-instruction">
+<h4><a class="toc-backref" href="#id1089">‘<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="id251">
+<h5><a class="toc-backref" href="#id1090">Syntax:</a><a class="headerlink" href="#id251" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = uitofp <ty> <value> to <ty2>             ; yields ty2
+</pre></div>
+</div>
+</div>
+<div class="section" id="id252">
+<h5><a class="toc-backref" href="#id1091">Overview:</a><a class="headerlink" href="#id252" 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="id253">
+<h5><a class="toc-backref" href="#id1092">Arguments:</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 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="id254">
+<h5><a class="toc-backref" href="#id1093">Semantics:</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 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="id255">
+<h5><a class="toc-backref" href="#id1094">Example:</a><a class="headerlink" href="#id255" 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="#id1095">‘<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="id256">
+<h5><a class="toc-backref" href="#id1096">Syntax:</a><a class="headerlink" href="#id256" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = sitofp <ty> <value> to <ty2>             ; yields ty2
+</pre></div>
+</div>
+</div>
+<div class="section" id="id257">
+<h5><a class="toc-backref" href="#id1097">Overview:</a><a class="headerlink" href="#id257" 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="id258">
+<h5><a class="toc-backref" href="#id1098">Arguments:</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 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="id259">
+<h5><a class="toc-backref" href="#id1099">Semantics:</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 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="id260">
+<h5><a class="toc-backref" href="#id1100">Example:</a><a class="headerlink" href="#id260" 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="#id1101">‘<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="id261">
+<h5><a class="toc-backref" href="#id1102">Syntax:</a><a class="headerlink" href="#id261" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = ptrtoint <ty> <value> to <ty2>             ; yields ty2
+</pre></div>
+</div>
+</div>
+<div class="section" id="id262">
+<h5><a class="toc-backref" href="#id1103">Overview:</a><a class="headerlink" href="#id262" 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="id263">
+<h5><a class="toc-backref" href="#id1104">Arguments:</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 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="id264">
+<h5><a class="toc-backref" href="#id1105">Semantics:</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 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="id265">
+<h5><a class="toc-backref" href="#id1106">Example:</a><a class="headerlink" href="#id265" 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="#id1107">‘<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="id266">
+<h5><a class="toc-backref" href="#id1108">Syntax:</a><a class="headerlink" href="#id266" title="Permalink to this headline">¶</a></h5>
+<div class="highlight-python"><div class="highlight"><pre><result> = inttoptr <ty> <value> to <ty2>             ; yields ty2
+</pre></div>
+</div>
+</div>
+<div class="section" id="id267">
+<h5><a class="toc-backref" href="#id1109">Overview:</a><a class="headerlink" href="#id267" 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="id268">
+<h5><a class="toc-backref" href="#id1110">Arguments:</a><a class="headerlink" href="#id268" title="Permalink to this headline">¶</a></h5>
+<