Initial draft of PNaCl bitcode files.

native_client_sdk/doc_generated/reference/pnacl-bitcode-manual.html

+{{+bindTo:partials.standard_nacl_article}}
+
+<section id="contents-of-pnacl-bitcode-files">
+<h1 id="contents-of-pnacl-bitcode-files">Contents Of PNaCl Bitcode Files</h1>
+<div class="contents local" id="contents" style="display: none">
+<ul class="small-gap">
+<li><a class="reference internal" href="#introduction" id="id6">Introduction</a></li>
+<li><a class="reference internal" href="#data-model" id="id7">Data Model</a></li>
+<li><a class="reference internal" href="#pnacl-blocks" id="id8">PNaCl Blocks</a></li>
+<li><a class="reference internal" href="#pnacl-records" id="id9">PNaCl Records</a></li>
+<li><a class="reference internal" href="#default-abbreviations" id="id10">Default Abbreviations</a></li>
+<li><a class="reference internal" href="#pnacl-identifiers" id="id11">PNaCl Identifiers</a></li>
+<li><a class="reference internal" href="#conventions-for-describing-records" id="id12">Conventions For Describing Records</a></li>
+<li><a class="reference internal" href="#factorial-example" id="id13">Factorial Example</a></li>
+<li><a class="reference internal" href="#road-map" id="id14">Road Map</a></li>
+<li><p class="first"><a class="reference internal" href="#global-state" id="id15">Global State</a></p>
+<ul class="small-gap">
+<li><a class="reference internal" href="#typing-functions" id="id16">Typing Functions</a></li>
+<li><a class="reference internal" href="#link-to-id-counters" id="id17">ID Counters</a></li>
+<li><a class="reference internal" href="#size-variables" id="id18">Size Variables</a></li>
+<li><a class="reference internal" href="#other-variables" id="id19">Other Variables</a></li>
+</ul>
+</li>
+<li><p class="first"><a class="reference internal" href="#global-records" id="id20">Global Records</a></p>
+<ul class="small-gap">
+<li><a class="reference internal" href="#header-record" id="id21">Header Record</a></li>
+<li><a class="reference internal" href="#enter-block-record" id="id22">Enter Block Record</a></li>
+<li><a class="reference internal" href="#exit-block-record" id="id23">Exit Block Record</a></li>
+<li><a class="reference internal" href="#abbreviation-record" id="id24">Abbreviation Record</a></li>
+</ul>
+</li>
+<li><p class="first"><a class="reference internal" href="#types-block" id="id25">Types Block</a></p>
+<ul class="small-gap">
+<li><a class="reference internal" href="#count-record" id="id26">Count Record</a></li>
+<li><a class="reference internal" href="#void-type" id="id27">Void Type</a></li>
+<li><a class="reference internal" href="#integer-types" id="id28">Integer Types</a></li>
+<li><a class="reference internal" href="#bit-floating-point-type" id="id29">32-Bit Floating Point Type</a></li>
+<li><a class="reference internal" href="#id1" id="id30">64-bit Floating Point Type</a></li>
+<li><a class="reference internal" href="#vector-types" id="id31">Vector Types</a></li>
+<li><a class="reference internal" href="#function-type" id="id32">Function Type</a></li>
+</ul>
+</li>
+<li><p class="first"><a class="reference internal" href="#globals-block" id="id33">Globals Block</a></p>
+<ul class="small-gap">
+<li><a class="reference internal" href="#link-for-globals-count-record" id="id34">Count Record</a></li>
+<li><a class="reference internal" href="#global-variable-addresses" id="id35">Global Variable Addresses</a></li>
+<li><a class="reference internal" href="#global-constant-addresses" id="id36">Global Constant Addresses</a></li>
+<li><a class="reference internal" href="#zerofill-initializer" id="id37">Zerofill Initializer</a></li>
+<li><a class="reference internal" href="#data-initializer" id="id38">Data Initializer</a></li>
+<li><a class="reference internal" href="#relocation-initializer" id="id39">Relocation Initializer</a></li>
+<li><a class="reference internal" href="#subfield-relocation-initializer" id="id40">Subfield Relocation Initializer</a></li>
+<li><a class="reference internal" href="#compound-initializer" id="id41">Compound Initializer</a></li>
+</ul>
+</li>
+<li><p class="first"><a class="reference internal" href="#valuesymtab-block" id="id42">Valuesymtab Block</a></p>
+<ul class="small-gap">
+<li><a class="reference internal" href="#entry-record" id="id43">Entry Record</a></li>
+</ul>
+</li>
+<li><p class="first"><a class="reference internal" href="#module-block" id="id44">Module Block</a></p>
+<ul class="small-gap">
+<li><a class="reference internal" href="#version-record" id="id45">Version Record</a></li>
+<li><a class="reference internal" href="#function-address" id="id46">Function Address</a></li>
+</ul>
+</li>
+<li><p class="first"><a class="reference internal" href="#constants-blocks" id="id47">Constants Blocks</a></p>
+<ul class="small-gap">
+<li><a class="reference internal" href="#set-type-record" id="id48">Set Type Record</a></li>
+<li><a class="reference internal" href="#undefined-literal" id="id49">Undefined Literal</a></li>
+<li><a class="reference internal" href="#integer-literal" id="id50">Integer Literal</a></li>
+<li><a class="reference internal" href="#floating-point-literal" id="id51">Floating Point Literal</a></li>
+</ul>
+</li>
+<li><p class="first"><a class="reference internal" href="#function-blocks" id="id52">Function Blocks</a></p>
+<ul class="small-gap">
+<li><a class="reference internal" href="#function-enter" id="id53">Function Enter</a></li>
+<li><a class="reference internal" href="#link-for-basic-blocks-count" id="id54">Count Record</a></li>
+</ul>
+</li>
+<li><p class="first"><a class="reference internal" href="#terminator-instructions" id="id55">Terminator Instructions</a></p>
+<ul class="small-gap">
+<li><a class="reference internal" href="#return-void-instruction" id="id56">Return Void Instruction</a></li>
+<li><a class="reference internal" href="#return-value-instruction" id="id57">Return Value Instruction</a></li>
+<li><a class="reference internal" href="#unconditional-branch-instruction" id="id58">Unconditional Branch Instruction</a></li>
+<li><a class="reference internal" href="#conditional-branch-instruction" id="id59">Conditional Branch Instruction</a></li>
+<li><a class="reference internal" href="#unreachable" id="id60">Unreachable</a></li>
+<li><a class="reference internal" href="#switch-instruction" id="id61">Switch Instruction</a></li>
+</ul>
+</li>
+<li><p class="first"><a class="reference internal" href="#integer-binary-instructions" id="id62">Integer Binary Instructions</a></p>
+<ul class="small-gap">
+<li><a class="reference internal" href="#integer-add" id="id63">Integer Add</a></li>
+<li><a class="reference internal" href="#integer-subtract" id="id64">Integer Subtract</a></li>
+<li><a class="reference internal" href="#integer-multiply" id="id65">Integer Multiply</a></li>
+<li><a class="reference internal" href="#signed-integer-divide" id="id66">Signed Integer Divide</a></li>
+<li><a class="reference internal" href="#unsigned-integer-divide" id="id67">Unsigned Integer Divide</a></li>
+<li><a class="reference internal" href="#signed-integer-remainder" id="id68">Signed Integer Remainder</a></li>
+<li><a class="reference internal" href="#unsigned-integer-remainder-instruction" id="id69">Unsigned Integer Remainder Instruction</a></li>
+<li><a class="reference internal" href="#shift-left" id="id70">Shift Left</a></li>
+<li><a class="reference internal" href="#logical-shift-right" id="id71">Logical Shift Right</a></li>
+<li><a class="reference internal" href="#arithmetic-shift-right" id="id72">Arithmetic Shift Right</a></li>
+<li><a class="reference internal" href="#logical-and" id="id73">Logical And</a></li>
+<li><a class="reference internal" href="#logical-or" id="id74">Logical Or</a></li>
+<li><a class="reference internal" href="#logical-xor" id="id75">Logical Xor</a></li>
+</ul>
+</li>
+<li><p class="first"><a class="reference internal" href="#floating-point-binary-instructions" id="id76">Floating Point Binary Instructions</a></p>
+<ul class="small-gap">
+<li><a class="reference internal" href="#floating-point-add" id="id77">Floating Point Add</a></li>
+<li><a class="reference internal" href="#floating-point-subtract" id="id78">Floating Point Subtract</a></li>
+<li><a class="reference internal" href="#floating-point-multiply" id="id79">Floating Point Multiply</a></li>
+<li><a class="reference internal" href="#floating-point-divide" id="id80">Floating Point Divide</a></li>
+<li><a class="reference internal" href="#floating-point-remainder" id="id81">Floating Point Remainder</a></li>
+</ul>
+</li>
+<li><p class="first"><a class="reference internal" href="#memory-creation-and-access-instructions" id="id82">Memory Creation and Access Instructions</a></p>
+<ul class="small-gap">
+<li><a class="reference internal" href="#alloca-instruction" id="id83">Alloca Instruction</a></li>
+<li><a class="reference internal" href="#load-instruction" id="id84">Load Instruction</a></li>
+<li><a class="reference internal" href="#store-instruction" id="id85">Store Instruction</a></li>
+</ul>
+</li>
+<li><p class="first"><a class="reference internal" href="#conversion-instructions" id="id86">Conversion Instructions</a></p>
+<ul class="small-gap">
+<li><a class="reference internal" href="#integer-truncating-instruction" id="id87">Integer Truncating Instruction</a></li>
+<li><a class="reference internal" href="#floating-point-truncating-instruction" id="id88">Floating Point Truncating Instruction</a></li>
+<li><a class="reference internal" href="#zero-extending-instruction" id="id89">Zero Extending Instruction</a></li>
+<li><a class="reference internal" href="#sign-extending-instruction" id="id90">Sign Extending Instruction</a></li>
+<li><a class="reference internal" href="#floating-point-extending-instruction" id="id91">Floating Point Extending Instruction</a></li>
+<li><a class="reference internal" href="#floating-point-to-unsigned-integer-instruction" id="id92">Floating Point to Unsigned Integer Instruction</a></li>
+<li><a class="reference internal" href="#floating-point-to-signed-integer-instruction" id="id93">Floating Point to Signed Integer Instruction</a></li>
+<li><a class="reference internal" href="#unsigned-integer-to-floating-point-instruction" id="id94">Unsigned Integer to Floating Point Instruction</a></li>
+<li><a class="reference internal" href="#signed-integer-to-floating-point-instruction" id="id95">Signed Integer to Floating Point Instruction</a></li>
+<li><a class="reference internal" href="#bitcast-instruction" id="id96">Bitcast Instruction</a></li>
+</ul>
+</li>
+<li><p class="first"><a class="reference internal" href="#comparison-instructions" id="id97">Comparison Instructions</a></p>
+<ul class="small-gap">
+<li><a class="reference internal" href="#integer-comparison-instructions" id="id98">Integer Comparison Instructions</a></li>
+<li><a class="reference internal" href="#floating-point-comparison-instructions" id="id99">Floating Point Comparison Instructions</a></li>
+</ul>
+</li>
+<li><p class="first"><a class="reference internal" href="#vector-instructions" id="id100">Vector Instructions</a></p>
+<ul class="small-gap">
+<li><a class="reference internal" href="#insert-element-instruction" id="id101">Insert Element Instruction</a></li>
+<li><a class="reference internal" href="#extract-element-instruction" id="id102">Extract Element Instruction</a></li>
+</ul>
+</li>
+<li><p class="first"><a class="reference internal" href="#other-instructions" id="id103">Other Instructions</a></p>
+<ul class="small-gap">
+<li><a class="reference internal" href="#forward-type-declaration" id="id104">Forward Type Declaration</a></li>
+<li><a class="reference internal" href="#phi-instruction" id="id105">Phi Instruction</a></li>
+<li><a class="reference internal" href="#select-instruction" id="id106">Select Instruction</a></li>
+<li><p class="first"><a class="reference internal" href="#call-instructions" id="id107">Call Instructions</a></p>
+<ul class="small-gap">
+<li><a class="reference internal" href="#direct-procedure-call" id="id108">Direct Procedure Call</a></li>
+<li><a class="reference internal" href="#direct-function-call" id="id109">Direct Function Call</a></li>
+<li><a class="reference internal" href="#indirect-procedure-call" id="id110">Indirect Procedure Call</a></li>
+<li><a class="reference internal" href="#indirect-function-call" id="id111">Indirect Function Call</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#memory-blocks-and-alignment" id="id112">Memory Blocks and Alignment</a></li>
+<li><a class="reference internal" href="#intrinsic-functions" id="id113">Intrinsic Functions</a></li>
+<li><p class="first"><a class="reference internal" href="#support-functions" id="id114">Support Functions</a></p>
+<ul class="small-gap">
+<li><a class="reference internal" href="#signrotate" id="id115">SignRotate</a></li>
+<li><a class="reference internal" href="#absoluteindex" id="id116">AbsoluteIndex</a></li>
+<li><a class="reference internal" href="#relativeindex" id="id117">RelativeIndex</a></li>
+<li><a class="reference internal" href="#abbrevindex" id="id118">AbbrevIndex</a></li>
+<li><a class="reference internal" href="#log2" id="id119">Log2</a></li>
+<li><a class="reference internal" href="#bitsizeof" id="id120">BitSizeOf</a></li>
+<li><a class="reference internal" href="#underlyingtype" id="id121">UnderlyingType</a></li>
+<li><a class="reference internal" href="#underlyingcount" id="id122">UnderlyingCount</a></li>
+<li><a class="reference internal" href="#isinteger" id="id123">IsInteger</a></li>
+<li><a class="reference internal" href="#isfloat" id="id124">IsFloat</a></li>
+<li><a class="reference internal" href="#isvector" id="id125">IsVector</a></li>
+<li><a class="reference internal" href="#isprimitive" id="id126">IsPrimitive</a></li>
+<li><a class="reference internal" href="#isfcnargtype" id="id127">IsFcnArgType</a></li>
+</ul>
+</li>
+<li><p class="first"><a class="reference internal" href="#abbreviations" id="id128">Abbreviations</a></p>
+<ul class="small-gap">
+<li><a class="reference internal" href="#abbreviations-block" id="id129">Abbreviations Block</a></li>
+<li><a class="reference internal" href="#todo" id="id130">TODO</a></li>
+</ul>
+</li>
+</ul>
+
+</div><h2 id="introduction">Introduction</h2>
+<p>This document is a reference manual for the contents of PNaCl bitcode files. We
+define bitcode files via three layers. The first layer is presented using
+assembly language <em>PNaClAsm</em>, and defines the textual form of the bitcode
+file. The textual form is then lowered to a sequence of <a class="reference internal" href="#link-for-pnacl-records"><em>PNaCl
+records</em></a>. The final layer applies abbreviations that
+convert each PNaCl record into a corresponding sequence of bits.</p>
+<img alt="/native-client/images/PNaClBitcodeFlow.png" src="/native-client/images/PNaClBitcodeFlow.png" />
+<p>PNaClAsm uses a <em>static single assignment</em> (SSA) based representation that
+requires generated results to have a single (assignment) source.</p>
+<p>PNaClAsm focuses on the semantic content of the file, not the bit-encoding of
+that content. However, it does provide annotations that allow one to specify how
+the <a class="reference internal" href="#link-for-abbreviations-section"><em>abbreviations</em></a> are used to convert
+PNaCl records into the sequence of bits.</p>
+<p>Each construct in PNaClAsm defines a corresponding <a class="reference internal" href="#link-for-pnacl-records"><em>PNaCl
+record</em></a>.  A PNaCl bitcode file is simply a sequence of
+PNaCl records. The goal of PNaClAsm is to make records easier to read, and not
+to define a high-level user programming language.</p>
+<p>PNaCl records are an abstract encoding of structured data, similar to XML. Like
+XML, A PNaCl record has a notion of a tag (i.e. the first element in a record,
+called a <em>code</em>). PNaCl records can be nested. Nesting is defined by a
+corresponding <a class="reference internal" href="#link-for-enter-block-record-section"><em>enter</em></a> and
+<a class="reference internal" href="#link-for-exit-block-record-section"><em>exit</em></a> block record.</p>
+<p>These block records must be used like balanced parentheses to define the block
+structure that is imposed on top of records. Each exit record must be preceded
+by a corresponding enter record. Blocks can be nested by nesting enter/exit
+records appropriately.</p>
+<p>The <em>PNaCl bitcode writer</em> takes the sequence of records, defined by a PNaClAsm
+program, and converts each record into a (variable-length) sequence of bits. The
+output of each bit sequence is appended together. The resulting generated
+sequence of bits is the contents of the PNaCl bitcode file.</p>
+<p>For every kind of record, there is a method for converting records into bit
+sequences. These methods correspond to a notion of
+<a class="reference internal" href="#link-for-abbreviations-section"><em>abbreviations</em></a>.  Each abbreviation defines
+a specific bit sequence conversion to be applied.</p>
+<p>Abbreviations can be user-defined, but there are also predefined defaults.  All
+user-specified abbreviations are included in the generated bitcode
+file. Predefined defaults are not.</p>
+<p>Each abbreviation defines how a record is converted to a bit sequence. The
+<a class="reference internal" href="/native-client/overview.html#link-for-pnacl-translator"><em>PNaCl translator</em></a> uses these abbreviations
+to convert the bit sequence back to the corresponding sequence of PNaCl records.
+As a result, all records have an abbreviation (user or default) associated with
+them.</p>
+<p>Conceptually, abbreviations are used to define how to pack the contents of
+records into bit sequences.  The main reason for defining abbreviations is to
+save space. The default abbreviations are simplistic and are intended to handle
+all possible records. The default abbreviations do not really worry about being
+efficient, in terms of the number of bits generated.</p>
+<p>By separating the concepts of PNaCl records and abbreviations, the notion of
+data compression is cleanly separated from semantic content. This allows
+different use cases to decide how much effort should be spent on compressing
+records.</p>
+<p>For a JIT compiler that produces bitcode, little (if any) compression should be
+applied. In fact, the API to the JIT may just be the records themselves.  The
+goal of a JIT is to perform the final translation to machine code as quickly as
+possible.</p>
+<p>On the other hand, when delivering across the web, one may want to compress the
+sequence of bits considerably, to reduce costs in delivering web pages. Note
+that <a class="reference internal" href="/native-client/devguide/devcycle/building.html#pnacl-compress"><em>pnacl-compress</em></a> is provided as part of the SDK to do
+this job.</p>
+<h2 id="data-model">Data Model</h2>
+<p>The data model for PNaCl bitcode is fixed at little-endian ILP32: pointers are
+32 bits in size. 64-bit integer types are also supported natively via the i64
+type (for example, a front-end can generate these from the C/C++ type <code>long
+long</code>).</p>
+<p>Integers are assumed to be modeled using two&#8217;s complement.  Floating point
+support is fixed at <a class="reference internal" href="/native-client/reference/pnacl-c-cpp-language-support.html#c-cpp-floating-point"><em>IEEE 754</em></a> 32-bit and 64-bit
+values (float and double, respectively).</p>
+<h2 id="pnacl-blocks">PNaCl Blocks</h2>
+<p>Blocks are used to organize records in the bitcode file.  The kinds of blocks
+defined in PNaClAsm are:</p>
+<dl class="docutils">
+<dt>Module block</dt>
+<dd>A top-level block defining the program. The <a class="reference internal" href="#link-for-module-block"><em>module
+block</em></a> defines global information used by the program,
+followed by function blocks defining the implementation of functions within
+the program. All other blocks (listed below) must appear within a module
+block.</dd>
+<dt>Types block</dt>
+<dd>The <a class="reference internal" href="#link-for-types-block-section"><em>types block</em></a> defines the set of types
+used by the program. All types used in the program must be defined in the
+types block.  These types consist of primitive types as well as high level
+constructs such as vectors and function signatures.</dd>
+<dt>Globals block</dt>
+<dd>The <a class="reference internal" href="#link-for-globals-block-section"><em>globals block</em></a> defines the set of
+addresses of global variables and constants used by the program. It also
+defines how each global (associated with the global address) is initialized.</dd>
+<dt>Valuesymtab block</dt>
+<dd>The <a class="reference internal" href="#link-for-valuesymtab-block-section"><em>valuesymtab block</em></a> defines
+textual names for external function addresses.</dd>
+<dt>Function block</dt>
+<dd>Each function (implemented) in a program has its own <a class="reference internal" href="#link-for-function-blocks-section"><em>function
+block</em></a> that defines the implementation of
+the corresponding function.</dd>
+<dt>Constants block</dt>
+<dd>Each implemented function that uses constants in its instructions defines a
+<a class="reference internal" href="#link-for-constants-block-section"><em>constants block</em></a>. Constants blocks
+appear within the corresponding function block of the implemented function.</dd>
+<dt>Abbreviations block</dt>
+<dd>Defines global abbreviations that are used to compress PNaCl records. The
+<a class="reference internal" href="#link-for-abbreviations-block-section"><em>abbreviations block</em></a> is segmented
+into multiple sections, one section for each kind of block. This block appears
+at the beginning of the module block.</dd>
+</dl>
+<p>This section is only intended as a high-level discussion of blocks. Later
+sections will dive more deeply into the constraints on how blocks must be laid
+out. This section only presents the overall concepts of what kinds of data are
+stored in each of the blocks.</p>
+<p>A PNaCl program consists of a <a class="reference internal" href="#link-for-header-record-section"><em>header
+record</em></a> and a <a class="reference internal" href="#link-for-module-block"><em>module
+block</em></a>. The header record defines a sequence of bytes
+uniquely identifying the file as a bitcode file. The module block defines the
+program to run.</p>
+<p>Each block, within a bitcode file, defines values. These values are associated
+with IDs. Each type of block defines different kinds of IDs.  The
+<a class="reference internal" href="#link-for-module-block"><em>module</em></a>,
+<a class="reference internal" href="#link-for-types-block-section"><em>types</em></a>,
+<a class="reference internal" href="#link-for-globals-block-section"><em>globals</em></a>, and
+<a class="reference internal" href="#link-for-abbreviations-block-section"><em>abbreviations</em></a> blocks define global
+identifiers, and only a single instance can appear.  The
+<a class="reference internal" href="#link-for-function-blocks-section"><em>function</em></a> and
+<a class="reference internal" href="#link-for-constants-block-section"><em>constant</em></a> blocks define local
+identifiers, and can have multiple instances (one for each implemented
+function).</p>
+<p>The only records in the module block that define values, are <a class="reference internal" href="#link-for-function-address-section"><em>function
+address</em></a> records.  Each function address
+record defines a different function address, and the <a class="reference internal" href="#link-for-function-type"><em>type
+signature</em></a> associated with that function address.</p>
+<p>Each <a class="reference internal" href="#link-for-function-blocks-section"><em>function block</em></a> defines the
+implementation of a single function. Each function block defines the
+intermediate representation of the function, consisting of basic blocks and
+instructions. If constants are used within instructions, they are defined in a
+<a class="reference internal" href="#link-for-constants-block-section"><em>constants block</em></a>, nested within the
+corresponding function block.</p>
+<p>All function blocks are associated with a corresponding function address. This
+association is positional rather than explicit. That is, the Nth function block
+in a module block corresponds to the Nth
+<a class="reference internal" href="#link-for-function-address-section"><em>defining</em></a> (rather than declared)
+function address record in the module block.</p>
+<p>Hence, within a function block, there is no explicit reference to the function
+address the block defines. For readability, PNaClAsm uses the corresponding
+function signature, associated with the corresponding function address record,
+even though that data does not appear in the corresponding records.</p>
+<h2 id="pnacl-records"><span id="link-for-pnacl-records"></span>PNaCl Records</h2>
+<p>A PNaCl record is a non-empty sequence of unsigned, 64-bit, integers. A record
+is identified by the record <em>code</em>, which is the first element in the
+sequence. Record codes are unique within a specific kind of block, but are not
+necessarily unique across different kinds of blocks. The record code acts as the
+variant discriminator (i.e. tag) within a block, to identify what kind of record
+it is.</p>
+<p>Record codes that are local to a specific kind of block are small values
+(starting from zero). In an ideal world, they would be a consecutive sequence of
+integers, starting at zero. However, the reality is that PNaCl records evolved
+over time (and actually started as <a class="reference external" href="http://llvm.org/docs/BitCodeFormat.html">LLVM records</a>).  For backward compatibility,
+obsolete numbers have not been reused, leaving gaps in the actual record code
+values used.</p>
+<p>Global record codes are record codes that have the same meaning in multiple
+kinds of blocks. To separate global record codes from local record codes, large
+values are used.  Currently there are four <a class="reference internal" href="#link-for-global-record-codes"><em>global record
+codes</em></a>.  To make these cases clear, and to leave
+ample room for future growth in PNaClAsm, these special records have record
+codes close to the value 2<sup>16</sup>. Note: Well-formed PNaCl bitcode files
+do not have record codes &gt;= 2<sup>16</sup>.</p>
+<p>A PNaCl record is denoted as follows:</p>
+<pre class="prettyprint">
+a: &lt;v0, v1, ... , vN&gt;
+</pre>
+<p>The value <code>v0</code> is the record code. The remaining values, <code>v1</code> through
+<code>vN</code>, are parameters that fill in additional information needed by the
+construct it represents. All records must have a record code. Hence, empty PNaCl
+records are not allowed. <code>a</code> is the index to the abbreviation used to convert
+the record to a bit sequence.</p>
+<p>While most records (for a given record code) have the same length, it is not
+true of all record codes. Some record codes can have arbitrary length. In
+particular, function type signatures, call instructions, phi instructions,
+switch instructions, and global variable initialization records all have
+variable length. The expected length is predefined and part of the PNaClAsm
+language. See the corresponding construct (associated with the record) to
+determine the expected length.</p>
+<p>The <em>PNaCl bitstream writer</em>, which converts records to bit sequences, does
+this by writing out the abbreviation index used to encode the record, followed
+by the contents of the record. The details of this are left to the section on
+<a class="reference internal" href="#link-for-abbreviations-section"><em>abbreviations</em></a>. However, at the record
+level, one important aspect of this appears in <a class="reference internal" href="#link-for-enter-block-record-section"><em>block
+enter</em></a> records.  These records must define
+how many bits are required to hold abbreviation indices associated with records
+of that block.</p>
+<h2 id="default-abbreviations"><span id="link-for-default-abbreviations"></span>Default Abbreviations</h2>
+<p>There are 4 predefined (default) abbreviation indices, used as the default
+abbreviations for PNaCl records. They are:</p>
+<dl class="docutils">
+<dt>0</dt>
+<dd>Abbreviation index for the abbreviation used to bit-encode an exit block
+record.</dd>
+<dt>1</dt>
+<dd>Abbreviation index for the abbreviation used to bit-encode an enter block
+record.</dd>
+<dt>2</dt>
+<dd>Abbreviation index for the abbreviation used to bit-encode a user-defined
+abbreviation. Note: User-defined abbreviations are also encoded as records,
+and hence need an abbreviation index to bit-encode them.</dd>
+<dt>3</dt>
+<dd>Abbreviation index for the default abbreviation to bit-encode all other
+records in the bitcode file.</dd>
+</dl>
+<p>A block may, in addition, define a list of block specific, user-defined,
+abbreviations (of length <code>U</code>). The number of bits <code>B</code> specified for an enter
+record must be sufficiently large such that:</p>
+<pre class="prettyprint">
+2**B &gt;= U + 4
+</pre>
+<p>In addition, the upper limit for <code>B</code> is <code>16</code>.</p>
+<p>PNaClAsm requires specifying the number of bits needed to read abbreviations as
+part of the enter block record. This allows the PNaCl bitcode reader/writer to
+use the specified number of bits to encode abbreviation indices.</p>
+<h2 id="pnacl-identifiers">PNaCl Identifiers</h2>
+<p>A program is defined by a <a class="reference internal" href="#link-for-module-block"><em>module block</em></a>. Blocks can
+be nested within other blocks, including the module block. Each block defines a
+sequence of records.</p>
+<p>Most of the records, within a block, also define unique values.  Each unique
+value is given a corresponding unique identifier (i.e. <em>ID</em>). In PNaClAsm, each
+kind of block defines its own kind of identifiers. The names of these
+identifiers are defined by concatenating a prefix character (<code>'&#64;'</code> or
+<code>'%'</code>), the kind of block (a single character), and a suffix index. The suffix
+index is defined by the positional location of the defined value within the
+records of the corresponding block. The indices are all zero based, meaning that
+the first defined value (within a block) is defined using index 0.</p>
+<p>Identifiers are categorized into two types, <em>local</em> and <em>global</em>.  Local
+identifiers are identifiers that are associated with the implementation of a
+single function. In that sense, they are local to the block they appear in.</p>
+<p>All other identifiers are global, and can appear in multiple blocks. This split
+is intentional. Global identifiers are used by multiple functions, and therefore
+must be known in all function implementations. Local identifiers only apply to a
+single function, and can be reused between functions.  The <a class="reference internal" href="/native-client/overview.html#link-for-pnacl-translator"><em>PNaCl
+translator</em></a> uses this separation to parallelize the
+compilation of functions.</p>
+<p>Note that local abbreviation identifiers are unique to the block they appear
+in. Global abbreviation identifiers are only unique to the block type they are
+defined for. Different block types can reuse global abbreviation identifiers.</p>
+<p>Global identifiers use the prefix character <code>'&#64;'</code> while local identifiers use
+the prefix character <code>'%'</code>.</p>
+<p>Note that by using positional location to define identifiers (within a block),
+the values defined in PNaCl bitcode files need not be explicitly included in the
+bitcode file. Rather, they are inferred by the (ordered) position of the record
+in the block.  This is also intentional. It is used to reduce the amount of data
+that must be (explicitly) passed to the <a class="reference internal" href="/native-client/overview.html#link-for-pnacl-translator"><em>PNaCl
+translator</em></a>, when downloaded into Chrome.</p>
+<p>In general, most of the records within blocks are assumed to be topologically
+sorted, putting value definitions before their uses.  This implies that records
+do not need to encode data if they can deduce the corresponding information from
+their uses.</p>
+<p>The most common use of this is that many instructions use the type of their
+operands to determine the type of the instruction. Again, this is
+intentional. It allows less information to be stored.</p>
+<p>However, for function blocks (which define instructions), a topological sort may
+not exist. Loop carried value dependencies simply do not allow topologically
+sorting. To deal with this, function blocks have a notion of (instruction value)
+<a class="reference internal" href="#link-for-forward-type-declaration-section"><em>forward type
+declarations</em></a>. These declarations
+must appear before any of the uses of that value, if the (instruction) value is
+defined later in the function than its first use.</p>
+<p>The kinds of identifiers used in PNaClAsm are:</p>
+<dl class="docutils">
+<dt>&#64;a</dt>
+<dd>Global abbreviation identifier.</dd>
+<dt>%a</dt>
+<dd>Local abbreviation identifier.</dd>
+<dt>%b</dt>
+<dd>Function basic block identifier.</dd>
+<dt>%c</dt>
+<dd>Function constant identifier.</dd>
+<dt>&#64;f</dt>
+<dd>Global function address identifier.</dd>
+<dt>&#64;g</dt>
+<dd>Global variable/constant address identifier.</dd>
+<dt>%p</dt>
+<dd>Function parameter identifier.</dd>
+<dt>&#64;t</dt>
+<dd>Global type identifier.</dd>
+<dt>%v</dt>
+<dd>Value generated by an instruction in a function block.</dd>
+</dl>
+<h2 id="conventions-for-describing-records">Conventions For Describing Records</h2>
+<p>PNaClAsm is the textual representation of <a class="reference internal" href="#link-for-pnacl-records"><em>PNaCl
+records</em></a>.  Each PNaCl record is described by a
+corresponding PNaClAsm construct. These constructs are described using syntax
+rules, and semantics on how they are converted to records. Along with the rules,
+is a notion of <a class="reference internal" href="#link-for-global-state-section"><em>global state</em></a>. The global
+state is updated by syntax rules.  The purpose of the global state is to track
+positional dependencies between records.</p>
+<p>For each PNaCl construct, we define multiple sections. The <strong>Syntax</strong>
+section defines a syntax rule for the construct. The <strong>Record</strong> section
+defines the corresponding record associated with the syntax rule. The
+<strong>Semantics</strong> section describes the semantics associated with the record, in
+terms of data within the global state and the corresponding syntax. It also
+includes other high-level semantics, when appropriate.</p>
+<p>The <strong>Constraints</strong> section (if present) defines any constraints associated
+with the construct, including the global state. The <strong>Updates</strong> section (if
+present) defines how the global state is updated when the construct is
+processed.  The <strong>Examples</strong> section gives one or more examples of using the
+corresponding PNaClAsm construct.</p>
+<p>Some semantics sections use functions to compute values. The meaning of
+functions can be found in <a class="reference internal" href="#link-for-support-functions-section"><em>support
+functions</em></a>.</p>
+<p>The syntax rule may include the
+<a class="reference internal" href="#link-for-abbreviations-section"><em>abbreviation</em></a> to use, when converting to a
+bit-sequence.  These abbreviations, if allowed, are at the end of the construct,
+and enclosed in <code>&lt;</code> and <code>&gt;</code> brackets. These abbreviations are optional in
+the syntax, and can be omitted. If they are used, the abbreviation brackets are
+part of the actual syntax of the construct. If the abbreviation is omitted, the
+default abbreviation index is used. To make it clear that abbreviations are
+optional, syntax rules separate abbreviations using plenty of whitespace.</p>
+<p>Within a syntax rule, lower case characters are literal values. Sequences of
+upper case alphanumeric characters are named values.  If we mix lower and upper
+case letters within a name appearing in a syntax rule, the lower case letters
+are literal while the upper case sequence of alphanumeric characters denote rule
+specific values.  The valid values for each of these names will be defined in
+the corresponding semantics and constraints subsections.</p>
+<p>For example, consider the following syntax rule:</p>
+<pre class="prettyprint">
+%vN = add T O1, O2;                            &lt;A&gt;
+</pre>
+<p>This rule defines a PNaClAsm add instruction.  This construct defines an
+instruction that adds two values (<code>O1</code> and <code>O2</code>) to generate instruction
+value <code>%vN</code>. The types of the arguments, and the result, are all of type
+<code>T</code>. If abbreviation ID <code>A</code> is present, the record is encoded using that
+abbreviation. Otherwise the corresponding <a class="reference internal" href="#link-for-default-abbreviations"><em>default abbreviation
+index</em></a> is used.</p>
+<p>To be concrete, the syntactic rule above defines the structure of the following
+PNaClAsm examples:</p>
+<pre class="prettyprint">
+%v10 = add i32 %v1, %v2;  &lt;&#64;a5&gt;
+%v11 = add i32 %v10, %v3;
+</pre>
+<p>In addition to specifying the syntax, each syntax rule can also also specify the
+contents of the corresponding record in the corresponding record subsection. In
+simple cases, the elements of the corresponding record are predefined (literal)
+constants. Otherwise the record element is an identifier from another subsection
+associated with the construct.</p>
+<h2 id="factorial-example">Factorial Example</h2>
+<p>This section provides a simple example of a PNaCl bitcode file. Its contents
+describe a bitcode file that only defines a function to compute the factorial
+value of a number.</p>
+<p>In C, the factorial function can be defined as:</p>
+<pre class="prettyprint">
+int fact(int n) {
+  if (n == 1) return 1;
+  return n * fact(n-1);
+}
+</pre>
+<p>Compiling this into a PNaCl bitcode file, and dumping out its contents with
+utility <a class="reference internal" href="/native-client/devguide/devcycle/building.html#pnacl-bcdis"><em>pnacl-bcdis</em></a>, the corresponding output is:</p>
+<pre class="prettyprint">
+  0:0|&lt;65532, 80, 69, 88, 69, 1, 0,|Magic Number: 'PEXE' (80, 69, 88, 69)
+     | 8, 0, 17, 0, 4, 0, 2, 0, 0, |PNaCl Version: 2
+     | 0&gt;                          |
+ 16:0|1: &lt;65535, 8, 2&gt;             |module {  // BlockID = 8
+ 24:0|  3: &lt;1, 1&gt;                  |  version 1;
+ 26:4|  1: &lt;65535, 0, 2&gt;           |  abbreviations {  // BlockID = 0
+ 36:0|  0: &lt;65534&gt;                 |  }
+ 40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+ 48:0|    3: &lt;1, 4&gt;                |    count 4;
+ 50:4|    3: &lt;7, 32&gt;               |    &#64;t0 = i32;
+ 53:6|    3: &lt;2&gt;                   |    &#64;t1 = void;
+ 55:4|    3: &lt;21, 0, 0, 0&gt;         |    &#64;t2 = i32 (i32);
+ 59:4|    3: &lt;7, 1&gt;                |    &#64;t3 = i1;
+ 62:0|  0: &lt;65534&gt;                 |  }
+ 64:0|  3: &lt;8, 2, 0, 0, 0&gt;         |  define external i32 &#64;f0(i32);
+ 68:6|  1: &lt;65535, 19, 2&gt;          |  globals {  // BlockID = 19
+ 76:0|    3: &lt;5, 0&gt;                |    count 0;
+ 78:4|  0: &lt;65534&gt;                 |  }
+ 80:0|  1: &lt;65535, 14, 2&gt;          |  valuesymtab {  // BlockID = 14
+ 88:0|    3: &lt;1, 0, 102, 97, 99,   |    &#64;f0 : &quot;fact&quot;;
+     |        116&gt;                 |
+ 96:4|  0: &lt;65534&gt;                 |  }
+100:0|  1: &lt;65535, 12, 2&gt;          |  function i32 &#64;f0(i32 %p0) {
+     |                             |                   // BlockID = 12
+108:0|    3: &lt;1, 3&gt;                |    blocks 3;
+110:4|    1: &lt;65535, 11, 2&gt;        |    constants {  // BlockID = 11
+120:0|      3: &lt;1, 0&gt;              |      i32:
+122:4|      3: &lt;4, 2&gt;              |        %c0 = i32 1;
+125:0|    0: &lt;65534&gt;               |      }
+     |                             |  %b0:
+128:0|    3: &lt;28, 2, 1, 32&gt;        |    %v0 = icmp eq i32 %p0, %c0;
+132:6|    3: &lt;11, 1, 2, 1&gt;         |    br i1 %v0, label %b1, label %b2;
+     |                             |  %b1:
+136:6|    3: &lt;10, 2&gt;               |    ret i32 %c0;
+     |                             |  %b2:
+139:2|    3: &lt;2, 3, 2, 1&gt;          |    %v1 = sub i32 %p0, %c0;
+143:2|    3: &lt;34, 0, 5, 1&gt;         |    %v2 = call i32 &#64;f0(i32 %v1);
+148:0|    3: &lt;2, 5, 1, 2&gt;          |    %v3 = mul i32 %p0, %v2;
+152:0|    3: &lt;10, 1&gt;               |    ret i32 %v3;
+154:4|  0: &lt;65534&gt;                 |  }
+156:0|0: &lt;65534&gt;                   |}
+</pre>
+<p>Note that there are three columns in this output. The first column contains the
+bit positions of the records within the bitcode file. The second column contains
+the sequence of records within the bitcode file. The third column contains the
+corresponding PNaClAsm program.</p>
+<p>Bit positions are defined by a pair <code>B:N</code>. <code>B</code> is the number of bytes, while
+<code>N</code> is the bit offset within the <code>B</code>-th byte. Hence, the bit position (in
+bits) is:</p>
+<pre class="prettyprint">
+B*8 + N
+</pre>
+<p>Hence, the first record is at bit offset <code>0</code> (<code>0*8+0</code>). The second record is
+at bit offset <code>128</code> (<code>16*8+0</code>).  The third record is at bit offset <code>192</code>
+(<code>24*8+0</code>).  The fourth record is at bit offset <code>212</code> (<code>26*8+4</code>).</p>
+<p>The <a class="reference internal" href="#link-for-header-record-section"><em>header record</em></a> is a sequence of 16
+bytes, defining the contents of the first 16 bytes of the bitcode file. These
+bytes never change, and are expected for all version 2, PNaCl bitcode files. The
+first four bytes define the magic number of the file, i.e. &#8216;PEXE&#8217;. All PEXE
+bitcode files begin with these four bytes.</p>
+<p>All but the header record has an abbreviation index associated with it. Since no
+user-defined abbreviations are provided, all records were converted to
+bit sequences using default abbreviations.</p>
+<p>The types block (starting at bit address <code>40:0</code>), defines 4 types: <code>i1</code>,
+<code>i32</code>, <code>void</code>, and function signature <code>i32 (i32)</code>.</p>
+<p>Bit address <code>64:0</code> declares the factorial function address <code>&#64;f0</code>, and its
+corresponding type signature. Bit address <code>88:0</code> associates the name <code>fact</code>
+with function address <code>&#64;f0</code>.</p>
+<p>Bit address <code>100:0</code> defines the function block that implements function
+<code>fact</code>. The entry point is <code>%b0</code> (at bit address <code>128:0</code>). It uses the
+32-bit integer constant <code>1</code> (defined at bit addresses <code>122:4</code>). Bit address
+<code>128:0</code> defines an equality comparison of the argument <code>%p0</code> with <code>1</code>
+(constant <code>%c0</code>). Bit address <code>132:6</code> defines a conditional branch. If the
+result of the previous comparison (<code>%v0</code>) is true, the program will branch to
+block <code>%b1</code>. Otherwise it will branch to block <code>%b2</code>.</p>
+<p>Bit address <code>136:6</code> returns constant <code>1</code> (<code>%c0</code>) when the input parameter
+is 1.  Instructions between bit address <code>139:2</code> and <code>154:4</code> compute and
+return <code>n * fact(n-1)</code>.</p>
+<h2 id="road-map">Road Map</h2>
+<p>At this point, this document transitions from basic concepts to the details
+of how records should be formatted. This section defines the road map to
+the remaining sections in this document.</p>
+<p>Many records have implicit information associated with them, and must be
+maintained across records. <a class="reference internal" href="#link-for-global-state-section"><em>Global state</em></a>
+describes how this implicit information is modeled. In addition, there are
+various <a class="reference internal" href="#link-for-support-functions-section"><em>support functions</em></a> that are
+used to define the semantics of records, and how they update the global state.</p>
+<p>There are just a handful of global records (records that either don&#8217;t appear in
+any block, or can appear in all blocks).  <a class="reference internal" href="#link-for-global-record-codes"><em>Global
+records</em></a> describes these records. This includes
+the block delimiter records <a class="reference internal" href="#link-for-enter-block-record-section"><em>enter</em></a>
+and <a class="reference internal" href="#link-for-exit-block-record-section"><em>exit</em></a> that define block
+boundaries.</p>
+<p>PNaClAsm is a strongly typed language, and most block values are typed.
+<a class="reference internal" href="#link-for-types-block-section"><em>types</em></a> describes the set of legal types, and
+how to define types.</p>
+<p>Global variables and their initializers are presented in the <a class="reference internal" href="#link-for-globals-block-section"><em>globals
+block</em></a>. <a class="reference internal" href="#link-for-function-address-section"><em>Function
+addresses</em></a> are part of the <a class="reference internal" href="#link-for-module-block"><em>module
+block</em></a>, but must be defined before any global variables.</p>
+<p>Names to be associated with global variables and function addresses, are defined
+in the <a class="reference internal" href="#link-for-valuesymtab-block-section"><em>valuesymtab block</em></a>, and must
+appear after the <a class="reference internal" href="#link-for-globals-block-section"><em>globals block</em></a>, but
+before any <a class="reference internal" href="#link-for-function-blocks-section"><em>function definition</em></a>.</p>
+<p>The <a class="reference internal" href="#link-for-module-block"><em>module block</em></a> is the top-most block, and all
+other blocks must appear within the module block. The module block defines the
+executable in the bitcode file.</p>
+<p>Constants used within a <a class="reference internal" href="#link-for-function-blocks-section"><em>function
+definition</em></a> must be defined using a
+<a class="reference internal" href="#link-for-constants-block-section"><em>constants block</em></a>.  Each function
+definition is defined by a <a class="reference internal" href="#link-for-function-blocks-section"><em>function
+block</em></a> and constant blocks can only appear
+within function blocks. Constants defined within a constant block can only be
+used in the enclosing function block.</p>
+<p>Function definitions are defined by a sequence of instructions. There are
+several types of instructions.</p>
+<p>A <a class="reference internal" href="#link-for-terminator-instruction-section"><em>terminator instruction</em></a> is the
+last instruction in a <a class="reference internal" href="#link-for-function-blocks-section"><em>basic block</em></a>, and
+is a branch, return, or unreachable instruction.</p>
+<p>There are <a class="reference internal" href="#link-for-integer-binary-instructions"><em>integer</em></a> and
+<a class="reference internal" href="#link-for-floating-point-binary-instructions"><em>floating point</em></a> binary
+operations.  Integer binary instructions include both arithmetic and logical
+operations. Floating point instructions define arithmetic operations.</p>
+<p>There are also <a class="reference internal" href="#link-for-memory-creation-and-access-instructions"><em>memory
+access</em></a> instructions that
+allow one to load and store values. That section also includes how to define
+local variables using the <a class="reference internal" href="#link-for-alloca-instruction"><em>alloca
+instruction</em></a>.</p>
+<p>One can also convert integer and floating point values using <a class="reference internal" href="#link-for-conversion-instructions"><em>conversion
+instructions</em></a>.</p>
+<p><a class="reference internal" href="#link-for-compare-instructions"><em>Comparison instructions</em></a>
+allow you to compare values.</p>
+<p><a class="reference internal" href="#link-for-vector-instructions"><em>Vector instructions</em></a> allow you to build and
+update vectors. Corresponding <a class="reference internal" href="#link-for-intrinsic-functions-section"><em>intrinsic
+functions</em></a>, as well as
+<a class="reference internal" href="#link-for-integer-binary-instructions"><em>integer</em></a> and <a class="reference internal" href="#link-for-floating-point-binary-instructions"><em>floating
+point</em></a> binary instructions allow
+you to apply operations to vectors.</p>
+<p>In addition, <a class="reference internal" href="#link-for-other-pnaclasm-instructions"><em>other instructions</em></a> are
+available. This includes function and procedure calls.</p>
+<p>There are also <a class="reference internal" href="#link-for-memory-blocks-and-alignment-section"><em>memory
+alignment</em></a> issues that should be
+considered for global and local variables, as well as load and store
+instructions.</p>
+<p>Finally, how to pack records is described in the
+<a class="reference internal" href="#link-for-abbreviations-section"><em>abbreviations</em></a> section.</p>
+<h2 id="global-state"><span id="link-for-global-state-section"></span>Global State</h2>
+<p>This section describes the global state associated with PNaClAsm. It is used to
+define contextual data that is carried between records.</p>
+<p>In particular, PNaClAsm is a strongly typed language, and hence, we must track
+the type associated with values. Subsection <a class="reference internal" href="#link-to-typing-functions"><em>Typing Functions</em></a>
+describes the functions used to maintain typing information associated with
+values.</p>
+<p>Values are implicitly ordered within a block, and the indices associated with
+the values do not appear in records.  Rather, ID counters are used to figure out
+what corresponding ID name is associated with a value generating record.
+Subsection <a class="reference internal" href="#link-to-id-counters"><em>ID Counters</em></a> defines counters maintained in the global
+state.</p>
+<p>In several blocks, one of the first records in the block defines how many values
+are defined in in the block. The main purpose of these counts is to communicate
+to the <a class="reference internal" href="/native-client/overview.html#link-for-pnacl-translator"><em>PNaCl translator</em></a> space requirements, or
+a limit so that it can detect bad references to values. Subsection
+<a class="reference internal" href="#link-for-size-variables"><em>Size Variables</em></a> defines variables that hold size definitions in
+the corresponding records.</p>
+<p>Finally, the function and constants block contain implicit context between
+records in those blocks. Subsection <a class="reference internal" href="#link-to-other-variables"><em>Other Variables</em></a> defines the
+variables that contain this implicit context.</p>
+<h3 id="typing-functions"><span id="link-to-typing-functions"></span>Typing Functions</h3>
+<p>Associated with most identifiers is a type. This type defines what type the
+corresponding value has. It is defined by the (initially empty) map:</p>
+<pre class="prettyprint">
+TypeOf: ID -&gt; Type
+</pre>
+<p>For each type in the <a class="reference internal" href="#link-for-types-block-section"><em>types block</em></a>, a
+corresponding inverse map:</p>
+<pre class="prettyprint">
+TypeID: Type -&gt; ID
+</pre>
+<p>is maintained to convert syntactic types to the corresponding type ID.</p>
+<p>Note: This document assumes that map <code>TypeID</code> is automatically maintained
+during updates to map <code>TypeOf</code> (when given a type <code>ID</code>). Hence, <em>Updates</em>
+subsections will not contain assignments to this map.</p>
+<p>Associated with each function identifier is its <a class="reference internal" href="#link-for-function-type"><em>type
+signature</em></a>. This is different than the type of the
+function identifier, since function identifiers represent the function address
+which is a pointer (and pointers are always implemented as a 32-bit integer
+following the ILP32 data model).</p>
+<p>Function type signatures are maintained using:</p>
+<pre class="prettyprint">
+TypeOfFcn: ID -&gt; Type
+</pre>
+<p>In addition, if a function address has an implementing block, there is a
+corresponding implementation associated with the function address.  To indicate
+which function addresses have implementations, we use the set:</p>
+<pre class="prettyprint">
+DefiningFcnIDs: set(ID)
+</pre>
+<h3 id="link-to-id-counters"><span id="id-counters"></span>ID Counters</h3>
+<p>Each block defines one or more kinds of values.  Value indices are generated
+sequentially, starting at zero. To capture this, the following counters are
+defined:</p>
+<dl class="docutils">
+<dt>NumTypes</dt>
+<dd>The number of types defined so far (in the <a class="reference internal" href="#link-for-types-block-section"><em>types
+block</em></a>).</dd>
+<dt>NumFuncAddresses</dt>
+<dd>The number of function addresses defined so far (in the <a class="reference internal" href="#link-for-module-block"><em>module
+block</em></a>).</dd>
+<dt>NumGlobalAddresses</dt>
+<dd>The number of global variable/constant addresses defined so far (in the
+<a class="reference internal" href="#link-for-globals-block-section"><em>globals block</em></a>).</dd>
+<dt>NumParams</dt>
+<dd>The number of parameters defined for a function. Note: Unlike other counters,
+this value is set once, at the beginning of the corresponding <a class="reference internal" href="#link-for-function-blocks-section"><em>function
+block</em></a>, based on the type signature
+associated with the function.</dd>
+<dt>NumFcnConsts</dt>
+<dd>The number of constants defined in a function so far (in the corresponding
+nested <a class="reference internal" href="#link-for-constants-block-section"><em>constants block</em></a>).</dd>
+<dt>NumBasicBlocks</dt>
+<dd>The number of basic blocks defined so far (within a <a class="reference internal" href="#link-for-function-blocks-section"><em>function
+block</em></a>).</dd>
+<dt>NumValuedInsts</dt>
+<dd>The number of instructions, generating values, defined so far (within a
+<a class="reference internal" href="#link-for-function-blocks-section"><em>function block</em></a>).</dd>
+</dl>
+<h3 id="size-variables"><span id="link-for-size-variables"></span>Size Variables</h3>
+<p>A number of blocks define expected sizes of constructs. These sizes are recorded
+in the following size variables:</p>
+<dl class="docutils">
+<dt>ExpectedBasicBlocks</dt>
+<dd>The expected <a class="reference internal" href="#link-for-basic-blocks-count"><em>number of basic blocks</em></a> within
+a function implementation.</dd>
+<dt>ExpectedTypes</dt>
+<dd>The expected <a class="reference internal" href="#link-for-types-count-record"><em>number of types</em></a> defined in
+the types block.</dd>
+<dt>ExpectedGlobals</dt>
+<dd>The expected <a class="reference internal" href="#link-for-globals-count-record"><em>number of global variable/constant
+addresses</em></a> in the globals block.</dd>
+<dt>ExpectedInitializers</dt>
+<dd>The expected <a class="reference internal" href="#link-for-compound-initializer"><em>number of initializers</em></a> for
+a global variable/constant address in the globals block.</dd>
+</dl>
+<p>It is assumed that the corresponding <a class="reference internal" href="#link-to-id-counters"><em>ID counters</em></a> are
+always smaller than the corresponding size variables (except
+ExpectedInitializers). That is:</p>
+<pre class="prettyprint">
+NumBasicBlocks &lt; ExpectedBasicBlocks
+NumTypes &lt; ExpectedTypes
+NumGlobalAddresses &lt; ExpectedGlobals
+</pre>
+<h3 id="other-variables"><span id="link-to-other-variables"></span>Other Variables</h3>
+<dl class="docutils">
+<dt>EnclosingFcnID</dt>
+<dd>The function ID of the function block being processed.</dd>
+<dt>ConstantsSetType</dt>
+<dd>Holds the type associated with the last <a class="reference internal" href="#link-for-constants-set-type-record"><em>set type
+record</em></a> in the constants block. Note: at
+the beginning of each constants block, this variable is set to type void.</dd>
+</dl>
+<h2 id="global-records"><span id="link-for-global-record-codes"></span>Global Records</h2>
+<p>Global records are records that can appear in any block. These records have
+the same meaning in multiple kinds of blocks.</p>
+<p>There are four global PNaCl records, each having its own record code. These
+global records are:</p>
+<dl class="docutils">
+<dt>Header</dt>
+<dd>The <a class="reference internal" href="#link-for-header-record-section"><em>header record</em></a> is the first record
+of a PNaCl bitcode file, and identifies the file&#8217;s magic number, as well as
+the bitcode version it uses. The record defines the sequence of bytes that
+make up the header and uniquely identifies the file as a PNaCl bitcode file.</dd>
+<dt>Enter</dt>
+<dd>An <a class="reference internal" href="#link-for-enter-block-record-section"><em>enter record</em></a> defines the
+beginning of a block. Since blocks can be nested, one can appear inside other
+blocks, as well as at the top level.</dd>
+<dt>Exit</dt>
+<dd>An <a class="reference internal" href="#link-for-exit-block-record-section"><em>exit record</em></a> defines the end of a
+block. Hence, it must appear in every block, to end the block.</dd>
+<dt>Abbreviation</dt>
+<dd>An <a class="reference internal" href="#link-for-abbreviation-record"><em>abbreviation record</em></a> defines a
+user-defined abbreviation to be applied to records within blocks.
+Abbreviation records appearing in the abbreviations block define global
+abbreviations. All other abbreviations are local to the block they appear in,
+and can only be used in that block.</dd>
+</dl>
+<p>All global records can&#8217;t have user-defined abbreviations associated with
+them. The <a class="reference internal" href="#link-for-default-abbreviations"><em>default abbreviation</em></a> is always
+used.</p>
+<h3 id="header-record"><span id="link-for-header-record-section"></span>Header Record</h3>
+<p>The header record must be the first record in the file. It is the only record in
+the bitcode file that doesn&#8217;t have a corresponding construct in PNaClAsm.  In
+addition, no abbreviation index is associated with it.</p>
+<p><strong>Syntax</strong>:</p>
+<p>There is no syntax for header records in PNaClAsm.</p>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+&lt;65532, 80, 69, 88, 69, 1, 0, 8, 0, 17, 0, 4, 0, 2, 0, 0, 0&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The header record defines the initial sequence of bytes that must appear at the
+beginning of all (PNaCl bitcode version 2) files. That sequence is the list of
+bytes inside the record (excluding the record code). As such, it uniquely
+identifies all PNaCl bitcode files.</p>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+0:0|&lt;65532, 80, 69, 88, 69, 1, 0,|Magic Number: 'PEXE' (80, 69, 88, 69)
+   | 8, 0, 17, 0, 4, 0, 2, 0, 0, |PNaCl Version: 2
+   | 0&gt;                          |
+</pre>
+<h3 id="enter-block-record"><span id="link-for-enter-block-record-section"></span>Enter Block Record</h3>
+<p>Block records can be top-level, as well as nested in other blocks. Blocks must
+begin with an <em>enter</em> record, and end with an
+<a class="reference internal" href="#link-for-exit-block-record-section"><em>exit</em></a> record.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+N {                                             &lt;B&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+1: &lt;65535, ID, B&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>Enter block records define the beginning of a block.  <code>B</code>, if present, is the
+number of bits needed to represent all possible abbreviation indices used within
+the block. If omitted, <code>B=2</code> is assumed.</p>
+<p>The block <code>ID</code> value is dependent on the name <code>N</code>. Valid names and
+corresponding <code>BlockID</code> values are defined as follows:</p>
+<table border="1" class="docutils">
+<colgroup>
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">N</th>
+<th class="head">Block ID</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>abbreviations</td>
+<td>0</td>
+</tr>
+<tr class="row-odd"><td>constants</td>
+<td>11</td>
+</tr>
+<tr class="row-even"><td>function</td>
+<td>12</td>
+</tr>
+<tr class="row-odd"><td>globals</td>
+<td>19</td>
+</tr>
+<tr class="row-even"><td>module</td>
+<td>8</td>
+</tr>
+<tr class="row-odd"><td>types</td>
+<td>17</td>
+</tr>
+<tr class="row-even"><td>valuesymtab</td>
+<td>14</td>
+</tr>
+</tbody>
+</table>
+<p>Note: For readability, PNaClAsm defines a more readable form of a function block
+enter record.  See <a class="reference internal" href="#link-for-function-blocks-section"><em>function blocks</em></a> for
+more details.</p>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+16:0|1: &lt;65535, 8, 2&gt;             |module {  // BlockID = 8
+24:0|  3: &lt;1, 1&gt;                  |  version 1;
+26:4|  1: &lt;65535, 0, 2&gt;           |  abbreviations {  // BlockID = 0
+36:0|  0: &lt;65534&gt;                 |  }
+40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+48:0|    3: &lt;1, 2&gt;                |    count 2;
+50:4|    3: &lt;2&gt;                   |    &#64;t0 = void;
+52:2|    3: &lt;21, 0, 0&gt;            |    &#64;t1 = void ();
+55:4|  0: &lt;65534&gt;                 |  }
+56:0|  3: &lt;8, 1, 0, 1, 0&gt;         |  declare external void &#64;f0();
+60:6|  1: &lt;65535, 19, 2&gt;          |  globals {  // BlockID = 19
+68:0|    3: &lt;5, 0&gt;                |    count 0;
+70:4|  0: &lt;65534&gt;                 |  }
+72:0|0: &lt;65534&gt;                   |}
+</pre>
+<h3 id="exit-block-record"><span id="link-for-exit-block-record-section"></span>Exit Block Record</h3>
+<p>Block records can be top-level, as well as nested, records. Blocks must begin
+with an <a class="reference internal" href="#link-for-enter-block-record-section"><em>enter</em></a> record, and end with
+an <em>exit</em> record.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+}
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+0: &lt;65534&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>All exit records are identical, no matter what block they are ending. An exit
+record defines the end of the block.</p>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+16:0|1: &lt;65535, 8, 2&gt;             |module {  // BlockID = 8
+24:0|  3: &lt;1, 1&gt;                  |  version 1;
+26:4|  1: &lt;65535, 0, 2&gt;           |  abbreviations {  // BlockID = 0
+36:0|  0: &lt;65534&gt;                 |  }
+40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+48:0|    3: &lt;1, 2&gt;                |    count 2;
+50:4|    3: &lt;2&gt;                   |    &#64;t0 = void;
+52:2|    3: &lt;21, 0, 0&gt;            |    &#64;t1 = void ();
+55:4|  0: &lt;65534&gt;                 |  }
+56:0|  3: &lt;8, 1, 0, 1, 0&gt;         |  declare external void &#64;f0();
+60:6|  1: &lt;65535, 19, 2&gt;          |  globals {  // BlockID = 19
+68:0|    3: &lt;5, 0&gt;                |    count 0;
+70:4|  0: &lt;65534&gt;                 |  }
+72:0|0: &lt;65534&gt;                   |}
+</pre>
+<h3 id="abbreviation-record"><span id="link-for-abbreviation-record"></span>Abbreviation Record</h3>
+<p>Abbreviation records define abbreviations. See
+<a class="reference internal" href="#link-for-abbreviations-section"><em>abbreviations</em></a> for details on how
+abbreviations should be written. This section only presents the mechanical
+details for converting an abbreviation into a PNaCl record.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+A = abbrev &lt;E1, ... , EM&gt;;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+2: &lt;65533, M, EE1, ... , EEM&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>Defines an abbreviation <code>A</code> as the sequence of encodings <code>E1</code> through
+<code>EM</code>.  If the abbreviation appears within the <a class="reference internal" href="#link-for-abbreviations-block-section"><em>abbreviations
+block</em></a>, <code>A</code> must be a global
+abbreviation. Otherwise, <code>A</code> must be a local abbreviation.</p>
+<p>Abbreviations within a block (or a section within the abbreviations block), must
+be enumerated in order, starting at index <code>0</code>.</p>
+<p>Valid encodings <code>Ei</code>, and the corresponding sequence of (unsigned) integers
+<code>EEi</code>, ( for <code>1 &lt;= i &lt;= M</code>) are defined by the following table:</p>
+<table border="1" class="docutils">
+<colgroup>
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">Ei</th>
+<th class="head">EEi</th>
+<th class="head">Form</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>C</td>
+<td>1, C</td>
+<td>Literal C in corresponding position in record.</td>
+</tr>
+<tr class="row-odd"><td>fixed(N)</td>
+<td>0, 1, N</td>
+<td>Encode value as a fixed sequence of N bits.</td>
+</tr>
+<tr class="row-even"><td>vbr(N)</td>
+<td>0, 2, N</td>
+<td>Encode value using a variable bit rate of N.</td>
+</tr>
+<tr class="row-odd"><td>char6</td>
+<td>0, 4</td>
+<td>Encode value as 6-bit char containing
+characters [a-zA-Z0-9._].</td>
+</tr>
+<tr class="row-even"><td>array</td>
+<td>0, 3</td>
+<td>Allow zero or more of the succeeding abbreviation.</td>
+</tr>
+</tbody>
+</table>
+<p>Note that &#8216;array&#8217; can only appear as the second to last element in the
+abbreviation.  Notationally, <code>array(EM)</code> is used in place of <code>array</code> and
+<code>EM</code>, the last two entries in an abbreviation.</p>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+  0:0|&lt;65532, 80, 69, 88, 69, 1, 0,|Magic Number: 'PEXE' (80, 69, 88, 69)
+     | 8, 0, 17, 0, 4, 0, 2, 0, 0, |PNaCl Version: 2
+     | 0&gt;                          |
+ 16:0|1: &lt;65535, 8, 2&gt;             |module {  // BlockID = 8
+ 24:0|  3: &lt;1, 1&gt;                  |  version 1;
+ 26:4|  1: &lt;65535, 0, 2&gt;           |  abbreviations {  // BlockID = 0
+ 36:0|    1: &lt;1, 14&gt;               |    valuesymtab:
+ 38:4|    2: &lt;65533, 4, 0, 1, 3, 0,|      &#64;a0 = abbrev &lt;fixed(3), vbr(8),
+     |        2, 8, 0, 3, 0, 1, 8&gt; |                   array(fixed(8))&gt;;
+ 43:2|    2: &lt;65533, 4, 1, 1, 0, 2,|      &#64;a1 = abbrev &lt;1, vbr(8),
+     |        8, 0, 3, 0, 1, 7&gt;    |                   array(fixed(7))&gt;;
+ 48:0|    2: &lt;65533, 4, 1, 1, 0, 2,|      &#64;a2 = abbrev &lt;1, vbr(8),
+     |        8, 0, 3, 0, 4&gt;       |                   array(char6)&gt;;
+ 52:1|    2: &lt;65533, 4, 1, 2, 0, 2,|      &#64;a3 = abbrev &lt;2, vbr(8),
+     |        8, 0, 3, 0, 4&gt;       |                   array(char6)&gt;;
+ 56:2|    1: &lt;1, 11&gt;               |    constants:
+ 58:6|    2: &lt;65533, 2, 1, 1, 0, 1,|      &#64;a0 = abbrev &lt;1, fixed(2)&gt;;
+     |        2&gt;                   |
+ 61:7|    2: &lt;65533, 2, 1, 4, 0, 2,|      &#64;a1 = abbrev &lt;4, vbr(8)&gt;;
+     |        8&gt;                   |
+ 65:0|    2: &lt;65533, 2, 1, 4, 1, 0&gt;|      &#64;a2 = abbrev &lt;4, 0&gt;;
+ 68:1|    2: &lt;65533, 2, 1, 6, 0, 2,|      &#64;a3 = abbrev &lt;6, vbr(8)&gt;;
+     |        8&gt;                   |
+ 71:2|    1: &lt;1, 12&gt;               |    function:
+ 73:6|    2: &lt;65533, 4, 1, 20, 0,  |      &#64;a0 = abbrev &lt;20, vbr(6), vbr(4),
+     |        2, 6, 0, 2, 4, 0, 2, |                   vbr(4)&gt;;
+     |        4&gt;                   |
+ 79:1|    2: &lt;65533, 4, 1, 2, 0, 2,|      &#64;a1 = abbrev &lt;2, vbr(6), vbr(6),
+     |        6, 0, 2, 6, 0, 1, 4&gt; |                   fixed(4)&gt;;
+ 84:4|    2: &lt;65533, 4, 1, 3, 0, 2,|      &#64;a2 = abbrev &lt;3, vbr(6),
+     |        6, 0, 1, 2, 0, 1, 4&gt; |                   fixed(2), fixed(4)&gt;;
+ 89:7|    2: &lt;65533, 1, 1, 10&gt;     |      &#64;a3 = abbrev &lt;10&gt;;
+ 91:7|    2: &lt;65533, 2, 1, 10, 0,  |      &#64;a4 = abbrev &lt;10, vbr(6)&gt;;
+     |        2, 6&gt;                |
+ 95:0|    2: &lt;65533, 1, 1, 15&gt;     |      &#64;a5 = abbrev &lt;15&gt;;
+ 97:0|    2: &lt;65533, 3, 1, 43, 0,  |      &#64;a6 = abbrev &lt;43, vbr(6),
+     |        2, 6, 0, 1, 2&gt;       |                   fixed(2)&gt;;
+101:2|    2: &lt;65533, 4, 1, 24, 0,  |      &#64;a7 = abbrev &lt;24, vbr(6), vbr(6),
+     |        2, 6, 0, 2, 6, 0, 2, |                   vbr(4)&gt;;
+     |        4&gt;                   |
+106:5|    1: &lt;1, 19&gt;               |    globals:
+109:1|    2: &lt;65533, 3, 1, 0, 0, 2,|      &#64;a0 = abbrev &lt;0, vbr(6),
+     |        6, 0, 1, 1&gt;          |                   fixed(1)&gt;;
+113:3|    2: &lt;65533, 2, 1, 1, 0, 2,|      &#64;a1 = abbrev &lt;1, vbr(8)&gt;;
+     |        8&gt;                   |
+116:4|    2: &lt;65533, 2, 1, 2, 0, 2,|      &#64;a2 = abbrev &lt;2, vbr(8)&gt;;
+     |        8&gt;                   |
+119:5|    2: &lt;65533, 3, 1, 3, 0, 3,|      &#64;a3 = abbrev &lt;3, array(fixed(8))&gt;
+     |        0, 1, 8&gt;             |          ;
+123:2|    2: &lt;65533, 2, 1, 4, 0, 2,|      &#64;a4 = abbrev &lt;4, vbr(6)&gt;;
+     |        6&gt;                   |
+126:3|    2: &lt;65533, 3, 1, 4, 0, 2,|      &#64;a5 = abbrev &lt;4, vbr(6), vbr(6)&gt;;
+     |        6, 0, 2, 6&gt;          |
+130:5|  0: &lt;65534&gt;                 |  }
+132:0|  1: &lt;65535, 17, 3&gt;          |  types {  // BlockID = 17
+140:0|    2: &lt;65533, 4, 1, 21, 0,  |    %a0 = abbrev &lt;21, fixed(1),
+     |        1, 1, 0, 3, 0, 1, 2&gt; |                  array(fixed(2))&gt;;
+144:7|    3: &lt;1, 3&gt;                |    count 3;
+147:4|    3: &lt;7, 32&gt;               |    &#64;t0 = i32;
+150:7|    4: &lt;21, 0, 0, 0, 0&gt;      |    &#64;t1 = i32 (i32, i32); &lt;%a0&gt;
+152:7|    3: &lt;2&gt;                   |    &#64;t2 = void;
+154:6|  0: &lt;65534&gt;                 |  }
+156:0|  3: &lt;8, 1, 0, 0, 0&gt;         |  define external i32 &#64;f0(i32, i32);
+160:6|  1: &lt;65535, 19, 4&gt;          |  globals {  // BlockID = 19
+168:0|    3: &lt;5, 0&gt;                |    count 0;
+170:6|  0: &lt;65534&gt;                 |  }
+172:0|  1: &lt;65535, 14, 3&gt;          |  valuesymtab {  // BlockID = 14
+180:0|    6: &lt;1, 0, 102&gt;           |    &#64;f0 : &quot;f&quot;; &lt;&#64;a2&gt;
+182:7|  0: &lt;65534&gt;                 |  }
+184:0|  1: &lt;65535, 12, 4&gt;          |  function i32 &#64;f0(i32 %p0, i32 %p1) {
+     |                             |                   // BlockID = 12
+192:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+194:6|    5: &lt;2, 2, 1, 0&gt;          |    %v0 = add i32 %p0, %p1; &lt;&#64;a1&gt;
+197:2|    5: &lt;2, 3, 1, 0&gt;          |    %v1 = add i32 %p0, %v0; &lt;&#64;a1&gt;
+199:6|    8: &lt;10, 1&gt;               |    ret i32 %v1; &lt;&#64;a4&gt;
+201:0|  0: &lt;65534&gt;                 |  }
+204:0|0: &lt;65534&gt;                   |}
+</pre>
+<p>Note that the example above shows the standard abbreviations used by
+<em>pnacl-finalize</em>.</p>
+<h2 id="types-block"><span id="link-for-types-block-section"></span>Types Block</h2>
+<p>The types block defines all types used in a program. It must appear in the
+<a class="reference internal" href="#link-for-module-block"><em>module block</em></a>, before any <a class="reference internal" href="#link-for-function-address-section"><em>function
+address</em></a> records, the <a class="reference internal" href="#link-for-globals-block-section"><em>globals
+block</em></a>, the <a class="reference internal" href="#link-for-valuesymtab-block-section"><em>valuesymtab
+block</em></a>, and any <a class="reference internal" href="#link-for-function-blocks-section"><em>function
+blocks</em></a>.</p>
+<p>All types used in a program must be defined in the types block. Many PNaClAsm
+constructs allow one to use explicit type names, rather than the type
+identifiers defined by this block. However, they are internally converted to the
+corresponding type identifier in the types block. Hence, the requirement that
+the types block must appear early in the module block.</p>
+<p>Each record in the types block defines a type used by the program.  Types can be
+broken into the following groups:</p>
+<dl class="docutils">
+<dt>Primitive value types</dt>
+<dd>Defines the set of base types for values. This includes various sizes of
+integer and floating point types.</dd>
+<dt>Void type</dt>
+<dd>A primitive type that doesn&#8217;t represent any value and has no size.</dd>
+<dt>Function types</dt>
+<dd>The type signatures of functions.</dd>
+<dt>Vector type</dt>
+<dd>Defines vectors of primitive types.</dd>
+</dl>
+<p>In addition, any type that is not defined using another type is a primitive
+type.  All other types (i.e. function and vector) are composite types.</p>
+<p>Types must be defined in a topological order, causing primitive types to appear
+before the composite types that use them. Each type must be unique. There are no
+additional restrictions on the order that types can be defined in a types block.</p>
+<p>The following subsections introduce each valid PNaClAsm type, and the
+corresponding PNaClAsm construct that defines the type. Types not defined in the
+types block, can&#8217;t be used in a PNaCl program.</p>
+<p>The first record of a types block must be a <a class="reference internal" href="#link-for-types-count-record"><em>count
+record</em></a>, defining how many types are defined by the
+types block. All remaining records defines a type. The following subsections
+defines valid records within a types block. The order of type records is
+important. The position of each defining record implicitly defines the type ID
+that will be used to denote that type, within other PNaCl records of the bitcode
+file.</p>
+<p>To make this more concrete, consider the following example types block:</p>
+<pre class="prettyprint">
+40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+48:0|    3: &lt;1, 4&gt;                |    count 4;
+50:4|    3: &lt;7, 32&gt;               |    &#64;t0 = i32;
+53:6|    3: &lt;3&gt;                   |    &#64;t1 = float;
+55:4|    3: &lt;2&gt;                   |    &#64;t2 = void;
+57:2|    3: &lt;21, 0, 2, 0, 1&gt;      |    &#64;t3 = void (i32, float);
+62:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<p>This example defines a types block that defines four type IDs:</p>
+<dl class="docutils">
+<dt>&#64;t0</dt>
+<dd>A 32-bit integer type.</dd>
+<dt>&#64;t1</dt>
+<dd>A 32-bit floating point type.</dd>
+<dt>&#64;t2</dt>
+<dd>The void type.</dd>
+<dt>&#64;t3</dt>
+<dd>A function, taking 32-bit integer and float point arguments that returns
+void.</dd>
+</dl>
+<h3 id="count-record"><span id="link-for-types-count-record"></span>Count Record</h3>
+<p>The <em>count record</em> defines how many types are defined in the types
+block. Following the types count record are records that define types used by
+the PNaCl program.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+count N;                                       &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;1, N&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>This construct defines the number of types used by the PNaCl program. <code>N</code> is
+the number of types defined in the types block. It is an error to define more
+(or fewer) types than value <code>N</code>, within the enclosing types block.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+0 == NumTypes
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+ExpectedTypes = N;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+48:0|    3: &lt;1, 4&gt;                |    count 4;
+50:4|    3: &lt;7, 32&gt;               |    &#64;t0 = i32;
+53:6|    3: &lt;3&gt;                   |    &#64;t1 = float;
+55:4|    3: &lt;2&gt;                   |    &#64;t2 = void;
+57:2|    3: &lt;21, 0, 2, 0, 1&gt;      |    &#64;t3 = void (i32, float);
+62:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="void-type">Void Type</h3>
+<p>The <em>void</em> type record defines the void type, which corresponds to the type that
+doesn&#8217;t define any value, and has no size.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+&#64;tN = void;                                     &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;2&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The void type record defines the type that has no values and has no size.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+N == NumTypes
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumTypes;
+TypeOf(&#64;tN) = void;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+48:0|    3: &lt;1, 4&gt;                |    count 4;
+50:4|    3: &lt;7, 32&gt;               |    &#64;t0 = i32;
+53:6|    3: &lt;3&gt;                   |    &#64;t1 = float;
+55:4|    3: &lt;2&gt;                   |    &#64;t2 = void;
+62:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="integer-types">Integer Types</h3>
+<p>PNaClAsm allows integer types for various bit sizes. Valid bit sizes are 1, 8,
+16, 32, and 64. Integers can be signed or unsigned, but the signed component of
+an integer is not specified by the type. Rather, individual instructions
+determine whether the value is assumed to be signed or unsigned.</p>
+<p>It should be noted that in PNaClAsm, all pointers are implemented as 32-bit
+(unsigned) integers.  There isn&#8217;t a separate type for pointers. The only way to
+tell that a 32-bit integer is a pointer, is when it is used in an instruction
+that requires a pointer (such as load and store instructions).</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+&#64;tN = iB;                                      &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;7, B&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>An integer type record defines an integer type. <code>B</code> defines the number of bits
+of the integer type.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+N == NumTypes &amp;
+B in {1, 8, 16, 32, 64}
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumTypes;
+TypeOf(&#64;tN) = iB;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+48:0|    3: &lt;1, 7&gt;                |    count 7;
+50:4|    3: &lt;7, 64&gt;               |    &#64;t0 = i64;
+53:6|    3: &lt;7, 1&gt;                |    &#64;t1 = i1;
+56:2|    3: &lt;7, 8&gt;                |    &#64;t2 = i8;
+58:6|    3: &lt;7, 16&gt;               |    &#64;t3 = i16;
+61:2|    3: &lt;7, 32&gt;               |    &#64;t4 = i32;
+64:4|    3: &lt;21, 0, 0, 1&gt;         |    &#64;t5 = i64 (i1);
+68:4|    3: &lt;2&gt;                   |    &#64;t6 = void;
+70:2|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="bit-floating-point-type">32-Bit Floating Point Type</h3>
+<p>PNaClAsm allows computation on 32-bit floating point values. A floating point
+type record defines the 32-bit floating point type.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+&#64;tN = float;                                    &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;3&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>A floating point type record defines the 32-bit floating point type.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+N == NumTypes
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumTypes;
+TypeOf(&#64;tN) = float;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+48:0|    3: &lt;1, 4&gt;                |    count 4;
+50:4|    3: &lt;4&gt;                   |    &#64;t0 = double;
+52:2|    3: &lt;3&gt;                   |    &#64;t1 = float;
+54:0|    3: &lt;21, 0, 0, 1&gt;         |    &#64;t2 = double (float);
+58:0|    3: &lt;2&gt;                   |    &#64;t3 = void;
+59:6|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="id1">64-bit Floating Point Type</h3>
+<p>PNaClAsm allows computation on 64-bit floating point values. A 64-bit floating
+type record defines the 64-bit floating point type.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+&#64;tN = double;                                   &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;4&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>A double type record defines the 64-bit floating point type.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+N == NumTypes
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumTypes;
+TypeOf(&#64;tN) = double;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+48:0|    3: &lt;1, 4&gt;                |    count 4;
+50:4|    3: &lt;4&gt;                   |    &#64;t0 = double;
+52:2|    3: &lt;3&gt;                   |    &#64;t1 = float;
+54:0|    3: &lt;21, 0, 0, 1&gt;         |    &#64;t2 = double (float);
+58:0|    3: &lt;2&gt;                   |    &#64;t3 = void;
+59:6|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="vector-types">Vector Types</h3>
+<p>A vector type is a derived type that represents a vector of elements.  Vector
+types are used when multiple primitive data values are operated in parallel
+using a single (SIMD) <a class="reference internal" href="#link-for-vector-instructions"><em>vector instruction</em></a>. A
+vector type requires a size (number of elements) and an underlying primitive
+data type.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+&#64;tN = &lt; E x T &gt;                                 &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;12, E, TT&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The vector type defines a vector of elements. <code>T</code> is the type of each
+element. <code>E</code> is the number of elements in the vector.</p>
+<p>Vector types can only be defined on <code>i1</code>, <code>i8</code>, <code>i16</code>, <code>i32</code>, and
+<code>float</code>.  All vector types, except those on <code>i1</code>, must contain exactly 128
+bits.  The valid element sizes are restricted as follows:</p>
+<table border="1" class="docutils">
+<colgroup>
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">Type</th>
+<th class="head">Valid element sizes</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>i1</td>
+<td>4, 8, 16</td>
+</tr>
+<tr class="row-odd"><td>i8</td>
+<td>16</td>
+</tr>
+<tr class="row-even"><td>i16</td>
+<td>8</td>
+</tr>
+<tr class="row-odd"><td>i32</td>
+<td>4</td>
+</tr>
+<tr class="row-even"><td>float</td>
+<td>4</td>
+</tr>
+</tbody>
+</table>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+TT == AbsoluteIndex(TypeID(T)) &amp;
+N == NumTypes
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumTypes
+TypeOf(&#64;tN) = &lt;E x T&gt;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+48:0|    3: &lt;1, 14&gt;               |    count 14;
+50:4|    3: &lt;7, 32&gt;               |    &#64;t0 = i32;
+53:6|    3: &lt;7, 1&gt;                |    &#64;t1 = i1;
+56:2|    3: &lt;2&gt;                   |    &#64;t2 = void;
+58:0|    3: &lt;12, 4, 1&gt;            |    &#64;t3 = &lt;4 x i1&gt;;
+61:2|    3: &lt;12, 8, 1&gt;            |    &#64;t4 = &lt;8 x i1&gt;;
+64:4|    3: &lt;12, 16, 1&gt;           |    &#64;t5 = &lt;16 x i1&gt;;
+67:6|    3: &lt;7, 8&gt;                |    &#64;t6 = i8;
+70:2|    3: &lt;12, 16, 6&gt;           |    &#64;t7 = &lt;16 x i8&gt;;
+73:4|    3: &lt;7, 16&gt;               |    &#64;t8 = i16;
+76:0|    3: &lt;12, 8, 8&gt;            |    &#64;t9 = &lt;8 x i16&gt;;
+79:2|    3: &lt;12, 4, 0&gt;            |    &#64;t10 = &lt;4 x i32&gt;;
+82:4|    3: &lt;3&gt;                   |    &#64;t11 = float;
+84:2|    3: &lt;12, 4, 11&gt;           |    &#64;t12 = &lt;4 x float&gt;;
+87:4|    3: &lt;21, 0, 2&gt;            |    &#64;t13 = void ();
+90:6|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="function-type"><span id="link-for-function-type"></span>Function Type</h3>
+<p>The <em>function</em> type can be thought of as a function signature. It consists of a
+return type, and a (possibly empty) list of formal parameter types.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%tN = RT (T1, ... , TM)                         &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;21, 0, IRT, IT1, ... , ITM&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The function type defines the signature of a function. <code>RT</code> is the return type
+of the function, while types <code>T1</code> through <code>TM</code> are the types of the
+arguments. Indices to the corresponding type identifiers are stored in the
+corresponding record.</p>
+<p>The return value must either be a primitive type, type <code>void</code>, or a vector
+type.  Parameter types can be a primitive or vector type.</p>
+<p>For ordinary functions, the only valid integer types that can be used for a
+return or parameter type are <code>i32</code> and <code>i64</code>.  All other integer types are
+not allowed.</p>
+<p>For <a class="reference internal" href="#link-for-intrinsic-functions-section"><em>intrinsic functions</em></a>, all
+integer types are allowed for both return and parameter types.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+M &gt;= 0 &amp;
+IRT == AbsoluteIndex(TypeID(RT)) &amp;
+IT1 == AbsoluteIndex(TypeID(T1)) &amp;
+...
+ITM == AbsoluteIndex(TypeID(TM)) &amp;
+N == NumTypes
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumTypes
+TypeOf(&#64;tN) = RT (T1, ... , TM)
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+48:0|    3: &lt;1, 7&gt;                |    count 7;
+50:4|    3: &lt;7, 32&gt;               |    &#64;t0 = i32;
+53:6|    3: &lt;3&gt;                   |    &#64;t1 = float;
+55:4|    3: &lt;4&gt;                   |    &#64;t2 = double;
+57:2|    3: &lt;21, 0, 2, 1&gt;         |    &#64;t3 = double (float);
+61:2|    3: &lt;2&gt;                   |    &#64;t4 = void;
+63:0|    3: &lt;21, 0, 4&gt;            |    &#64;t5 = void ();
+66:2|    3: &lt;21, 0, 0, 0, 1, 0, 2&gt;|    &#64;t6 =
+    |                             |        i32 (i32, float, i32, double);
+72:4|  0: &lt;65534&gt;                 |  }
+</pre>
+<h2 id="globals-block"><span id="link-for-globals-block-section"></span>Globals Block</h2>
+<p>The globals block defines global addresses of variables and constants, used by
+the PNaCl program. It also defines the memory associated with the global
+addresses, and how to initialize each global variable/constant. It must appear
+in the <a class="reference internal" href="#link-for-module-block"><em>module block</em></a>. It must appear after the
+<a class="reference internal" href="#link-for-types-block-section"><em>types block</em></a>, as well as after all
+<a class="reference internal" href="#link-for-function-address-section"><em>function address</em></a> records. But, it must
+also appear before the <a class="reference internal" href="#link-for-valuesymtab-block-section"><em>valuesymtab
+block</em></a>, and any
+<a class="reference internal" href="#link-for-function-blocks-section"><em>function blocks</em></a>.</p>
+<p>The globals block begins with a <a class="reference internal" href="#link-for-globals-count-record"><em>count
+record</em></a>, defining how many global addresses are
+defined by the PNaCl program. It is then followed by a sequence of records that
+defines each global address, and how each global address is initialized.</p>
+<p>The standard sequence, for defining global addresses, begins with a global
+address record.  It is then followed by a sequence of records defining how the
+global address is initialized.  If the initializer is simple, a single record is
+used. Otherwise, the initializer is preceded with a <a class="reference internal" href="#link-for-compound-initializer"><em>compound
+record</em></a>, specifying a number <em>N</em>, followed by
+sequence of <em>N</em> simple initializer records.</p>
+<p>The size of the memory referenced by each global address is defined by its
+initializer records. All simple initializer records define a sequence of
+bytes. A compound initializer defines the sequence of bytes by concatenating the
+corresponding sequence of bytes for each of its simple initializer records.</p>
+<p>For notational convenience, PNaClAsm begins a compound record with a &#8220;{&#8221;, and
+inserts a &#8220;}&#8221; after the last initializer record associated with the compound
+record. This latter &#8220;}&#8221; does not correspond to any record. It is implicitly
+assumed by the size specified in the compound record, and is added only to
+improve readability.</p>
+<p>Explicit alignment is specified for global addresses, and must be a power of
+2. See <a class="reference internal" href="#link-for-memory-blocks-and-alignment-section"><em>memory blocks and
+alignment</em></a> for a more detailed
+discussion on how to define alignment.</p>
+<p>For example, consider the following pnacl-bcdis output snippet:</p>
+<pre class="prettyprint">
+52:0|  1: &lt;65535, 19, 2&gt;          |  globals {  // BlockID = 19
+60:0|    3: &lt;5, 2&gt;                |    count 2;
+62:4|    3: &lt;0, 1, 1&gt;             |    const &#64;g0, align 1,
+65:6|    3: &lt;2, 8&gt;                |      zerofill 8;
+68:2|    3: &lt;0, 1, 0&gt;             |    var &#64;g1, align 1,
+71:4|    3: &lt;1, 2&gt;                |      initializers 2 {
+74:0|    3: &lt;3, 1, 2, 3, 4&gt;       |        {  1,   2,   3,   4}
+78:6|    3: &lt;2, 2&gt;                |        zerofill 2;
+    |                             |      }
+81:2|  0: &lt;65534&gt;                 |  }
+</pre>
+<p>This snippet defines the global constant <code>&#64;g0</code>, and the global variable
+<code>&#64;g1</code>. <code>&#64;g0</code> is 8 bytes long, and initialized to zero. <code>&#64;g1</code> is
+initialized with 6 bytes: <code>1 2 3 4 0 0</code>.</p>
+<h3 id="link-for-globals-count-record"><span id="id2"></span>Count Record</h3>
+<p>The count record defines the number of global addresses used by the PNaCl
+program.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+count N;                                       &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;5, N&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>This record must appear first in the globals block.  The count record defines
+the number of global addresses used by the program.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A)
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+ExpectedGlobals = N;
+ExpectedInitializers = 0;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+52:0|  1: &lt;65535, 19, 2&gt;          |  globals {  // BlockID = 19
+60:0|    3: &lt;5, 2&gt;                |    count 2;
+62:4|    3: &lt;0, 1, 1&gt;             |    const &#64;g0, align 1,
+65:6|    3: &lt;2, 8&gt;                |      zerofill 8;
+68:2|    3: &lt;0, 1, 0&gt;             |    var &#64;g1, align 1,
+71:4|    3: &lt;1, 2&gt;                |      initializers 2 {
+74:0|    3: &lt;3, 1, 2, 3, 4&gt;       |        {  1,   2,   3,   4}
+78:6|    3: &lt;2, 2&gt;                |        zerofill 2;
+    |                             |      }
+81:2|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="global-variable-addresses"><span id="link-for-global-variable-address"></span>Global Variable Addresses</h3>
+<p>A global variable address record defines a global address to global data.  The
+global variable address record must be immediately followed by initializer
+record(s) that define how the corresponding global variable is initialized.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+var &#64;gN, align V,                               &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;0, VV, 0&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>A global variable address record defines a global address for a global variable.
+<code>V</code> is the <a class="reference internal" href="#link-for-memory-blocks-and-alignment-section"><em>memory
+alignment</em></a> for the global variable
+address, and is a power of 2.</p>
+<p>It is assumed that the memory, referenced by the global variable address, can be
+both read and written to.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+N == NumGlobalAddresses &amp;
+ExpectedInitializers == 0 &amp;
+VV == Log2(V+1)
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumGlobalAddresses;
+ExpectedInitializers = 1;
+TypeOf(&#64;gN) = i32;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+52:0|  1: &lt;65535, 19, 2&gt;          |  globals {  // BlockID = 19
+60:0|    3: &lt;5, 2&gt;                |    count 2;
+62:4|    3: &lt;0, 3, 0&gt;             |    var &#64;g0, align 4,
+65:6|    3: &lt;2, 8&gt;                |      zerofill 8;
+68:2|    3: &lt;0, 1, 0&gt;             |    var &#64;g1, align 1,
+71:4|    3: &lt;3, 1, 2, 3, 4&gt;       |      {  1,   2,   3,   4}
+76:2|  0: &lt;65534&gt;                 |  }
+80:0|0: &lt;65534&gt;                   |}
+</pre>
+<h3 id="global-constant-addresses"><span id="link-for-global-constant-address"></span>Global Constant Addresses</h3>
+<p>A global constant address record defines an address corresponding to a global
+constant that can&#8217;t be modified by the program. The global constant address
+record must be immediately followed by initializer record(s) that define how
+the corresponding global constant is initialized.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+const &#64;gN, align V,                             &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;0, VV, 1&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>A global constant address record defines a global address for a global constant.
+<code>V</code> is the <a class="reference internal" href="#link-for-memory-blocks-and-alignment-section"><em>memory
+alignment</em></a> for the global constant
+address, and is a power of 2.</p>
+<p>It is assumed that the memory, referenced by the global constant address, is
+only read, and can&#8217;t be written to.</p>
+<p>Note that the only difference between a global variable address and a global
+constant address record is the third element of the record. If the value is
+zero, it defines a global variable address. If the value is one, it defines a
+global constant address.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+N == NumGlobalAddresses &amp;
+ExpectedInitializers == 0 &amp;
+VV == Log2(V+1)
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumGlobalAddresses;
+ExpectedInitializers = 1;
+TypeOf(&#64;gN) = i32;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+52:0|  1: &lt;65535, 19, 2&gt;          |  globals {  // BlockID = 19
+60:0|    3: &lt;5, 2&gt;                |    count 2;
+62:4|    3: &lt;0, 3, 1&gt;             |    const &#64;g0, align 4,
+65:6|    3: &lt;2, 8&gt;                |      zerofill 8;
+68:2|    3: &lt;0, 1, 1&gt;             |    const &#64;g1, align 1,
+71:4|    3: &lt;3, 1, 2, 3, 4&gt;       |      {  1,   2,   3,   4}
+76:2|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="zerofill-initializer">Zerofill Initializer</h3>
+<p>The zerofill initializer record initializes a sequence of bytes, associated with
+a global address, with zeros.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+zerofill N;                                     &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;2, N&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>A zerofill initializer record initializes a sequence of bytes, associated with a
+global address, with zeros. The number of bytes initialized to zero is <code>N</code>.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+ExpectedInitializers &gt; 0
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+--ExpectedInitializers;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+52:0|  1: &lt;65535, 19, 2&gt;          |  globals {  // BlockID = 19
+60:0|    3: &lt;5, 2&gt;                |    count 2;
+62:4|    3: &lt;0, 3, 1&gt;             |    const &#64;g0, align 4,
+65:6|    3: &lt;2, 8&gt;                |      zerofill 8;
+68:2|    3: &lt;0, 1, 0&gt;             |    var &#64;g1, align 1,
+71:4|    3: &lt;2, 4&gt;                |      zerofill 4;
+74:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="data-initializer">Data Initializer</h3>
+<p>Data records define a sequence of bytes. These bytes define the initial value of
+the contents of the corresponding memory.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+{ B1 , .... , BN }                              &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;3, B1, ..., BN&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>A data record defines a sequence of (unsigned) bytes <code>B1</code> through <code>BN</code>, that
+initialize <code>N</code> bytes of memory.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+ExpectedInitializers &gt; 0
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+--ExpectedInitializers;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 56:0|  3: &lt;8, 1, 0, 1, 0&gt;         |  declare external void &#64;f0();
+ 60:6|  1: &lt;65535, 19, 2&gt;          |  globals {  // BlockID = 19
+ 68:0|    3: &lt;5, 2&gt;                |    count 2;
+ 70:4|    3: &lt;0, 1, 1&gt;             |    const &#64;g0, align 1,
+ 73:6|    3: &lt;3, 1, 2, 97, 36, 44, |      {  1,   2,  97,  36,  44,  88,
+     |        88, 44, 50&gt;          |        44,  50}
+ 86:0|    3: &lt;0, 1, 1&gt;             |    const &#64;g1, align 1,
+ 89:2|    3: &lt;1, 3&gt;                |      initializers 3 {
+ 91:6|    3: &lt;3, 1, 2, 3, 4&gt;       |        {  1,   2,   3,   4}
+ 96:4|    3: &lt;4, 0&gt;                |        reloc &#64;f0;
+ 99:0|    3: &lt;3, 99, 66, 22, 12&gt;   |        { 99,  66,  22,  12}
+     |                             |      }
+105:2|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="relocation-initializer">Relocation Initializer</h3>
+<p>A relocation initializer record allows one to define the initial value of a
+global address with the value of another global address (i.e. either
+<a class="reference internal" href="#link-for-function-address-section"><em>function</em></a>,
+<a class="reference internal" href="#link-for-global-variable-address"><em>variable</em></a>, or
+<a class="reference internal" href="#link-for-global-constant-address"><em>constant</em></a>). Since addresses are
+pointers, a relocation initializer record defines 4 bytes of memory.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+reloc V;                                        &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;4, VV&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>A relocation initializer record defines a 4-byte value containing the specified
+global address <code>V</code>.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+VV == AbsoluteIndex(V) &amp;
+VV &gt;= NumFuncAddresses &amp;
+VV &lt; NumFuncAddresses + ExpectedGlobals &amp;
+ExpectedInitializers &gt; 0
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+--ExpectedInitializers;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+48:0|    3: &lt;1, 2&gt;                |    count 2;
+50:4|    3: &lt;2&gt;                   |    &#64;t0 = void;
+52:2|    3: &lt;21, 0, 0&gt;            |    &#64;t1 = void ();
+55:4|  0: &lt;65534&gt;                 |  }
+56:0|  3: &lt;8, 1, 0, 1, 0&gt;         |  declare external void &#64;f0();
+60:6|  1: &lt;65535, 19, 2&gt;          |  globals {  // BlockID = 19
+68:0|    3: &lt;5, 2&gt;                |    count 2;
+70:4|    3: &lt;0, 1, 0&gt;             |    var &#64;g0, align 1,
+73:6|    3: &lt;1, 3&gt;                |      initializers 3 {
+76:2|    3: &lt;4, 0&gt;                |        reloc &#64;f0;
+78:6|    3: &lt;4, 1&gt;                |        reloc &#64;g0;
+81:2|    3: &lt;4, 2&gt;                |        reloc &#64;g1;
+    |                             |      }
+83:6|    3: &lt;0, 3, 0&gt;             |    var &#64;g1, align 4,
+87:0|    3: &lt;2, 4&gt;                |      zerofill 4;
+89:4|  0: &lt;65534&gt;                 |  }
+</pre>
+<p>This example defines global address <code>&#64;g0</code> and <code>&#64;g1</code>. <code>&#64;g0</code> defines 12
+bytes of memory, and is initialized with three addresses <code>&#64;f1</code>, <code>&#64;g0</code>, and
+<code>&#64;g1</code>. Note that all global addresses can be used in a relocation
+initialization record, even if it isn&#8217;t defined yet.</p>
+<h3 id="subfield-relocation-initializer">Subfield Relocation Initializer</h3>
+<p>A subfield relocation initializer record allows one to define the initial value
+of a global address with the value of another (non-function) global address
+(i.e. either <a class="reference internal" href="#link-for-global-variable-address"><em>variable</em></a> or
+<a class="reference internal" href="#link-for-global-constant-address"><em>constant</em></a> address), plus a
+constant. Since addresses are pointers, a relocation initializer record defines
+4 bytes of memory.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+reloc V + X;                                    &lt;A&gt;
+reloc V - X;                                    &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;4, VV, XXX&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>A subfield relocation initializer record defines a 4-byte value containing the
+specified global (non-function) address <code>V</code>, modified by the unsigned offset
+<code>X</code>. <code>XX</code> is the corresponding signed offset. In the first form, <code>XX ==
+X</code>. In the second form, <code>XX == -X</code>.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A)
+VV == AbsoluteIndex(V)
+VV &gt;= NumFuncAddresses
+VV &lt; NumFuncAddresses + ExpectedGlobals
+ExpectedInitializers &gt; 0
+XXX == SignRotate(XX)
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+--ExpectedInitializers;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+48:0|    3: &lt;1, 0&gt;                |    count 0;
+50:4|  0: &lt;65534&gt;                 |  }
+52:0|  1: &lt;65535, 19, 2&gt;          |  globals {  // BlockID = 19
+60:0|    3: &lt;5, 3&gt;                |    count 3;
+62:4|    3: &lt;0, 1, 0&gt;             |    var &#64;g0, align 1,
+65:6|    3: &lt;1, 3&gt;                |      initializers 3 {
+68:2|    3: &lt;4, 0, 1&gt;             |        reloc &#64;g0 + 1;
+71:4|    3: &lt;4, 1, 4294967295&gt;    |        reloc &#64;g1 - 1;
+79:2|    3: &lt;4, 2, 4&gt;             |        reloc &#64;g2 + 4;
+    |                             |      }
+82:4|    3: &lt;0, 3, 0&gt;             |    var &#64;g1, align 4,
+85:6|    3: &lt;2, 4&gt;                |      zerofill 4;
+88:2|    3: &lt;0, 3, 0&gt;             |    var &#64;g2, align 4,
+91:4|    3: &lt;2, 8&gt;                |      zerofill 8;
+94:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="compound-initializer"><span id="link-for-compound-initializer"></span>Compound Initializer</h3>
+<p>The compound initializer record must immediately follow a global
+<a class="reference internal" href="#link-for-global-variable-address"><em>variable</em></a> or
+<a class="reference internal" href="#link-for-global-constant-address"><em>constant</em></a> address record. It defines how
+many simple initializer records are used to define the initializer. The size of
+the corresponding memory is the sum of the bytes needed for each of the
+succeeding initializers.</p>
+<p>Note that a compound initializer can&#8217;t be used as a simple initializer of
+another compound initializer (i.e. nested compound initializers are not
+allowed).</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+initializers N {                                &lt;A&gt;
+ ...
+}
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;1, N&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>Defines that the next <cite>N</cite> initializers should be associated with the global
+address of the previous record.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+ExpectedInitializers == 1
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+ExpectedInitializers = N;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+48:0|    3: &lt;1, 0&gt;                |    count 0;
+50:4|  0: &lt;65534&gt;                 |  }
+52:0|  1: &lt;65535, 19, 2&gt;          |  globals {  // BlockID = 19
+60:0|    3: &lt;5, 2&gt;                |    count 2;
+62:4|    3: &lt;0, 0, 1&gt;             |    const &#64;g0, align 0,
+65:6|    3: &lt;1, 2&gt;                |      initializers 2 {
+68:2|    3: &lt;2, 8&gt;                |        zerofill 8;
+70:6|    3: &lt;3, 3, 2, 1, 0&gt;       |        {  3,   2,   1,   0}
+    |                             |      }
+75:4|    3: &lt;0, 0, 0&gt;             |    var &#64;g1, align 0,
+78:6|    3: &lt;1, 2&gt;                |      initializers 2 {
+81:2|    3: &lt;3, 1, 2, 3, 4&gt;       |        {  1,   2,   3,   4}
+86:0|    3: &lt;2, 2&gt;                |        zerofill 2;
+    |                             |      }
+88:4|  0: &lt;65534&gt;                 |  }
+</pre>
+<h2 id="valuesymtab-block"><span id="link-for-valuesymtab-block-section"></span>Valuesymtab Block</h2>
+<p>The valuesymtab block does not define any values.  Its only goal is to associate
+text names with external <a class="reference internal" href="#link-for-function-address-section"><em>function
+addresses</em></a>.  Each association is defined by a
+record in the valuesymtab block.  Currently, only
+<a class="reference internal" href="#link-for-intrinsic-functions-section"><em>intrinsic</em></a> function addresses and
+the (external) start function (<code>_start</code>) can be named.  All named function
+addresses must be external.  Each record in the valuesymtab block is a <em>entry</em>
+record, defining a single name association.</p>
+<h3 id="entry-record">Entry Record</h3>
+<p>The <em>entry</em> record defines a name for a function address.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+V : &quot;NAME&quot;;                                     &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;1, B1, ... , BN&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The <em>entry</em> record defines a name <code>NAME</code> for function address <code>V</code>. <code>NAME</code>
+is a sequence of ASCII characters <code>B1</code> through <code>BN</code>.</p>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 72:0|  3: &lt;8, 4, 0, 1, 0&gt;         |  declare external
+     |                             |      void &#64;f0(i32, i32, i32, i32, i1);
+ 76:6|  3: &lt;8, 4, 0, 1, 0&gt;         |  declare external
+     |                             |      void &#64;f1(i32, i32, i32, i32, i1);
+ 81:4|  3: &lt;8, 5, 0, 0, 0&gt;         |  define external void &#64;f2(i32);
+ 86:2|  1: &lt;65535, 19, 2&gt;          |  globals {  // BlockID = 19
+ 92:0|    3: &lt;5, 0&gt;                |    count 0;
+ 94:4|  0: &lt;65534&gt;                 |  }
+ 96:0|  1: &lt;65535, 14, 2&gt;          |  valuesymtab {  // BlockID = 14
+104:0|    3: &lt;1, 1, 108, 108, 118, |    &#64;f1 : &quot;llvm.memmove.p0i8.p0i8.i32&quot;;
+     |        109, 46, 109, 101,   |
+     |        109, 109, 111, 118,  |
+     |        101, 46, 112, 48,    |
+     |        105, 56, 46, 112, 48,|
+     |        105, 56, 46, 105, 51,|
+     |        50&gt;                  |
+145:4|    3: &lt;1, 2, 95, 115, 116,  |    &#64;f2 : &quot;_start&quot;;
+     |        97, 114, 116&gt;        |
+157:0|    3: &lt;1, 0, 108, 108, 118, |    &#64;f0 : &quot;llvm.memcpy.p0i8.p0i8.i32&quot;;
+     |        109, 46, 109, 101,   |
+     |        109, 99, 112, 121,   |
+     |        46, 112, 48, 105, 56,|
+     |        46, 112, 48, 105, 56,|
+     |        46, 105, 51, 50&gt;     |
+197:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h2 id="module-block"><span id="link-for-module-block"></span>Module Block</h2>
+<p>The module block, like all blocks, is enclosed in a pair of
+<a class="reference internal" href="#link-for-enter-block-record-section"><em>enter</em></a> /
+<a class="reference internal" href="#link-for-exit-block-record-section"><em>exit</em></a> records, using block ID 8. A
+well-formed module block consists of the following records (in order):</p>
+<dl class="docutils">
+<dt>A version record</dt>
+<dd>The <a class="reference internal" href="#link-for-version-record"><em>version record</em></a> communicates which version
+of the PNaCl bitcode reader/writer should be used. Note that this is
+different than the PNaCl bitcode (ABI) version. The PNaCl bitcode (ABI)
+version defines what is expected in records, and is defined in the header
+record of the bitcode file. The version record defines the version of the
+PNaCl bitcode reader/writer to use to convert records into bit sequences.</dd>
+<dt>Optional local abbreviations</dt>
+<dd>Defines a list of local <a class="reference internal" href="#link-for-abbreviations-section"><em>abbreviations</em></a>
+to use for records within the module block.</dd>
+<dt>An abbreviations block</dt>
+<dd>The <a class="reference internal" href="#link-for-abbreviations-block-section"><em>abbreviations block</em></a> defines
+user-defined, global abbreviations that are used to convert PNaCl records to
+bit sequences in blocks following the abbreviations block.</dd>
+<dt>A types block</dt>
+<dd>The <a class="reference internal" href="#link-for-types-block-section"><em>types block</em></a> defines the set of all
+types used in the program.</dd>
+<dt>A non-empty sequence of function address records</dt>
+<dd>Each record defines a <a class="reference internal" href="#link-for-function-address-section"><em>function
+address</em></a> used by the program. Function
+addresses must either be external, or defined internally by the program. If
+they are defined by the program, there must be a <a class="reference internal" href="#link-for-function-blocks-section"><em>function
+block</em></a> (appearing later in the module) that
+defines the sequence of instructions for each defined function.</dd>
+<dt>A globals block defining the global variables.</dt>
+<dd>This <a class="reference internal" href="#link-for-globals-block-section"><em>block</em></a> defines the set of
+global <a class="reference internal" href="#link-for-global-variable-address"><em>variable</em></a> and
+<a class="reference internal" href="#link-for-global-constant-address"><em>constant</em></a> addresses used by the
+program. In addition to the addresses, each global variable also defines how
+the corresponding global variable is initialized.</dd>
+<dt>An optional value symbol table block.</dt>
+<dd>This <a class="reference internal" href="#link-for-valuesymtab-block-section"><em>block</em></a>, if defined, provides
+textual names for <a class="reference internal" href="#link-for-function-address-section"><em>function
+addresses</em></a> (previously defined in the
+module). Note that only names for intrinsic functions and the start function
+are specified.</dd>
+<dt>A sequence of function blocks.</dt>
+<dd>Each <a class="reference internal" href="#link-for-function-blocks-section"><em>function block</em></a> defines the
+corresponding intermediate representation for each defined function. The
+order of function blocks is used to associate them with <a class="reference internal" href="#link-for-function-address-section"><em>function
+addresses</em></a>.  The order of the defined
+function blocks must follow the same order as the corresponding function
+addresses defined in the module block.</dd>
+</dl>
+<p>Descriptions of the <a class="reference internal" href="#link-for-abbreviations-section"><em>abbreviations</em></a>,
+<a class="reference internal" href="#link-for-types-block-section"><em>types</em></a>,
+<a class="reference internal" href="#link-for-globals-block-section"><em>globals</em></a>, <a class="reference internal" href="#link-for-valuesymtab-block-section"><em>value symbol
+table</em></a>, and
+<a class="reference internal" href="#link-for-function-blocks-section"><em>function</em></a> blocks are not provided
+here. See the appropriate reference for more details. The following subsections
+describe each of the records that can appear in a module block.</p>
+<h3 id="version-record"><span id="link-for-version-record"></span>Version Record</h3>
+<p>The version record defines the implementation of the PNaCl bitstream
+reader/writer to use. That is, the implementation that converts PNaCl records to
+bit sequences, and converts them back to PNaCl records. Note that this is
+different than the PNaCl version of the bitcode file (encoded in the header
+record of the bitcode file).  The PNaCl version defines the valid forms of PNaCl
+records. The version record is specific to the PNaCl version, and may have
+different values for different PNaCl versions.</p>
+<p>Note that currently, only PNaCl bitcode version 2, and version record value 1 is
+defined.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+version N;                                  &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;1, N&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The version record defines which PNaCl reader/writer rules should be
+followed. <code>N</code> is the version number. Currently <code>N</code> must be 1. Future
+versions of PNaCl may define additional legal values.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A)
+</pre>
+<p><em>Examples</em>:</p>
+<pre class="prettyprint">
+16:0|1: &lt;65535, 8, 2&gt;             |module {  // BlockID = 8
+24:0|  3: &lt;1, 1&gt;                  |  version 1;
+26:4|  1: &lt;65535, 0, 2&gt;           |  abbreviations {  // BlockID = 0
+36:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="function-address"><span id="link-for-function-address-section"></span>Function Address</h3>
+<p>A function address record describes a function address. <em>Defined</em> function
+addresses define <a class="reference internal" href="#link-for-function-blocks-section"><em>implementations</em></a> while
+<em>declared</em> function addresses do not.</p>
+<p>Since a PNaCl program is assumed to be a complete (statically linked)
+executable, All functions should be <em>defined</em> and <em>internal</em>.  The exception to
+this are <a class="reference internal" href="#link-for-intrinsic-functions-section"><em>intrinsic functions</em></a>, which
+should only be <em>declared</em> and <em>external</em>, since intrinsic functions will be
+automatically converted to appropriate code by the <a class="reference internal" href="/native-client/overview.html#link-for-pnacl-translator"><em>PNaCl
+translator</em></a>.</p>
+<p>The implementation of a <em>defined</em> function address is provided by a
+corresponding function block, appearing later in the module block. The
+association of a <em>defined</em> function address with the corresponding function
+block is based on position.  The <em>Nth</em> defined function address record, in the
+module block, has its implementation in the <em>Nth</em> function block of that module
+block.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+PN LN T0 &#64;fN ( T1 , ... , TM );                 &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;8, T, C, P, L&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>Describes the function address <code>&#64;fN</code>. <code>PN</code> is the name that specifies the
+prototype value <code>P</code> associated with the function. A function address is
+<em>defined</em> only if <code>P == 0</code>. Otherwise, it is only <em>declared</em>.  The type of the
+function is <a class="reference internal" href="#link-for-function-type"><em>function type</em></a> <code>&#64;tT</code>. <code>L</code> is the
+linkage specification corresponding to name <code>LN</code>. <code>C</code> is the calling
+convention used by the function.</p>
+<p>Note that function signature must be defined by a function type in the types
+block. Hence, the return value must either be a primitive type, type <code>void</code>,
+or a vector type.</p>
+<p>For ordinary functions, integer parameter and types can only be <code>i32</code> and
+<code>i64</code>.  All other integer types are not allowed. For intrinsic functions, all
+integer types are allowed.</p>
+<p>Valid prototype names <code>PN</code>, and corresponding <code>P</code> values, are:</p>
+<table border="1" class="docutils">
+<colgroup>
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">P</th>
+<th class="head">PN</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>1</td>
+<td>declare</td>
+</tr>
+<tr class="row-odd"><td>0</td>
+<td>define</td>
+</tr>
+</tbody>
+</table>
+<p>Valid linkage names <code>LN</code>, and corresponding <code>L</code> values, are:</p>
+<table border="1" class="docutils">
+<colgroup>
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">L</th>
+<th class="head">LN</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>3</td>
+<td>internal</td>
+</tr>
+<tr class="row-odd"><td>0</td>
+<td>external</td>
+</tr>
+</tbody>
+</table>
+<p>Currently, only one calling convention <code>C</code> is supported:</p>
+<table border="1" class="docutils">
+<colgroup>
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">C</th>
+<th class="head">Calling Convention</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>0</td>
+<td>C calling convention</td>
+</tr>
+</tbody>
+</table>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA = AbbrevIndex(A) &amp;
+T = TypeID(TypeOf(T0 ( T1 , ... , TN ))) &amp;
+N = NumFuncAddresses
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumFuncAddresses;
+TypeOf(&#64;fN) = TypeOf(TypeID(i32));
+TypeOfFcn(&#64;fN) = TypeOf(&#64;tT);
+
+if PN == 0:
+  DefiningFcnIDs += &#64;FN;
+  ++NumDefinedFunctionAddresses;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+48:0|    3: &lt;1, 7&gt;                |    count 7;
+50:4|    3: &lt;7, 32&gt;               |    &#64;t0 = i32;
+53:6|    3: &lt;3&gt;                   |    &#64;t1 = float;
+55:4|    3: &lt;4&gt;                   |    &#64;t2 = double;
+57:2|    3: &lt;2&gt;                   |    &#64;t3 = void;
+59:0|    3: &lt;21, 0, 2, 1&gt;         |    &#64;t4 = double (float);
+63:0|    3: &lt;21, 0, 0, 0, 1, 0, 2&gt;|    &#64;t5 =
+    |                             |        i32 (i32, float, i32, double);
+69:2|    3: &lt;21, 0, 3&gt;            |    &#64;t6 = void ();
+72:4|  0: &lt;65534&gt;                 |  }
+76:0|  3: &lt;8, 4, 0, 1, 0&gt;         |  declare external double &#64;f0(float);
+80:6|  3: &lt;8, 5, 0, 1, 0&gt;         |  declare external
+    |                             |      i32 &#64;f1(i32, float, i32, double);
+85:4|  3: &lt;8, 6, 0, 0, 0&gt;         |  define external void &#64;f2();
+</pre>
+<h2 id="constants-blocks"><span id="link-for-constants-block-section"></span>Constants Blocks</h2>
+<p>Constants blocks define literal constants used within each function. Its intent
+is to define them once, before instructions. A constants block can only appear
+in a <a class="reference internal" href="#link-for-function-blocks-section"><em>function block</em></a>, and must appear
+before any instructions in the function block.</p>
+<p>Currently, only integer literals, floating point literals, and undefined vector
+constants can be defined.</p>
+<p>To minimize type information put in a constants block, the type information is
+separated from the constants. This allows a sequence of constants to be given
+the same type. This is done by defining a <a class="reference internal" href="#link-for-constants-set-type-record"><em>set type
+record</em></a>, followed by a sequence of literal
+constants. These literal constants all get converted to the type of the
+preceding set type record.</p>
+<p>Note that constants that are used for switch case selectors should not be added
+to the constants block, since the switch instruction contains the constants used
+for case selectors. All other constants in the function block must be put into a
+constants block, so that instructions can use them.</p>
+<p>To make this more concrete, consider the following example constants block:</p>
+<pre class="prettyprint">
+106:4|    1: &lt;65535, 11, 2&gt;        |    constants {  // BlockID = 11
+116:0|      3: &lt;1, 0&gt;              |      i32:
+118:4|      3: &lt;4, 2&gt;              |        %c0 = i32 1;
+121:0|      3: &lt;4, 4&gt;              |        %c1 = i32 2;
+123:4|      3: &lt;1, 2&gt;              |      i8:
+126:0|      3: &lt;4, 8&gt;              |        %c2 = i8 4;
+128:4|      3: &lt;4, 6&gt;              |        %c3 = i8 3;
+131:0|      3: &lt;1, 1&gt;              |      float:
+133:4|      3: &lt;6, 1065353216&gt;     |        %c4 = float 1;
+139:6|    0: &lt;65534&gt;               |      }
+</pre>
+<h3 id="set-type-record"><span id="link-for-constants-set-type-record"></span>Set Type Record</h3>
+<p>The <em>set type</em> record defines the type to use for the (immediately) succeeding
+literals.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+T:                                              &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;1, TT&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The <em>set type</em> record defines type <code>T</code> to be used to type the (immediately)
+succeeding literals. <code>T</code> must be a non-void primitive value type or a vector
+type.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+TT == TypeID(T)
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+ConstantsSetType = T;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+106:4|    1: &lt;65535, 11, 2&gt;        |    constants {  // BlockID = 11
+116:0|      3: &lt;1, 0&gt;              |      i32:
+118:4|      3: &lt;4, 2&gt;              |        %c0 = i32 1;
+121:0|      3: &lt;4, 4&gt;              |        %c1 = i32 2;
+123:4|      3: &lt;1, 2&gt;              |      i8:
+126:0|      3: &lt;4, 8&gt;              |        %c2 = i8 4;
+128:4|      3: &lt;4, 6&gt;              |        %c3 = i8 3;
+131:0|      3: &lt;1, 1&gt;              |      float:
+133:4|      3: &lt;6, 1065353216&gt;     |        %c4 = float 1;
+139:6|    0: &lt;65534&gt;               |      }
+</pre>
+<h3 id="undefined-literal"><span id="link-for-undefined-literal"></span>Undefined Literal</h3>
+<p>The <em>undefined</em> literal record creates an undefined literal for the type <em>T</em>
+defined by the preceding <em>set type</em> record.</p>
+<p>Note: See <a class="reference internal" href="#link-for-insert-element-instruction-section"><em>insert element
+instruction</em></a> for an example of how
+you would use the undefined literal with vector types.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%cN = T undef;                              &lt;50&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;3&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The <em>undefined</em> literal record creates an undefined literal constant <code>%cN</code> for
+type <code>T</code>.  <code>T</code> must be the type defined by the preceding <em>set type</em> record,
+and be a primitive value type or a vector type.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+N == NumFcnConsts &amp;
+T == ConstantsSetType &amp;
+IsPrimitive(T) or IsVector(T)
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumFcnConsts;
+TypeOf(%cN) = T;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+ 48:0|    3: &lt;1, 5&gt;                |    count 5;
+ 50:4|    3: &lt;7, 32&gt;               |    &#64;t0 = i32;
+ 53:6|    3: &lt;3&gt;                   |    &#64;t1 = float;
+ 55:4|    3: &lt;2&gt;                   |    &#64;t2 = void;
+ 57:2|    3: &lt;12, 4, 0&gt;            |    &#64;t3 = &lt;4 x i32&gt;;
+ 60:4|    3: &lt;21, 0, 2&gt;            |    &#64;t4 = void ();
+ 63:6|  0: &lt;65534&gt;                 |  }
+ ...
+106:4|    1: &lt;65535, 11, 2&gt;        |    constants {  // BlockID = 11
+116:0|      3: &lt;1, 0&gt;              |      i32:
+118:4|      3: &lt;3&gt;                 |        %c0 = i32 undef;
+120:2|      3: &lt;4, 2&gt;              |        %c1 = i32 1;
+122:6|      3: &lt;1, 3&gt;              |      &lt;4 x i32&gt;:
+125:2|      3: &lt;3&gt;                 |        %c2 = &lt;4 x i32&gt; undef;
+127:0|      3: &lt;1, 1&gt;              |      float:
+129:4|      3: &lt;3&gt;                 |        %c3 = float undef;
+131:2|    0: &lt;65534&gt;               |      }
+</pre>
+<h3 id="integer-literal"><span id="link-for-integer-literal"></span>Integer Literal</h3>
+<p>The <em>integer literal</em> record creates an integer literal for the integer type <em>T</em>
+defined by the preceding <em>set type</em> record.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%cN = T V;                                      &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;4, VV&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The <em>integer literal</em> record creates an integer literal constant <code>%cN</code> for
+type <code>T</code>.  <code>T</code> must be the type defined by the preceding <em>set type</em> record,
+and an integer type. The literal <code>V</code> can be signed, but must be definable by
+type <code>T</code>.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+N == NumFcnConsts &amp;
+T == ConstantsSetType &amp;
+VV == SignRotate(V) &amp;
+IsInteger(T)
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+TypeOf(%cN) = T;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+ 48:0|    3: &lt;1, 7&gt;                |    count 7;
+ 50:4|    3: &lt;7, 8&gt;                |    &#64;t0 = i8;
+ 53:0|    3: &lt;7, 16&gt;               |    &#64;t1 = i16;
+ 55:4|    3: &lt;7, 32&gt;               |    &#64;t2 = i32;
+ 58:6|    3: &lt;7, 64&gt;               |    &#64;t3 = i64;
+ 62:0|    3: &lt;7, 1&gt;                |    &#64;t4 = i1;
+ 64:4|    3: &lt;2&gt;                   |    &#64;t5 = void;
+ 66:2|    3: &lt;21, 0, 5&gt;            |    &#64;t6 = void ();
+ 69:4|  0: &lt;65534&gt;                 |  }
+ ...
+114:4|    1: &lt;65535, 11, 2&gt;        |    constants {  // BlockID = 11
+124:0|      3: &lt;1, 0&gt;              |      i8:
+126:4|      3: &lt;4, 2&gt;              |        %c0 = i8 1;
+129:0|      3: &lt;4, 4&gt;              |        %c1 = i8 2;
+131:4|      3: &lt;1, 1&gt;              |      i16:
+134:0|      3: &lt;4, 6&gt;              |        %c2 = i16 3;
+136:4|      3: &lt;4, 8&gt;              |        %c3 = i16 4;
+139:0|      3: &lt;1, 2&gt;              |      i32:
+141:4|      3: &lt;4, 10&gt;             |        %c4 = i32 5;
+144:0|      3: &lt;4, 12&gt;             |        %c5 = i32 6;
+146:4|      3: &lt;1, 3&gt;              |      i64:
+149:0|      3: &lt;4, 3&gt;              |        %c6 = i64 -1;
+151:4|      3: &lt;4, 5&gt;              |        %c7 = i64 -2;
+154:0|      3: &lt;1, 4&gt;              |      i1:
+156:4|      3: &lt;4, 3&gt;              |        %c8 = i1 1;
+159:0|      3: &lt;4, 0&gt;              |        %c9 = i1 0;
+161:4|    0: &lt;65534&gt;               |      }
+</pre>
+<h3 id="floating-point-literal">Floating Point Literal</h3>
+<p>The <em>floating point literal</em> record creates a floating point literal for the
+floating point type <em>T</em> defined by the preceding <em>set type</em> record.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%cN = T V;                                      &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;6, VV&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The <em>floating point literal</em> record creates a floating point literal constant
+<code>%cN</code> for type <code>T</code>. <code>T</code> must the type type defined by the preceding <em>set
+type</em> record, and be a floating point type. The literal <code>V</code> is the floating
+value to be defined. The value <code>VV</code> if the corresponding IEEE unsigned integer
+that defines value <code>V</code>. That is, the literal <code>VV</code> must be a valid IEEE 754
+32-bit (unsigned integer) value if <code>T</code> is <code>float</code>, and a valid IEEE 754
+64-bit (unsigned integer) value if <code>T</code> is <code>double</code>.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+N == NumFcnConsts
+T == ConstantsSetType
+IsFloat(T)
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+TypeOf(%cN) = T;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+ 48:0|    3: &lt;1, 4&gt;                |    count 4;
+ 50:4|    3: &lt;3&gt;                   |    &#64;t0 = float;
+ 52:2|    3: &lt;4&gt;                   |    &#64;t1 = double;
+ 54:0|    3: &lt;2&gt;                   |    &#64;t2 = void;
+ 55:6|    3: &lt;21, 0, 2&gt;            |    &#64;t3 = void ();
+ 59:0|  0: &lt;65534&gt;                 |  }
+ ...
+102:4|    1: &lt;65535, 11, 2&gt;        |    constants {  // BlockID = 11
+112:0|      3: &lt;1, 0&gt;              |      float:
+114:4|      3: &lt;6, 0&gt;              |        %c0 = float 0;
+117:0|      3: &lt;6, 1065353216&gt;     |        %c1 = float 1;
+123:2|      3: &lt;6, 1088421888&gt;     |        %c2 = float 7;
+130:2|      3: &lt;6, 1090519040&gt;     |        %c3 = float 8;
+137:2|      3: &lt;3&gt;                 |        %c4 = float undef;
+139:0|      3: &lt;6, 2143289344&gt;     |        %c5 = float nan;
+146:0|      3: &lt;6, 2139095040&gt;     |        %c6 = float inf;
+153:0|      3: &lt;6, 4286578688&gt;     |        %c7 = float -inf;
+160:0|      3: &lt;1, 1&gt;              |      double:
+162:4|      3: &lt;6,                 |        %c8 = double 1;
+     |        4607182418800017408&gt; |
+174:0|      3: &lt;6, 0&gt;              |        %c9 = double 0;
+176:4|      3: &lt;6,                 |        %c10 = double 5;
+     |        4617315517961601024&gt; |
+188:0|      3: &lt;6,                 |        %c11 = double 6;
+     |        4618441417868443648&gt; |
+199:4|      3: &lt;6,                 |        %c12 = double nan;
+     |        9221120237041090560&gt; |
+211:0|      3: &lt;6,                 |        %c13 = double inf;
+     |        9218868437227405312&gt; |
+222:4|      3: &lt;6,                 |        %c14 = double -inf;
+     |        18442240474082181120&gt;|
+234:0|    0: &lt;65534&gt;               |      }
+</pre>
+<h2 id="function-blocks"><span id="link-for-function-blocks-section"></span>Function Blocks</h2>
+<p>A function block defines the implementation of a defined <a class="reference internal" href="#link-for-function-address-section"><em>function
+address</em></a>. The function address it defines is
+based on the position of the corresponding defined function address. The Nth
+defined function address always corresponds to the Nth function block in the
+module block.</p>
+<p>A function implementation contains a list of basic blocks, forming the control
+flow graph. Each <em>basic block</em> contains a list of instructions, and ends with a
+<a class="reference internal" href="#link-for-terminator-instruction-section"><em>terminator instruction</em></a>
+(e.g. branch).</p>
+<p>Basic blocks are not represented by records. Rather, context is implicit. The
+first basic block begins with the first instruction record in the function
+block.  Block boundaries are determined by terminator instructions. The
+instruction that follows a terminator instruction begins a new basic block.</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&#8217;t be any branches to the entry block of a
+function). Because the entry block has no predecessors, it also can&#8217;t have any
+<a class="reference internal" href="#link-for-phi-instruction-section"><em>phi</em></a> instructions.</p>
+<p>The parameters are implied by the type of the corresponding function
+address. One parameter is defined for each argument of the function <a class="reference internal" href="#link-for-function-type"><em>type
+signature</em></a> of the corresponding <a class="reference internal" href="#link-for-function-address-section"><em>function
+address</em></a>.</p>
+<p>The number of basic blocks is defined by the <a class="reference internal" href="#link-for-basic-blocks-count"><em>count
+record</em></a>. Each <a class="reference internal" href="#link-for-terminator-instruction-section"><em>terminator
+instruction</em></a> ends the current basic
+block, and the next instruction begins a new basic block.  Basic blocks are
+numbered by the order they appear (starting with index 0). Basic block IDs have
+the form <code>%bN</code>, where <code>N</code> corresponds to the position of the basic block
+within the function block.</p>
+<p>Each instruction, within a function block, corresponds to a corresponding PNaCl
+record.  The layout of a function block is the (basic block) count record,
+followed by a sequence of instruction records.</p>
+<p>For readability, PNaClAsm introduces basic block IDs. These basic block IDs do
+not correspond to PNaCl records, since basic block boundaries are defined
+implicitly, after terminator instructions. They appear only for readability.</p>
+<p>Operands of instructions are defined using an <a class="reference internal" href="#link-for-absolute-index-section"><em>absolute
+index</em></a>. This absolute index implicitly encodes
+function addresses, global addresses, parameters, constants, and instructions
+that generate values. The encoding takes advantage of the implied ordering of
+these values in the bitcode file, defining a contiguous sequence of indices for
+each kind of identifier.  That is, indices are ordered by putting function
+address identifiers first, followed by global address identifiers, followed by
+parameter identifiers, followed by constant identifiers, and lastly instruction
+value identifiers.</p>
+<p>To save space in the encoded bitcode file, most operands are encoded using a
+<a class="reference internal" href="#link-for-relative-index"><em>relative index</em></a> value, rather than
+<a class="reference internal" href="#link-for-absolute-index-section"><em>absolute</em></a>. This
+is done because most instruction operands refer to values defined earlier in the
+(same) basic block.  As a result, the relative distance (back) from the next
+value defining instruction is frequently a small number. Small numbers tend to
+require fewer bits when they are converted to bit sequences.</p>
+<p>Note that instructions that can appear in a function block are defined in
+sections <a class="reference internal" href="#link-for-terminator-instruction-section"><em>Terminator Instructions</em></a>,
+<a class="reference internal" href="#link-for-integer-binary-instructions"><em>Integer Binary Instructions</em></a>,
+<a class="reference internal" href="#link-for-floating-point-binary-instructions"><em>Floating Point Binary Instructions</em></a>,
+<a class="reference internal" href="#link-for-memory-creation-and-access-instructions"><em>Memory Creation and Access Instructions</em></a>,
+<a class="reference internal" href="#link-for-conversion-instructions"><em>Conversion Instructions</em></a>, <a class="reference internal" href="#link-for-compare-instructions"><em>Comparison Instructions</em></a>,
+<a class="reference internal" href="#link-for-vector-instructions"><em>Vector Instructions</em></a>, and
+<a class="reference internal" href="#link-for-other-pnaclasm-instructions"><em>Other Instructions</em></a>.</p>
+<p>The following subsections define the remaining records that can appear in a
+function block.</p>
+<h3 id="function-enter">Function Enter</h3>
+<p>PNaClAsm defines a function enter block construct. The corresponding record is
+simply an <a class="reference internal" href="#link-for-enter-block-record-section"><em>enter block</em></a> record, with
+BlockID value <code>12</code>. All context about the defining address is implicit by the
+position of the function block, and the corresponding defining <a class="reference internal" href="#link-for-function-address-section"><em>function
+address</em></a>. To improve readability, PNaClAsm
+includes the function signature into the syntax rule.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+function TR &#64;fN ( T0 %p0, ... , TM %pM ) {             &lt;B&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+1: &lt;65535, 12, B&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p><code>B</code> is the number of bits reserved for abbreviations in the block. If it is
+omitted, 2 is assumed. See <a class="reference internal" href="#link-for-enter-block-record-section"><em>enter</em></a>
+block records for more details.</p>
+<p>The value of <code>N</code> corresponds to the positional index of the corresponding
+defining function address this block is associated with. <code>M</code> is the number of
+defined parameters (minus one) in the function heading.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+N == NumFcnImpls &amp;
+&#64;fN in DefiningFcnIDs &amp;
+TypeOfFcn(&#64;fN) == TypeOf(TypeID(TR (T0, ... , TM)))
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumFcnImpls;
+EnclosingFcnID = &#64;fN;
+NumBasicBlocks = 0;
+ExpectedBlocks = 0;
+NumParams = M;
+for I in [0..M]:
+  TypeOf(%pI) = TypeOf(TypeID(TI));
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+ 48:0|    3: &lt;1, 4&gt;                |    count 4;
+ 50:4|    3: &lt;7, 32&gt;               |    &#64;t0 = i32;
+ 53:6|    3: &lt;2&gt;                   |    &#64;t1 = void;
+ 55:4|    3: &lt;21, 0, 1&gt;            |    &#64;t2 = void ();
+ 58:6|    3: &lt;21, 0, 0, 0&gt;         |    &#64;t3 = i32 (i32);
+ 62:6|  0: &lt;65534&gt;                 |  }
+ ...
+104:0|  1: &lt;65535, 12, 2&gt;          |  function void &#64;f0() {
+     |                             |                   // BlockID = 12
+112:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+114:4|    3: &lt;10&gt;                  |    ret void;
+116:2|  0: &lt;65534&gt;                 |  }
+120:0|  1: &lt;65535, 12, 2&gt;          |  function i32 &#64;f1(i32 %p0) {
+     |                             |                   // BlockID = 12
+128:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+130:4|    3: &lt;10, 1&gt;               |    ret i32 %p0;
+133:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="link-for-basic-blocks-count"><span id="id3"></span>Count Record</h3>
+<p>The count record, within a function block, defines the number of basic blocks
+used to define the function implementation. It must be the first record in the
+function block.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+  blocks: N;                                    &lt;A&gt;
+%b0:
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;1, N&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The count record defines the number <code>N</code> of basic blocks in the implemented
+function.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+ExpectedBasicBlocks == N &amp;
+NumBasicBlocks == 0
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+104:0|  1: &lt;65535, 12, 2&gt;          |  function void &#64;f0() {
+     |                             |                   // BlockID = 12
+112:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+114:4|    3: &lt;10&gt;                  |    ret void;
+116:2|  0: &lt;65534&gt;                 |  }
+120:0|  1: &lt;65535, 12, 2&gt;          |  function i32 &#64;f1(i32 %p0) {
+     |                             |                   // BlockID = 12
+128:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+130:4|    3: &lt;10, 1&gt;               |    ret i32 %p0;
+133:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h2 id="terminator-instructions"><span id="link-for-terminator-instruction-section"></span>Terminator Instructions</h2>
+<p>Terminator instructions are instructions that appear in a <a class="reference internal" href="#link-for-function-blocks-section"><em>function
+block</em></a>, and define the end of the current
+basic block. A terminator instruction indicates which block should be executed
+after the current block is finished. The function block is well formed only if
+the number of terminator instructions, in the function block, corresponds to the
+value defined by the corresponding function basic block <a class="reference internal" href="#link-for-basic-blocks-count"><em>count
+record</em></a>.</p>
+<p>Note that any branch instruction to label <code>%bN</code>, where <code>N &gt;=
+ExpectedBasicBlocks</code>, is illegal. For ease of readability, this constraint
+hasn&#8217;t been put on branch instructions. Rather it is only implied.</p>
+<p>In addition, it must be the case that <code>NumBasicBlocks &lt; ExpectedBasicBlocks</code>,
+and will not be listed as a constraint. Further, if <code>B = NumBasicBlocks + 1</code>
+is the number associated with the next basic block.  Label <cite>%bB:</cite> only appears
+if:</p>
+<pre class="prettyprint">
+B &lt; ExpectedBasicBlocks
+</pre>
+<p>That is, the label is omitted only if this terminator instruction is the last
+instruction in the function block.</p>
+<h3 id="return-void-instruction">Return Void Instruction</h3>
+<p>The return void instruction is used to return control from a function back to
+the caller, without returning any value.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+  ret void;                                     &lt;A&gt;
+%bB:
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;10&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The return void instruction returns control to the calling function.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+B == NumBasicBlocks + 1 &amp;
+ReturnType(TypeOf(EnclosingFcnID)) == void
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumBasicBlocks;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+104:0|  1: &lt;65535, 12, 2&gt;          |  function void &#64;f0() {
+     |                             |                   // BlockID = 12
+112:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+114:4|    3: &lt;10&gt;                  |    ret void;
+116:2|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="return-value-instruction">Return Value Instruction</h3>
+<p>The return value instruction is used to return control from a function back to
+the caller, including a value. The value must correspond to the return type of
+the enclosing function.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+  ret T V;                                      &lt;A&gt;
+%bB:
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;10, VV&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The return value instruction returns control to the calling function, returning
+the provided value.</p>
+<p><code>V</code> is the value to return. Type <code>T</code> must be of the type returned by the
+function.  It must also be the type associated with value <code>V</code>.</p>
+<p>The return type <code>T</code> must either be a (non-void) primitive type, or a vector
+type. If the function block is implementing an ordinary function, and the return
+type is an integer type, it must be either <code>i32</code> or <code>i64</code>.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+VV == RelativeIndex(V) &amp;
+B == NumBasicBlocks + 1 &amp;
+T == TypeOf(V) == ReturnType(TypeOf(EnclosingFcnID))
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumBasicBlocks;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+120:0|  1: &lt;65535, 12, 2&gt;          |  function i32 &#64;f1(i32 %p0) {
+     |                             |                   // BlockID = 12
+128:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+130:4|    3: &lt;10, 1&gt;               |    ret i32 %p0;
+</pre>
+<h3 id="unconditional-branch-instruction">Unconditional Branch Instruction</h3>
+<p>The unconditional branch instruction is used to cause control flow to transfer
+to a different basic block of the function.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+  br %bN;                                       &lt;A&gt;
+%bB:
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;11, N&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The unconditional branch instruction causes control flow to transfer to basic
+block <code>N</code>.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+B == NumBasicBlocks + 1 &amp;
+0 &lt; N &amp;
+N &lt; ExpectedBasicBlocks
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumBasicBlocks;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 88:0|  1: &lt;65535, 12, 2&gt;          |  function void &#64;f0() {
+     |                             |                   // BlockID = 12
+ 96:0|    3: &lt;1, 5&gt;                |    blocks 5;
+     |                             |  %b0:
+ 98:4|    3: &lt;11, 3&gt;               |    br label %b3;
+     |                             |  %b1:
+101:0|    3: &lt;11, 4&gt;               |    br label %b4;
+     |                             |  %b2:
+103:4|    3: &lt;11, 1&gt;               |    br label %b1;
+     |                             |  %b3:
+106:0|    3: &lt;11, 2&gt;               |    br label %b2;
+     |                             |  %b4:
+108:4|    3: &lt;10&gt;                  |    ret void;
+110:2|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="conditional-branch-instruction">Conditional Branch Instruction</h3>
+<p>The conditional branch instruction is used to cause control flow to transfer to
+a different basic block of the function, based on a boolean test condition.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+  br i1 C, %bT, %bBF;                          &lt;A&gt;
+%bB:
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;11, T, F, CC&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>Upon execution of a conditional branch instruction, the <em>i1</em> (boolean) argument
+<code>C</code> is evaluated. If the value is <code>true</code>, control flows to basic block
+<code>%bT</code>. Otherwise control flows to basic block <code>%bF</code>.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+CC == RelativeIndex(C) &amp;
+B == NumBasicBlocks + 1 &amp;
+0 &lt; T &amp;
+B1 &lt; ExpectedBasicBlocks &amp;
+0 &lt; F &amp;
+B2 &lt; ExpectedBasicBlocks &amp;
+TypeOf(C) == i1
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumBasicBlocks;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 92:0|  1: &lt;65535, 12, 2&gt;          |  function void &#64;f0() {
+     |                             |                   // BlockID = 12
+100:0|    3: &lt;1, 5&gt;                |    blocks 5;
+102:4|    1: &lt;65535, 11, 2&gt;        |    constants {  // BlockID = 11
+112:0|      3: &lt;1, 1&gt;              |      i1:
+114:4|      3: &lt;4, 3&gt;              |        %c0 = i1 1;
+117:0|      3: &lt;4, 0&gt;              |        %c1 = i1 0;
+119:4|    0: &lt;65534&gt;               |      }
+     |                             |  %b0:
+120:0|    3: &lt;11, 3&gt;               |    br label %b3;
+     |                             |  %b1:
+122:4|    3: &lt;11, 2, 4, 2&gt;         |    br i1 %c0, label %b2, label %b4;
+     |                             |  %b2:
+126:4|    3: &lt;11, 3&gt;               |    br label %b3;
+     |                             |  %b3:
+129:0|    3: &lt;10&gt;                  |    ret void;
+     |                             |  %b4:
+130:6|    3: &lt;11, 2, 3, 1&gt;         |    br i1 %c1, label %b2, label %b3;
+134:6|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="unreachable">Unreachable</h3>
+<p>The unreachable instruction has no defined semantics. The instruction is used to
+inform the <a class="reference internal" href="/native-client/overview.html#link-for-pnacl-translator"><em>PNaCl translator</em></a> that control
+can&#8217;t reach this instruction.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+  unreachable;                                  &lt;A&gt;
+%bB:
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;15&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>Directive to the <a class="reference internal" href="/native-client/overview.html#link-for-pnacl-translator"><em>PNaCl translator</em></a> that
+this instruction is unreachable.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A)
+B == NumBasicBlocks + 1 &amp;
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumBasicBlocks;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+108:0|  1: &lt;65535, 12, 2&gt;          |  function void &#64;f0(i32 %p0) {
+     |                             |                   // BlockID = 12
+116:0|    3: &lt;1, 5&gt;                |    blocks 5;
+118:4|    1: &lt;65535, 11, 2&gt;        |    constants {  // BlockID = 11
+128:0|      3: &lt;1, 2&gt;              |      i1:
+130:4|      3: &lt;4, 3&gt;              |        %c0 = i1 1;
+133:0|      3: &lt;4, 0&gt;              |        %c1 = i1 0;
+135:4|    0: &lt;65534&gt;               |      }
+     |                             |  %b0:
+136:0|    3: &lt;11, 1, 2, 2&gt;         |    br i1 %c0, label %b1, label %b2;
+     |                             |  %b1:
+140:0|    3: &lt;11, 3, 4, 1&gt;         |    br i1 %c1, label %b3, label %b4;
+     |                             |  %b2:
+144:0|    3: &lt;15&gt;                  |    unreachable;
+     |                             |  %b3:
+145:6|    3: &lt;15&gt;                  |    unreachable;
+     |                             |  %b4:
+147:4|    3: &lt;10&gt;                  |    ret void;
+149:2|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="switch-instruction">Switch Instruction</h3>
+<p>The <em>switch</em> instruction transfers control flow to one of several different
+places, based on a selector value. It is a generalization of the conditional
+branch instruction.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+  switch T V0 {
+    default: br label %bB0;
+    T V1:    br label %bB1;
+    ...
+    T VN:    br label %bBN;
+  }                                             &lt;A&gt;
+%bB:
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;12, TT, B0, N, (1, 1, VVI, BI | 1 &lt;= i &lt;= N)&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The switch instruction transfers control to a basic block in <code>B0</code> through
+<code>BN</code>.  Value <code>V</code> is used to conditionally select which block to branch
+to. <code>T</code> is the type of <code>V</code> and <code>V1</code> through <code>VN</code>, and must be an integer
+type. Value <code>V1</code> through <code>VN</code> are integers to compare against <code>V</code>. If
+selector <code>V</code> matches <code>VI</code> (for some <code>I</code>, <code>1 &lt;= I &lt;= N</code>), then the
+instruction branches to block <code>BI</code>. If <code>V</code> is not in <code>V1</code> through <code>VN</code>,
+the instruction branches to block <code>B0</code>.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+B == NumBasicBlocks + 1 &amp;
+TT == TypeID(T) &amp;
+VI == SignRotate(VI) for all I, 1 &lt;= I &lt;= N &amp;
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumBasicBlocks;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+116:0|  1: &lt;65535, 12, 2&gt;          |  function void &#64;f0(i32 %p0) {
+     |                             |                   // BlockID = 12
+124:0|    3: &lt;1, 6&gt;                |    blocks 6;
+     |                             |  %b0:
+126:4|    3: &lt;12, 1, 1, 2, 4, 1, 1,|    switch i32 %p0 {
+     |        2, 3, 1, 1, 4, 3, 1, |      default: br label %b2;
+     |        1, 8, 4, 1, 1, 10, 4&gt;|      i32 1: br label %b3;
+     |                             |      i32 2: br label %b3;
+     |                             |      i32 4: br label %b4;
+     |                             |      i32 5: br label %b4;
+     |                             |    }
+     |                             |  %b1:
+143:2|    3: &lt;11, 5&gt;               |    br label %b5;
+     |                             |  %b2:
+145:6|    3: &lt;11, 5&gt;               |    br label %b5;
+     |                             |  %b3:
+148:2|    3: &lt;11, 5&gt;               |    br label %b5;
+     |                             |  %b4:
+150:6|    3: &lt;11, 5&gt;               |    br label %b5;
+     |                             |  %b5:
+153:2|    3: &lt;10&gt;                  |    ret void;
+155:0|  0: &lt;65534&gt;                 |  }
+156:0|  1: &lt;65535, 12, 2&gt;          |  function void &#64;f1(i64 %p0) {
+     |                             |                   // BlockID = 12
+164:0|    3: &lt;1, 6&gt;                |    blocks 6;
+     |                             |  %b0:
+166:4|    3: &lt;12, 2, 1, 2, 4, 1, 1,|    switch i64 %p0 {
+     |        2, 3, 1, 1, 4, 3, 1, |      default: br label %b2;
+     |        1, 8, 4, 1, 1,       |      i64 1: br label %b3;
+     |        39777555332, 4&gt;      |      i64 2: br label %b3;
+     |                             |      i64 4: br label %b4;
+     |                             |      i64 19888777666: br label %b4;
+     |                             |    }
+     |                             |  %b1:
+188:4|    3: &lt;11, 5&gt;               |    br label %b5;
+     |                             |  %b2:
+191:0|    3: &lt;11, 5&gt;               |    br label %b5;
+     |                             |  %b3:
+193:4|    3: &lt;11, 5&gt;               |    br label %b5;
+     |                             |  %b4:
+196:0|    3: &lt;11, 5&gt;               |    br label %b5;
+     |                             |  %b5:
+198:4|    3: &lt;10&gt;                  |    ret void;
+200:2|  0: &lt;65534&gt;                 |  }
+</pre>
+<h2 id="integer-binary-instructions"><span id="link-for-integer-binary-instructions"></span>Integer Binary Instructions</h2>
+<p>Binary instructions are used to do most of the computation in a program. This
+section focuses on binary instructions that operator on integer values, or
+vectors of integer values.</p>
+<p>All binary operations require two operands of the same type, execute an
+operation on them, and produce a value. The value may represent multiple values
+if the type is a vector type.  The result value always has the same type as its
+operands.</p>
+<p>Some integer binary operations can be applied to both signed and unsigned
+integers. Others, the sign is significant. In general, if the sign plays a role
+in the instruction, the sign information is encoded into the name of the
+instruction.</p>
+<p>For most binary operations (except some of the logical operations), integer
+type i1 is disallowed.</p>
+<h3 id="integer-add">Integer Add</h3>
+<p>The integer add instruction returns the sum of its two arguments. Both arguments
+and the result must be of the same type. That type must be integer, or an
+integer vector type.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = add T V1, V2;                             &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;2, VV1, VV2, 0&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The integer add instruction returns the sum of its two arguments. Arguments
+<code>V1</code> and <code>V2</code>, and the result <code>%vN</code>, must be of type <code>T</code>. <code>T</code> must be
+an integer type, or an integer vector type.  <code>N</code> is defined by the record
+position, defining the corresponding value generated by the instruction.</p>
+<p>The result returned is the mathematical result modulo 2<sup>n</sup>, where <code>n</code>
+is the bit width of the integer result.</p>
+<p>Because integers are assumed to use a two&#8217;s complement representation,
+this instruction is appropriate for both signed and unsigned integers.</p>
+<p>In the add instruction, integer type <code>i1</code> (and a vector of integer type
+<code>i1</code>) is disallowed.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+VV1 == RelativeIndex(V1) &amp;
+VV2 == RelativeIndex(V2) &amp;
+T == TypeOf(V1) == TypeOf(V2) &amp;
+IsInteger(UnderlyingType(T)) &amp;
+UnderlyingType(T) != i1 &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 96:0|  1: &lt;65535, 12, 2&gt;          |  function i32 &#64;f0(i32 %p0, i32 %p1) {
+     |                             |                   // BlockID = 12
+104:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+106:4|    3: &lt;2, 2, 1, 0&gt;          |    %v0 = add i32 %p0, %p1;
+110:4|    3: &lt;2, 3, 1, 0&gt;          |    %v1 = add i32 %p0, %v0;
+114:4|    3: &lt;10, 1&gt;               |    ret i32 %v1;
+117:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="integer-subtract">Integer Subtract</h3>
+<p>The integer subtract instruction returns the difference of its two arguments.
+Both arguments and the result must be of the same type. That type must be
+integer, or an integer vector type.</p>
+<p>Note: Since there isn&#8217;t a negate instruction, subtraction from constant zero
+should be used to negate values.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = sub T V1, V2;                             &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;2, VV1, VV2, 1&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The integer subtract returns the difference of its two arguments. Arguments
+<code>V1</code> and <code>V2</code>, and the result <code>%vN</code> must be of type <code>T</code>. <code>T</code> must be
+an integer type, or an integer vector type. <code>N</code> is defined by the record
+position, defining the corresponding value generated by the instruction.</p>
+<p>The result returned is the mathematical result modulo 2<sup>n</sup>, where <code>n</code>
+is the bit width of the integer result.</p>
+<p>Because integers are assumed to use a two&#8217;s complement representation,
+this instruction is appropriate for both signed and unsigned integers.</p>
+<p>In the subtract instruction, integer type <code>i1</code> (and a vector of integer type
+<code>i1</code>) is disallowed.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+VV1 == RelativeIndex(V1) &amp;
+VV2 == RelativeIndex(V2) &amp;
+T == TypeOf(V1) == TypeOf(V2) &amp;
+IsInteger(UnderlyingType(T)) &amp;
+UnderlyingType(T) != i1 &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 96:0|  1: &lt;65535, 12, 2&gt;          |  function i32 &#64;f0(i32 %p0, i32 %p1) {
+     |                             |                   // BlockID = 12
+104:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+106:4|    3: &lt;2, 2, 1, 1&gt;          |    %v0 = sub i32 %p0, %p1;
+110:4|    3: &lt;2, 3, 1, 1&gt;          |    %v1 = sub i32 %p0, %v0;
+114:4|    3: &lt;10, 1&gt;               |    ret i32 %v1;
+117:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="integer-multiply">Integer Multiply</h3>
+<p>The integer multiply instruction returns the product of its two arguments.  Both
+arguments and the result must be of the same type. That type must be integer,
+or an integer based vector type.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+&amp;vN = mul T V1, V2;                             &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;2, VV1, VV2, 2&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The integer multiply instruction returns the product of its two
+arguments. Arguments <code>V1</code> and <code>V2</code>, and the result <code>%vN</code>, must be of type
+<code>T</code>.  <code>T</code> must be an integer type, or an integer vector type. <code>N</code> is
+defined by the record position, defining the corresponding value generated by
+the instruction.</p>
+<p>The result returned is the mathematical result modulo 2<sup>n</sup>, where <code>n</code>
+is the bit width of the integer result.</p>
+<p>Because integers are assumed to use a two&#8217;s complement representation,
+this instruction is appropriate for both signed and unsigned integers.</p>
+<p>In the subtract instruction, integer type <code>i1</code> (or a vector on integer type
+<code>i1</code>) is disallowed.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+VV1 == RelativeIndex(V1) &amp;
+VV2 == RelativeIndex(V2) &amp;
+T == TypeOf(V1) == TypeOf(V2) &amp;
+IsInteger(UnderlyingType(T)) &amp;
+UnderlyingType(T) != i1 &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 96:0|  1: &lt;65535, 12, 2&gt;          |  function i32 &#64;f0(i32 %p0, i32 %p1) {
+     |                             |                   // BlockID = 12
+104:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+106:4|    3: &lt;2, 2, 1, 2&gt;          |    %v0 = mul i32 %p0, %p1;
+110:4|    3: &lt;2, 1, 3, 2&gt;          |    %v1 = mul i32 %v0, %p0;
+114:4|    3: &lt;10, 1&gt;               |    ret i32 %v1;
+117:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="signed-integer-divide">Signed Integer Divide</h3>
+<p>The signed integer divide instruction returns the quotient of its two arguments.
+Both arguments and the result must be of the same type. That type must be
+integer, or an integer vector type.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = sdiv T V1, V2;                             &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;2, VV1, VV2, 4&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The signed integer divide instruction returns the quotient of its two
+arguments. Arguments <code>V1</code> and <code>V2</code>, and the result <code>%vN</code>, must be of type
+<code>T</code>. <code>T</code> must be a integer type, or an integer vector type. <code>N</code> is defined
+by the record position, defining the corresponding value generated by the
+instruction.</p>
+<p>Signed values are assumed.  Note that signed and unsigned integer division are
+distinct operations. For unsigned integer division use the unsigned integer
+divide instruction (udiv).</p>
+<p>In the signed integer divide instruction, integer type <code>i1</code> (and a vector of
+integer type <code>i1</code>) is disallowed. Integer division by zero is guaranteed to
+trap.</p>
+<p>Note that overflow can happen with this instruction when dividing the maximum
+negative integer by <code>-1</code>. The behavior for this case is currently undefined.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+VV1 == RelativeIndex(V1) &amp;
+VV2 == RelativeIndex(V2) &amp;
+T == TypeOf(V1) == TypeOf(V2) &amp;
+IsInteger(UnderlyingType(T)) &amp;
+UnderlyingType(T) != i1 &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 96:0|  1: &lt;65535, 12, 2&gt;          |  function i32 &#64;f0(i32 %p0, i32 %p1) {
+     |                             |                   // BlockID = 12
+104:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+106:4|    3: &lt;2, 2, 1, 4&gt;          |    %v0 = sdiv i32 %p0, %p1;
+110:4|    3: &lt;2, 1, 2, 4&gt;          |    %v1 = sdiv i32 %v0, %p1;
+114:4|    3: &lt;10, 1&gt;               |    ret i32 %v1;
+117:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="unsigned-integer-divide">Unsigned Integer Divide</h3>
+<p>The unsigned integer divide instruction returns the quotient of its two
+arguments. Both the arguments and the result must be of the same type. That type
+must be integer, or an integer vector type.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = udiv T V1, V2;                            &lt;a&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;2, A1, A2, 3&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The unsigned integer divide instruction returns the quotient of its two
+arguments. Arguments <code>V1</code> and <code>V2</code>, and the result <code>%vN</code>, must be of type
+<code>T</code>. <code>T</code> must be an integer type, or an integer vector type.  <code>N</code> is
+defined by the record position, defining the corresponding value generated by
+the instruction.</p>
+<p>Unsigned integer values are assumed.  Note that signed and unsigned integer
+division are distinct operations. For signed integer division use the signed
+integer divide instruction (sdiv).</p>
+<p>In the unsigned integer divide instruction, integer type <code>i1</code> (and a vector of
+integer type <code>i1</code>) is disallowed. Division by zero is guaranteed to trap.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+VV1 == RelativeIndex(V1) &amp;
+VV2 == RelativeIndex(V2) &amp;
+T == TypeOf(V1) == TypeOf(V2) &amp;
+IsInteger(UnderlyingType(T)) &amp;
+UnderlyingType(T) != i1 &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 96:0|  1: &lt;65535, 12, 2&gt;          |  function i32 &#64;f0(i32 %p0, i32 %p1) {
+     |                             |                   // BlockID = 12
+104:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+106:4|    3: &lt;2, 2, 1, 3&gt;          |    %v0 = udiv i32 %p0, %p1;
+110:4|    3: &lt;2, 1, 2, 3&gt;          |    %v1 = udiv i32 %v0, %p1;
+114:4|    3: &lt;10, 1&gt;               |    ret i32 %v1;
+117:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="signed-integer-remainder">Signed Integer Remainder</h3>
+<p>The signed integer remainder instruction returns the remainder of the quotient
+of its two arguments. Both arguments and the result must be of the same
+type. That type must be integer, or an integer based vector type.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = srem T V1, V2;                             &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;2, VV1, VV2, 6&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The signed integer remainder instruction returns the remainder of the quotient
+of its two arguments. Arguments <code>V1</code> and <code>V2</code>, and the result <code>%vN</code>, must
+be of type <code>T</code>. <code>T</code> must be a integer type, or an integer vector type. <code>N</code>
+is defined by the record position, defining the corresponding value generated by
+the instruction.</p>
+<p>Signed values are assumed.  Note that signed and unsigned integer division are
+distinct operations. For unsigned integer division use the unsigned integer
+remainder instruction (urem).</p>
+<p>In the signed integer remainder instruction, integer type <code>i1</code> (and a vector
+of integer type <code>i1</code>) is disallowed.  Division by zero is guaranteed to trap.</p>
+<p>Note that overflow can happen with this instruction when dividing the maximum
+negative integer by <code>-1</code>. The behavior for this case is currently undefined.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+VV1 == RelativeIndex(V1) &amp;
+VV2 == RelativeIndex(V2) &amp;
+T == TypeOf(V1) == TypeOf(V2) &amp;
+IsInteger(UnderlyingType(T)) &amp;
+UnderlyingType(T) != i1 &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 96:0|  1: &lt;65535, 12, 2&gt;          |  function i32 &#64;f0(i32 %p0, i32 %p1) {
+     |                             |                   // BlockID = 12
+104:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+106:4|    3: &lt;2, 2, 1, 6&gt;          |    %v0 = srem i32 %p0, %p1;
+110:4|    3: &lt;2, 1, 2, 6&gt;          |    %v1 = srem i32 %v0, %p1;
+114:4|    3: &lt;10, 1&gt;               |    ret i32 %v1;
+117:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="unsigned-integer-remainder-instruction">Unsigned Integer Remainder Instruction</h3>
+<p>The unsigned integer remainder instruction returns the remainder of the quotient
+of its two arguments. Both the arguments and the result must be of the same
+type. The type must be integer, or an integer vector type.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = urem T V1, V2;                            &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;2, A1, A2, 5&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The unsigned integer remainder instruction returns the remainder of the quotient
+of its two arguments. Arguments <code>V1</code> and <code>V2</code>, and the result <code>%vN</code>, must
+be of type <code>T</code>. <code>T</code> must be an integer type, or an integer vector type.
+<code>N</code> is defined by the record position, defining the corresponding value
+generated by the instruction.</p>
+<p>Unsigned values are assumed. Note that signed and unsigned integer division are
+distinct operations. For signed integer division use the remainder instruction
+(srem).</p>
+<p>In the unsigned integer remainder instruction, integer type <code>i1</code> (and a vector
+of integer type <code>i1</code>) is disallowed.  Division by zero is guaranteed to trap.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+VV1 == RelativeIndex(V1) &amp;
+VV2 == RelativeIndex(V2) &amp;
+T == TypeOf(V1) == TypeOf(V2) &amp;
+IsInteger(UnderlyingType(T)) &amp;
+UnderlyingType(T) != i1 &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 96:0|  1: &lt;65535, 12, 2&gt;          |  function i32 &#64;f0(i32 %p0, i32 %p1) {
+     |                             |                   // BlockID = 12
+104:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+106:4|    3: &lt;2, 2, 1, 5&gt;          |    %v0 = urem i32 %p0, %p1;
+110:4|    3: &lt;2, 1, 2, 5&gt;          |    %v1 = urem i32 %v0, %p1;
+114:4|    3: &lt;10, 1&gt;               |    ret i32 %v1;
+117:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="shift-left">Shift Left</h3>
+<p>The (integer) shift left instruction returns the first operand, shifted to the
+left a specified number of bits with zero fill. The shifted value must be
+integer, or an integer vector type.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = shl T V1, V2;                             &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;2, VV1, VV2, 7&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>This instruction performs a shift left operation. Arguments <code>V1</code> and <code>V2</code>
+and the result <code>%vN</code> must be of type <code>T</code>. <code>T</code> must be an integer, or a
+vector of integers. <code>N</code> is defined by the record position, defining the
+corresponding value generated by the instruction.</p>
+<p><code>V2</code> is assumed to be unsigned.  The least significant bits of the result will
+be filled with zero bits after the shift. If <code>V2</code> is (statically or
+dynamically) negative or equal to or larger than the number of bits in
+<code>V1</code>, the result is undefined. If the arguments are vectors, each vector
+element of <code>V1</code> is shifted by the corresponding shift amount in <code>V2</code>.</p>
+<p>In the shift left instruction, integer type <code>i1</code> (and a vector of integer type
+<code>i1</code>) is disallowed.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+VV1 == RelativeIndex(V1) &amp;
+VV2 == RelativeIndex(V2) &amp;
+T == TypeOf(V1) == TypeOf(V2) &amp;
+IsInteger(UnderlyingType(T)) &amp;
+UnderlyingType(T) != i1 &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 96:0|  1: &lt;65535, 12, 2&gt;          |  function i32 &#64;f0(i32 %p0, i32 %p1) {
+     |                             |                   // BlockID = 12
+104:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+106:4|    3: &lt;2, 2, 1, 7&gt;          |    %v0 = shl i32 %p0, %p1;
+110:4|    3: &lt;2, 1, 2, 7&gt;          |    %v1 = shl i32 %v0, %p1;
+114:4|    3: &lt;10, 1&gt;               |    ret i32 %v1;
+117:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="logical-shift-right">Logical Shift Right</h3>
+<p>The logical shift right instruction returns the first operand, shifted to the
+right a specified number of bits with zero fill.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = lshr T V1, V2;                            &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;2, VV1, VV2, 8&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>This instruction performs a logical shift right operation. Arguments <code>V1</code> and
+<code>V2</code> and the result <code>%vN</code> must be of type <code>T</code>. <code>T</code> must be an integer,
+or a vector of integers. <code>N</code> is defined by the record position, defining the
+corresponding value generated by the instruction.</p>
+<p><code>V2</code> is assumed to be unsigned. The most significant bits of the result will
+be filled with zero bits after the shift. If <code>V2</code> is (statically or
+dynamically) negative or equal to or larger than the number of bits in <code>V1</code>,
+the result is undefined. If the arguments are vectors, each vector element of
+<code>V1</code> is shifted by the corresponding shift amount in <code>V2</code>.</p>
+<p>In the logical shift right instruction, integer type <code>i1</code> (and a vector of
+integer type <code>i1</code>) is disallowed.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+VV1 == RelativeIndex(V1) &amp;
+VV2 == RelativeIndex(V2) &amp;
+T == TypeOf(V1) == TypeOf(V2) &amp;
+IsInteger(UnderlyingType(T)) &amp;
+UnderlyingType(T) != i1 &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 96:0|  1: &lt;65535, 12, 2&gt;          |  function i32 &#64;f0(i32 %p0, i32 %p1) {
+     |                             |                   // BlockID = 12
+104:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+106:4|    3: &lt;2, 2, 1, 8&gt;          |    %v0 = lshr i32 %p0, %p1;
+110:4|    3: &lt;2, 1, 2, 8&gt;          |    %v1 = lshr i32 %v0, %p1;
+114:4|    3: &lt;10, 1&gt;               |    ret i32 %v1;
+117:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="arithmetic-shift-right">Arithmetic Shift Right</h3>
+<p>The arithmetic shift right instruction returns the first operand, shifted to the
+right a specified number of bits with sign extension.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = ashr T V1, V2;                            &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;2, VV1, VVA2, 9&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>This instruction performs an arithmetic shift right operation. Arguments <code>V1</code>
+and <code>V2</code> and and the result <code>%vN</code> must be of type <code>T</code>. <code>T</code> must be an
+integer, or a vector of integers. <code>N</code> is defined by the record position,
+defining the corresponding value generated by the instruction.</p>
+<p><code>V2</code> is assumed to be unsigned. The most significant bits of the result will
+be filled with the sign bit of <code>V1</code>. If <code>V2</code> is (statically or dynamically)
+negative or equal to or larger than the number of bits in <code>V1</code>, the result is
+undefined. If the arguments are vectors, each vector element of <code>V1</code> is
+shifted by the corresponding shift amount in <code>V2</code>.</p>
+<p>In the arithmetic shift right instruction, integer type <code>i1</code> (and a vector of
+integral type <code>i1</code>) is disallowed.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+VV1 == RelativeIndex(V1) &amp;
+VV2 == RelativeIndex(V2) &amp;
+T == TypeOf(V1) == TypeOf(V2) &amp;
+IsInteger(UnderlyingType(T)) &amp;
+UnderlyingType(T) != i1 &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 96:0|  1: &lt;65535, 12, 2&gt;          |  function i32 &#64;f0(i32 %p0, i32 %p1) {
+     |                             |                   // BlockID = 12
+104:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+106:4|    3: &lt;2, 2, 1, 9&gt;          |    %v0 = ashr i32 %p0, %p1;
+110:4|    3: &lt;2, 1, 2, 9&gt;          |    %v1 = ashr i32 %v0, %p1;
+114:4|    3: &lt;10, 1&gt;               |    ret i32 %v1;
+117:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="logical-and">Logical And</h3>
+<p>The <em>and</em> instruction returns the bitwise logical and of its two operands.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = and T V1, V2;                             &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;2, VV1, VV2, 10&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>This instruction performs a bitwise logical and of its arguments.  Arguments
+<code>V1</code> and <code>V2</code>, and the result <code>%vN</code> must be of type <code>T</code>. <code>T</code> must be
+an integer, or a vector of integers. <code>N</code> is defined by the record position,
+defining the corresponding value generated by the instruction.  <code>A</code> is the
+(optional) abbreviation associated with the corresponding record.</p>
+<p>The truth table used for the <em>and</em> instruction is:</p>
+<table border="1" class="docutils">
+<colgroup>
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">Arg 1</th>
+<th class="head">Arg 2</th>
+<th class="head">Result</th>
+</tr>
+</thead>
+<tbody valign="top">
+<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>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+VV1 == RelativeIndex(V1) &amp;
+VV2 == RelativeIndex(V2) &amp;
+T == TypeOf(V1) == TypeOf(V2) &amp;
+IsInteger(UnderlyingType(T))) &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 96:0|  1: &lt;65535, 12, 2&gt;          |  function i32 &#64;f0(i32 %p0, i32 %p1) {
+     |                             |                   // BlockID = 12
+104:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+106:4|    3: &lt;2, 2, 1, 10&gt;         |    %v0 = and i32 %p0, %p1;
+110:4|    3: &lt;2, 1, 2, 10&gt;         |    %v1 = and i32 %v0, %p1;
+114:4|    3: &lt;10, 1&gt;               |    ret i32 %v1;
+117:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="logical-or">Logical Or</h3>
+<p>The <em>or</em> instruction returns the bitwise logical inclusive or of its
+two operands.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = or T V1, V2;                              &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;2, VV1, VV2, 11&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>This instruction performs a bitwise logical inclusive or of its arguments.
+Arguments <code>V1</code> and <code>V2</code>, and the result <code>%vN</code> must be of type <code>T</code>. <code>T</code>
+must be an integer, or a vector of integers. <code>N</code> is defined by the record
+position, defining the corresponding value generated by the instruction.</p>
+<p>The truth table used for the <em>or</em> instruction is:</p>
+<table border="1" class="docutils">
+<colgroup>
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">Arg 1</th>
+<th class="head">Arg 2</th>
+<th class="head">Result</th>
+</tr>
+</thead>
+<tbody valign="top">
+<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>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+VV1 == RelativeIndex(V1) &amp;
+VV2 == RelativeIndex(V2) &amp;
+T == TypeOf(V1) == TypeOf(V2) &amp;
+IsInteger(UnderlyingType(T))) &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 96:0|  1: &lt;65535, 12, 2&gt;          |  function i32 &#64;f0(i32 %p0, i32 %p1) {
+     |                             |                   // BlockID = 12
+104:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+106:4|    3: &lt;2, 2, 1, 11&gt;         |    %v0 = or i32 %p0, %p1;
+110:4|    3: &lt;2, 1, 2, 11&gt;         |    %v1 = or i32 %v0, %p1;
+114:4|    3: &lt;10, 1&gt;               |    ret i32 %v1;
+117:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="logical-xor">Logical Xor</h3>
+<p>The <em>xor</em> instruction returns the bitwise logical exclusive or of its
+two operands.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = xor T V1, V2;                             &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;2, VV1, VV2, 12&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>This instruction performs a bitwise logical exclusive or of its arguments.
+Arguments <code>V1</code> and <code>V2</code>, and the result <code>%vN</code> must be of type <code>T</code>. <code>T</code>
+must be an integer, or a vector of integers. <code>N</code> is defined by the record
+position, defining the corresponding value generated by the instruction.</p>
+<p>The truth table used for the <em>xor</em> instruction is:</p>
+<table border="1" class="docutils">
+<colgroup>
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">Arg 1</th>
+<th class="head">Arg 2</th>
+<th class="head">Result</th>
+</tr>
+</thead>
+<tbody valign="top">
+<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>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+A1 == RelativeIndex(V1) &amp;
+A2 == RelativeIndex(V2) &amp;
+T == TypeOf(V1) == TypeOf(V2) &amp;
+IsInteger(UnderlyingType(T))) &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 96:0|  1: &lt;65535, 12, 2&gt;          |  function i32 &#64;f0(i32 %p0, i32 %p1) {
+     |                             |                   // BlockID = 12
+104:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+106:4|    3: &lt;2, 2, 1, 12&gt;         |    %v0 = xor i32 %p0, %p1;
+110:4|    3: &lt;2, 1, 2, 12&gt;         |    %v1 = xor i32 %v0, %p1;
+114:4|    3: &lt;10, 1&gt;               |    ret i32 %v1;
+117:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h2 id="floating-point-binary-instructions"><span id="link-for-floating-point-binary-instructions"></span>Floating Point Binary Instructions</h2>
+<p>Floating point binary instructions require two operands of the same type,
+execute an operation on them, and produce a value. The value may represent
+multiple values if the type is a vector type.  The result value always has the
+same type as its operands.</p>
+<h3 id="floating-point-add">Floating Point Add</h3>
+<p>The floating point add instruction returns the sum of its two arguments. Both
+arguments and the result must be of the same type. That type must be a floating
+point type, or a vector of a floating point type.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = fadd T V1, V2;                            &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;2, VV1, VV2, 0&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The floating point add instruction returns the sum of its two arguments.
+Arguments <code>V1</code> and <code>V2</code> and the result <code>%vN</code> must be of type <code>T</code>. <code>T</code>
+must be a floating point type, or a vector of a floating point type. <code>N</code> is
+defined by the record position, defining the corresponding value generated by
+the instruction.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+VV1 == RelativeIndex(V1) &amp;
+VV2 == RelativeIndex(V2) &amp;
+T == TypeOf(V1) == TypeOf(V2) &amp;
+IsFloat(UnderlyingType(T)) &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 92:0|  1: &lt;65535, 12, 2&gt;          |  function
+     |                             |      float &#64;f0(float %p0, float %p1) {
+     |                             |                    // BlockID = 12
+100:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+102:4|    3: &lt;2, 2, 1, 0&gt;          |    %v0 = fadd float %p0, %p1;
+106:4|    3: &lt;2, 3, 1, 0&gt;          |    %v1 = fadd float %p0, %v0;
+110:4|    3: &lt;10, 1&gt;               |    ret float %v1;
+113:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="floating-point-subtract">Floating Point Subtract</h3>
+<p>The floating point subtract instruction returns the difference of its two
+arguments. Both arguments and the result must be of the same type. That type
+must be a floating point type, or a vector of a floating point type.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = fsub T V1, V2;                            &lt;a&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;2, VV1, VV2, 1&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The floating point subtract instruction returns the difference of its two
+arguments. Arguments <code>V1</code> and <code>V2</code>, and the result <code>%vN</code> must be of type
+<code>T</code>. <code>T</code> must be a floating point type, or a vector of a floating point
+type. <code>N</code> is defined by the record position, defining the corresponding value
+generated by the instruction.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+VV1 == RelativeIndex(V1) &amp;
+VV2 == RelativeIndex(V2) &amp;
+T == TypeOf(V1) == TypeOf(V2) &amp;
+IsFloat(UnderlyingType(T)) &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 92:0|  1: &lt;65535, 12, 2&gt;          |  function
+     |                             |      float &#64;f0(float %p0, float %p1) {
+     |                             |                    // BlockID = 12
+100:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+102:4|    3: &lt;2, 2, 1, 1&gt;          |    %v0 = fsub float %p0, %p1;
+106:4|    3: &lt;2, 3, 1, 1&gt;          |    %v1 = fsub float %p0, %v0;
+110:4|    3: &lt;10, 1&gt;               |    ret float %v1;
+113:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="floating-point-multiply">Floating Point Multiply</h3>
+<p>The floating point multiply instruction returns the product of its two
+arguments. Both arguments and the result must be of the same type. That type
+must be a floating point type, or a vector of a floating point type.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+&amp;vN = fmul T V1, V2;                            &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;2, VV1, VV2, 2&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The floating point multiply instruction returns the product of its two
+arguments. Arguments <code>V1</code> and <code>V2</code>, and the result <code>%vN</code> must be of type
+<code>T</code>.  <code>T</code> must be a floating point type, or a vector of a floating point
+type. <code>N</code> is defined by the record position, defining the corresponding value
+generated by the instruction.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+VV1 == RelativeIndex(V1) &amp;
+VV2 == RelativeIndex(V2) &amp;
+T == TypeOf(V1) == TypeOf(V2) &amp;
+IsFloat(UnderlyingType(T)) &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 92:0|  1: &lt;65535, 12, 2&gt;          |  function
+     |                             |      float &#64;f0(float %p0, float %p1) {
+     |                             |                    // BlockID = 12
+100:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+102:4|    3: &lt;2, 2, 1, 2&gt;          |    %v0 = fmul float %p0, %p1;
+106:4|    3: &lt;2, 3, 1, 2&gt;          |    %v1 = fmul float %p0, %v0;
+110:4|    3: &lt;10, 1&gt;               |    ret float %v1;
+113:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="floating-point-divide">Floating Point Divide</h3>
+<p>The floating point divide instruction returns the quotient of its two
+arguments. Both arguments and the result must be of the same type. That type
+must be a floating point type, or a vector of a floating point type.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = fdiv T V1, V2;                            &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;2, V1, V2, 4&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The floating point divide instruction returns the quotient of its two
+arguments. Arguments <code>V1</code> and <code>V2</code>, and the result <code>%vN</code> must be of type
+<code>T</code>. <code>T</code> must be a floating point type, or a vector of a floating point
+type. <code>N</code> is defined by the record position, defining the corresponding value
+generated by the instruction.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+VV1 == RelativeIndex(V1) &amp;
+VV22 == RelativeIndex(V2) &amp;
+T == TypeOf(V1) == TypeOf(V2) &amp;
+IsFloat(UnderlyingType(T)) &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 92:0|  1: &lt;65535, 12, 2&gt;          |  function
+     |                             |      double
+     |                             |      &#64;f0(double %p0, double %p1) {
+     |                             |                   // BlockID = 12
+100:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+102:4|    3: &lt;2, 2, 1, 4&gt;          |    %v0 = fdiv double %p0, %p1;
+106:4|    3: &lt;2, 3, 1, 4&gt;          |    %v1 = fdiv double %p0, %v0;
+110:4|    3: &lt;10, 1&gt;               |    ret double %v1;
+113:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="floating-point-remainder">Floating Point Remainder</h3>
+<p>The floating point remainder instruction returns the remainder of the quotient
+of its two arguments. Both arguments and the result must be of the same
+type. That type must be a floating point type, or a vector of a floating point
+type.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = frem T V1, V2;                            &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;2, VV1, VV2, 6&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The floating point remainder instruction returns the remainder of the quotient
+of its two arguments. Arguments <code>V1</code> and <code>V2</code>, and the result <code>%vN</code> must
+be of type <code>T</code>. <code>T</code> must be a floating point type, or a vector of a floating
+point type. <code>N</code> is defined by the record position, defining the corresponding
+value generated by the instruction.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+VV1 == RelativeIndex(V1) &amp;
+VV2 == RelativeIndex(V2) &amp;
+T == TypeOf(V1) == TypeOf(V2)  &amp;
+IsFloat(UnderlyingType(T)) &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 92:0|  1: &lt;65535, 12, 2&gt;          |  function
+     |                             |      double
+     |                             |      &#64;f0(double %p0, double %p1) {
+     |                             |                   // BlockID = 12
+100:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+102:4|    3: &lt;2, 2, 1, 6&gt;          |    %v0 = frem double %p0, %p1;
+106:4|    3: &lt;2, 3, 1, 6&gt;          |    %v1 = frem double %p0, %v0;
+110:4|    3: &lt;10, 1&gt;               |    ret double %v1;
+113:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h2 id="memory-creation-and-access-instructions"><span id="link-for-memory-creation-and-access-instructions"></span>Memory Creation and Access Instructions</h2>
+<p>A key design point of SSA-based representation is how it represents
+memory. In PNaCl bitcode files, no memory locations are in SSA
+form. This makes things very simple.</p>
+<h3 id="alloca-instruction"><span id="link-for-alloca-instruction"></span>Alloca Instruction</h3>
+<p>The <em>alloca</em> instruction allocates memory on the stack frame of the
+currently executing function. This memory is automatically released
+when the function returns to its caller.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = alloca i8, i32 S, align V;                &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;19, SS, VV&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The <em>alloca</em> instruction allocates memory on the stack frame of the currently
+executing function.  The resulting value is a pointer to the allocated memory
+(i.e. of type i32). <code>S</code> is the number of bytes that are allocated on the
+stack. <code>S</code> must be of integer type i32. <code>V</code> is the alignment of the
+generated stack address.</p>
+<p>Alignment must be a power of 2. See <a class="reference internal" href="#link-for-memory-blocks-and-alignment-section"><em>memory blocks and
+alignment</em></a> for a more detailed
+discussion on how to define alignment.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+VV == Log2(V+1) &amp;
+SS == RelativeIndex(S) &amp;
+i32 == TypeOf(S) &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = i32;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+112:0|  1: &lt;65535, 12, 2&gt;          |  function void &#64;f1() {
+     |                             |                   // BlockID = 12
+120:0|    3: &lt;1, 1&gt;                |    blocks 1;
+122:4|    1: &lt;65535, 11, 2&gt;        |    constants {  // BlockID = 11
+132:0|      3: &lt;1, 0&gt;              |      i32:
+134:4|      3: &lt;4, 4&gt;              |        %c0 = i32 2;
+137:0|      3: &lt;4, 8&gt;              |        %c1 = i32 4;
+139:4|      3: &lt;4, 16&gt;             |        %c2 = i32 8;
+142:0|    0: &lt;65534&gt;               |      }
+     |                             |  %b0:
+144:0|    3: &lt;19, 3, 1&gt;            |    %v0 = alloca i8, i32 %c0, align 1;
+147:2|    3: &lt;19, 3, 3&gt;            |    %v1 = alloca i8, i32 %c1, align 4;
+150:4|    3: &lt;19, 3, 4&gt;            |    %v2 = alloca i8, i32 %c2, align 8;
+153:6|    3: &lt;10&gt;                  |    ret void;
+155:4|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="load-instruction">Load Instruction</h3>
+<p>The <em>load</em> instruction is used to read from memory.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = load T* P, align V;                       &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;20, PP, VV, TT&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The load instruction is used to read from memory. <code>P</code> is the identifier of the
+memory address to read. The type of <code>P</code> must be an <code>i32</code>.  <code>T</code> is the type
+of value to read. <code>V</code> is the alignment of the memory address.</p>
+<p>Type <code>T</code> must be a vector, integer, or floating point type. Both <code>float</code> and
+<code>double</code> types are allowed for floating point types. All integer types except
+i1 are allowed.</p>
+<p>Alignment must be a power of 2. See <a class="reference internal" href="#link-for-memory-blocks-and-alignment-section"><em>memory blocks and
+alignment</em></a> for a more detailed
+discussion on how to define alignment.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+i32 == TypeOf(P) &amp;
+PP == RelativeIndex(P) &amp;
+VV == Log2(V+1) &amp;
+%tTT == TypeID(T) &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+ 48:0|    3: &lt;1, 4&gt;                |    count 4;
+ 50:4|    3: &lt;7, 32&gt;               |    &#64;t0 = i32;
+ 53:6|    3: &lt;2&gt;                   |    &#64;t1 = void;
+ 55:4|    3: &lt;4&gt;                   |    &#64;t2 = double;
+ 57:2|    3: &lt;21, 0, 1, 0&gt;         |    &#64;t3 = void (i32);
+ 61:2|  0: &lt;65534&gt;                 |  }
+ ...
+ 96:0|  1: &lt;65535, 12, 2&gt;          |  function void &#64;f0(i32 %p0) {
+     |                             |                   // BlockID = 12
+104:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+106:4|    3: &lt;20, 1, 1, 0&gt;         |    %v0 = load i32* %p0, align 1;
+110:4|    3: &lt;20, 1, 4, 2&gt;         |    %v1 = load double* %v0, align 8;
+114:4|    3: &lt;10&gt;                  |    ret void;
+116:2|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="store-instruction">Store Instruction</h3>
+<p>The <em>store</em> instruction is used to write to memory.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+store T S, T* P, align V;                     &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;24, PP, SS, VV&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The store instruction is used to write to memory. <code>P</code> is the identifier of the
+memory address to write to.  The type of <code>P</code> must be an i32 integer.  <code>T</code> is
+the type of value to store. <code>S</code> is the value to store, and must be of type
+<code>T</code>.  <code>V</code> is the alignment of the memory address.  <code>A</code> is the (optional)
+abbreviation index associated with the record.</p>
+<p>Type <code>T</code> must be an integer or floating point type. Both <code>float</code> and
+<code>double</code> types are allowed for floating point types. All integer types except
+i1 are allowed.</p>
+<p>Alignment must be a power of 2. See <a class="reference internal" href="#link-for-memory-blocks-and-alignment-section"><em>memory blocks and
+alignment</em></a> for a more detailed
+discussion on how to define alignment.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+i32 == TypeOf(P) &amp;
+PP == RelativeIndex(P) &amp;
+VV == Log2(V+1)
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+ 48:0|    3: &lt;1, 4&gt;                |    count 4;
+ 50:4|    3: &lt;7, 32&gt;               |    &#64;t0 = i32;
+ 53:6|    3: &lt;2&gt;                   |    &#64;t1 = void;
+ 55:4|    3: &lt;4&gt;                   |    &#64;t2 = double;
+ 57:2|    3: &lt;21, 0, 1, 0, 0, 0, 2&gt;|    &#64;t3 = void (i32, i32, i32, double);
+ 63:4|  0: &lt;65534&gt;                 |  }
+ ...
+ 96:0|  1: &lt;65535, 12, 2&gt;          |  function
+     |                             |      void
+     |                             |      &#64;f0(i32 %p0, i32 %p1, i32 %p2,
+     |                             |          double %p3) {
+     |                             |                   // BlockID = 12
+104:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+106:4|    3: &lt;24, 4, 3, 1&gt;         |    store i32 %p1, i32* %p0, align 1;
+110:4|    3: &lt;24, 2, 1, 4&gt;         |    store double %p3, double* %p2,
+     |                             |        align 8;
+114:4|    3: &lt;10&gt;                  |    ret void;
+116:2|  0: &lt;65534&gt;                 |  }
+</pre>
+<h2 id="conversion-instructions"><span id="link-for-conversion-instructions"></span>Conversion Instructions</h2>
+<p>Conversion instructions all take a single operand and a type. The value is
+converted to the corresponding type.</p>
+<h3 id="integer-truncating-instruction">Integer Truncating Instruction</h3>
+<p>The integer truncating instruction takes a value to truncate, and a type
+defining the truncated type. Both types must be integer types, or integer
+vectors with the same number of elements. The bit size of the value must be
+larger than the bit size of the destination type. Equal sized types are not
+allowed.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = trunc T1 V to T2;                         &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;3, VV, TT2, 0&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The integer truncating instruction takes a value <code>V</code>, and truncates to type
+<code>T2</code>. Both <code>T1</code> and <code>T2</code> must be integer types, or integer vectors with
+the same number of elements. <code>T1</code> has to be wider than <code>T2</code>.  If the value
+doesn&#8217;t fit in in <code>T2</code>, then the higher order bits are dropped.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+TypeOf(V) == T1 &amp;
+VV == RelativeIndex(V) &amp;
+%tTT2 == TypeID(T2) &amp;
+BitSizeOf(UnderlyingType(T1)) &gt; BitSizeOf(UnderlyingType(T2)) &amp;
+UnderlyingCount(T1) == UnderlyingCount(T2) &amp;
+IsInteger(UnderlyingType(T1)) &amp;
+IsInteger(UnderlyingType(T2)) &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T2;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+ 48:0|    3: &lt;1, 5&gt;                |    count 5;
+ 50:4|    3: &lt;7, 32&gt;               |    &#64;t0 = i32;
+ 53:6|    3: &lt;2&gt;                   |    &#64;t1 = void;
+ 55:4|    3: &lt;7, 16&gt;               |    &#64;t2 = i16;
+ 58:0|    3: &lt;21, 0, 1, 0&gt;         |    &#64;t3 = void (i32);
+ 62:0|    3: &lt;7, 8&gt;                |    &#64;t4 = i8;
+ 64:4|  0: &lt;65534&gt;                 |  }
+ ...
+100:0|  1: &lt;65535, 12, 2&gt;          |  function void &#64;f0(i32 %p0) {
+     |                             |                   // BlockID = 12
+108:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+110:4|    3: &lt;3, 1, 2, 0&gt;          |    %v0 = trunc i32 %p0 to i16;
+114:4|    3: &lt;3, 1, 4, 0&gt;          |    %v1 = trunc i16 %v0 to i8;
+118:4|    3: &lt;10&gt;                  |    ret void;
+120:2|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="floating-point-truncating-instruction">Floating Point Truncating Instruction</h3>
+<p>The floating point truncating instruction takes a value to truncate, and a type
+defining the truncated type. Both types must be floating point types, or
+floating point vectors with the same number of elements. The source must be
+<code>double</code> while the destination is <code>float</code>.  If the source is a vector, the
+destination must also be vector with the same size as the source.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = fptrunc T1 V to T2;                       &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;3, VV, TT2, 7&gt;
+</pre>
+<p><strong>Semantics</strong></p>
+<p>The floating point truncating instruction takes a value <code>V</code>, and truncates to
+type <code>T2</code>. Both <code>T1</code> and <code>T2</code> must be floating point types, or floating
+point vectors with the same number of elements. <code>T1</code> must be defined on
+<code>double</code> while <code>T2</code> is defined on <code>float</code>.  If the value can&#8217;t fit within
+the destination type <code>T2</code>, the results are undefined.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+TypeOf(V) == T1 &amp;
+double == UnderlyingType(T1) &amp;
+float == UnderlyingType(T2) &amp;
+VV == RelativeIndex(V) &amp;
+%tTT2 == TypeID(T2) &amp;
+BitSizeOf(UnderlyingType(T1)) &gt; BitSizeOf(UnderlyingType(T2)) &amp;
+UnderlyingCount(T1) == UnderlyingCount(T2) &amp;
+IsFloat(UnderlyingType(T1)) &amp;
+IsFloat(UnderlyingType(T2)) &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T2;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+ 48:0|    3: &lt;1, 4&gt;                |    count 4;
+ 50:4|    3: &lt;3&gt;                   |    &#64;t0 = float;
+ 52:2|    3: &lt;4&gt;                   |    &#64;t1 = double;
+ 54:0|    3: &lt;21, 0, 0, 1&gt;         |    &#64;t2 = float (double);
+ 58:0|    3: &lt;2&gt;                   |    &#64;t3 = void;
+ 59:6|  0: &lt;65534&gt;                 |  }
+...
+ 92:0|  1: &lt;65535, 12, 2&gt;          |  function float &#64;f0(double %p0) {
+     |                             |                   // BlockID = 12
+100:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+102:4|    3: &lt;3, 1, 0, 7&gt;          |    %v0 = fptrunc double %p0 to float;
+106:4|    3: &lt;10, 1&gt;               |    ret float %v0;
+109:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="zero-extending-instruction">Zero Extending Instruction</h3>
+<p>The zero extending instruction takes a value to extend, and a type to extend it
+to. Both types must be integer types, or integer vectors with the same number
+of elements. The bit size of the source type must be smaller than the bit size
+of the destination type. Equal sized types are not allowed.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = zext T1 V to T2;                          &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;3, VV, TT2, 1&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The zero extending instruction takes a value <code>V</code>, and expands it to type
+<code>T2</code>. Both <code>T1</code> and <code>T2</code> must be integer types, or integer vectors with
+the same number of elements. <code>T2</code> must be wider than <code>T1</code>.</p>
+<p>The instruction fills the high order bits of the value with zero bits until it
+reaches the size of the destination type. When zero extending from i1, the
+result will always be either 0 or 1.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+TypeOf(V) == T1 &amp;
+VV == RelativeIndex(V) &amp;
+%tTT2 == TypeID(T2) &amp;
+BitSizeOf(UnderlyingType(T1)) &lt; BitSizeOf(UnderlyingType(T2)) &amp;
+UnderlyingCount(T1) == UnderlyingCount(T2) &amp;
+IsInteger(UnderlyingType(T1)) &amp;
+IsInteger(UnderlyingType(T2)) &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T2;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+ 48:0|    3: &lt;1, 5&gt;                |    count 5;
+ 50:4|    3: &lt;7, 64&gt;               |    &#64;t0 = i64;
+ 53:6|    3: &lt;7, 32&gt;               |    &#64;t1 = i32;
+ 57:0|    3: &lt;21, 0, 0&gt;            |    &#64;t2 = i64 ();
+ 60:2|    3: &lt;7, 8&gt;                |    &#64;t3 = i8;
+ 62:6|    3: &lt;2&gt;                   |    &#64;t4 = void;
+ 64:4|  0: &lt;65534&gt;                 |  }
+ ...
+100:0|  1: &lt;65535, 12, 2&gt;          |  function i64 &#64;f0() {  // BlockID = 12
+108:0|    3: &lt;1, 1&gt;                |    blocks 1;
+110:4|    1: &lt;65535, 11, 2&gt;        |    constants {  // BlockID = 11
+120:0|      3: &lt;1, 3&gt;              |      i8:
+122:4|      3: &lt;4, 2&gt;              |        %c0 = i8 1;
+125:0|    0: &lt;65534&gt;               |      }
+     |                             |  %b0:
+128:0|    3: &lt;3, 1, 1, 1&gt;          |    %v0 = zext i8 %c0 to i32;
+132:0|    3: &lt;3, 1, 0, 1&gt;          |    %v1 = zext i32 %v0 to i64;
+136:0|    3: &lt;10, 1&gt;               |    ret i64 %v1;
+138:4|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="sign-extending-instruction">Sign Extending Instruction</h3>
+<p>The sign extending instruction takes a value to cast, and a type to extend it
+to. Both types must be integer types, or integral vectors with the same number
+of elements. The bit size of the source type must be smaller than the bit size
+of the destination type. Equal sized types are not allowed.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = sext T1 V to T2;                          &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;3, VV, TT2, 2&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The sign extending instruction takes a value <code>V</code>, and expands it to type
+<code>T2</code>. Both <code>T1</code> and <code>T2</code> must be integer types, or integer vectors with
+the same number of integers.  <code>T2</code> has to be wider than <code>T1</code>.</p>
+<p>When sign extending, the instruction fills the high order bits of the value with
+the (current) high order bit of the value. When sign extending from i1, the
+extension always results in -1 or 0.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+TypeOf(V) == T1 &amp;
+VV == RelativeIndex(V) &amp;
+%tTT2 == TypeID(T2) &amp;
+BitSizeOf(UnderlyingType(T1)) &lt; BitSizeOf(UnderlyingType(T2)) &amp;
+UnderlyingCount(T1) == UnderlyingCount(T2) &amp;
+IsInteger(UnderlyingType(T1)) &amp;
+IsInteger(UnderlyingType(T2)) &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T2;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+ 48:0|    3: &lt;1, 5&gt;                |    count 5;
+ 50:4|    3: &lt;7, 64&gt;               |    &#64;t0 = i64;
+ 53:6|    3: &lt;7, 32&gt;               |    &#64;t1 = i32;
+ 57:0|    3: &lt;21, 0, 0&gt;            |    &#64;t2 = i64 ();
+ 60:2|    3: &lt;7, 8&gt;                |    &#64;t3 = i8;
+ 62:6|    3: &lt;2&gt;                   |    &#64;t4 = void;
+ 64:4|  0: &lt;65534&gt;                 |  }
+ ...
+100:0|  1: &lt;65535, 12, 2&gt;          |  function i64 &#64;f0() {  // BlockID = 12
+108:0|    3: &lt;1, 1&gt;                |    blocks 1;
+110:4|    1: &lt;65535, 11, 2&gt;        |    constants {  // BlockID = 11
+120:0|      3: &lt;1, 3&gt;              |      i8:
+122:4|      3: &lt;4, 3&gt;              |        %c0 = i8 -1;
+125:0|    0: &lt;65534&gt;               |      }
+     |                             |  %b0:
+128:0|    3: &lt;3, 1, 1, 2&gt;          |    %v0 = sext i8 %c0 to i32;
+132:0|    3: &lt;3, 1, 0, 2&gt;          |    %v1 = sext i32 %v0 to i64;
+136:0|    3: &lt;10, 1&gt;               |    ret i64 %v1;
+138:4|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="floating-point-extending-instruction">Floating Point Extending Instruction</h3>
+<p>The floating point extending instruction takes a value to extend, and a type to
+extend it to. Both types must either be floating point types, or vectors of
+floating point types with the same number of elements. The source value must be
+<code>float</code> while the destination is <code>double</code>.  If the source is a vector, the
+destination must also be vector with the same size as the source.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = fpext T1 V to T2;                           &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;3, VV, TT2, 8&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The floating point extending instruction converts floating point values.
+<code>V</code> is the value to extend, and <code>T2</code> is the type to extend it
+to. Both <code>T1</code> and <code>T2</code> must be floating point types, or floating point
+vector types with the same number of floating point values. <code>T1</code> contains
+<code>float</code> while <code>T2</code> contains <code>double</code>.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+TypeOf(V) == T1 &amp;
+VV == RelativeIndex(V) &amp;
+%tTT2 == TypeID(T2) &amp;
+BitSizeOf(UnderlyingType(T1)) &lt; BitSizeOf(UnderlyingType(T2)) &amp;
+UnderlyingCount(T1) == UnderlyingCount(T2) &amp;
+IsFloat(UnderlyingType(T1)) &amp;
+IsFloat(UnderlyingType(T2)) &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T2;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+ 48:0|    3: &lt;1, 4&gt;                |    count 4;
+ 50:4|    3: &lt;4&gt;                   |    &#64;t0 = double;
+ 52:2|    3: &lt;3&gt;                   |    &#64;t1 = float;
+ 54:0|    3: &lt;21, 0, 0, 1&gt;         |    &#64;t2 = double (float);
+ 58:0|    3: &lt;2&gt;                   |    &#64;t3 = void;
+ 59:6|  0: &lt;65534&gt;                 |  }
+ ...
+ 92:0|  1: &lt;65535, 12, 2&gt;          |  function double &#64;f0(float %p0) {
+     |                             |                   // BlockID = 12
+100:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+102:4|    3: &lt;3, 1, 0, 8&gt;          |    %v0 = fpext float %p0 to double;
+106:4|    3: &lt;10, 1&gt;               |    ret double %v0;
+109:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="floating-point-to-unsigned-integer-instruction">Floating Point to Unsigned Integer Instruction</h3>
+<p>The floating point to unsigned integer instruction converts floating point
+values to unsigned integers.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = fptoui T1 V to T2;                        &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;3, VV, TT2, 3&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The floating point to unsigned integer instruction converts floating point
+value(s) in <code>V</code> to its unsigned integer equivalent of type <code>T2</code>. <code>T1</code> must
+be a floating point type, or a floating point vector type. <code>T2</code> must be an
+integer type, or an integer vector type. If either type is a vector type, they
+both must have the same number of elements.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+TypeOf(V) == T1 &amp;
+VV == RelativeIndex(V) &amp;
+%tTT2 == TypeID(T2) &amp;
+UnderlyingCount(T1) == UnderlyingCount(T2) &amp;
+IsFloat(UnderlyingType(T1)) &amp;
+IsInteger(UnderlyingType(T2)) &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T2;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+ 48:0|    3: &lt;1, 6&gt;                |    count 6;
+ 50:4|    3: &lt;3&gt;                   |    &#64;t0 = float;
+ 52:2|    3: &lt;4&gt;                   |    &#64;t1 = double;
+ 54:0|    3: &lt;2&gt;                   |    &#64;t2 = void;
+ 55:6|    3: &lt;21, 0, 2, 0, 1&gt;      |    &#64;t3 = void (float, double);
+ 60:4|    3: &lt;7, 32&gt;               |    &#64;t4 = i32;
+ 63:6|    3: &lt;7, 16&gt;               |    &#64;t5 = i16;
+ 66:2|  0: &lt;65534&gt;                 |  }
+ ...
+100:0|  1: &lt;65535, 12, 2&gt;          |  function
+     |                             |      void &#64;f0(float %p0, double %p1) {
+     |                             |                    // BlockID = 12
+108:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+110:4|    3: &lt;3, 2, 4, 3&gt;          |    %v0 = fptoui float %p0 to i32;
+114:4|    3: &lt;3, 2, 5, 3&gt;          |    %v1 = fptoui double %p1 to i16;
+118:4|    3: &lt;10&gt;                  |    ret void;
+120:2|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="floating-point-to-signed-integer-instruction">Floating Point to Signed Integer Instruction</h3>
+<p>The floating point to signed integer instruction converts floating point
+values to signed integers.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = fptosi T1 V to T2;                        &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;3, VV, TT2, 4&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The floating point to signed integer instruction converts floating point
+value(s) in <code>V</code> to its signed integer equivalent of type <code>T2</code>. <code>T1</code> must
+be a floating point type, or a floating point vector type. <code>T2</code> must be an
+integer type, or an integer vector type. If either type is a vector type, they
+both must have the same number of elements.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+TypeOf(V) == T1 &amp;
+VV == RelativeIndex(V) &amp;
+%tTT2 = TypeID(T2) &amp;
+UnderlyingCount(T1) = UnderlyingCount(T2) &amp;
+IsFloat(UnderlyingType(T1)) &amp;
+IsInteger(UnderlyingType(T2)) &amp;
+N = NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T2;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+ 48:0|    3: &lt;1, 6&gt;                |    count 6;
+ 50:4|    3: &lt;3&gt;                   |    &#64;t0 = float;
+ 52:2|    3: &lt;4&gt;                   |    &#64;t1 = double;
+ 54:0|    3: &lt;2&gt;                   |    &#64;t2 = void;
+ 55:6|    3: &lt;21, 0, 2, 0, 1&gt;      |    &#64;t3 = void (float, double);
+ 60:4|    3: &lt;7, 8&gt;                |    &#64;t4 = i8;
+ 63:0|    3: &lt;7, 16&gt;               |    &#64;t5 = i16;
+ 65:4|  0: &lt;65534&gt;                 |  }
+ ...
+100:0|  1: &lt;65535, 12, 2&gt;          |  function
+     |                             |      void &#64;f0(float %p0, double %p1) {
+     |                             |                    // BlockID = 12
+108:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+110:4|    3: &lt;3, 2, 4, 4&gt;          |    %v0 = fptosi float %p0 to i8;
+114:4|    3: &lt;3, 2, 5, 4&gt;          |    %v1 = fptosi double %p1 to i16;
+118:4|    3: &lt;10&gt;                  |    ret void;
+120:2|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="unsigned-integer-to-floating-point-instruction">Unsigned Integer to Floating Point Instruction</h3>
+<p>The unsigned integer to floating point instruction converts unsigned integers to
+floating point values.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = uitofp T1 V to T2;                        &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;3, VV, TT2, 5&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The unsigned integer to floating point instruction converts unsigned integer(s)
+to its floating point equivalent of type <code>T2</code>. <code>T1</code> must be an integer type,
+or a integer vector type. <code>T2</code> must be a floating point type, or a floating
+point vector type. If either type is a vector type, they both must have the same
+number of elements.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+TypeOf(V) == T1 &amp;
+VV == RelativeIndex(V) &amp;
+%tTT2 = TypeID(T2) &amp;
+UnderlyingCount(T1) == UnderlyingCount(T2) &amp;
+IsInteger(UnderlyingType(T1)) &amp;
+IsFloat(UnderlyingType(T2)) &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) == T2;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+ 48:0|    3: &lt;1, 7&gt;                |    count 7;
+ 50:4|    3: &lt;7, 32&gt;               |    &#64;t0 = i32;
+ 53:6|    3: &lt;7, 64&gt;               |    &#64;t1 = i64;
+ 57:0|    3: &lt;2&gt;                   |    &#64;t2 = void;
+ 58:6|    3: &lt;3&gt;                   |    &#64;t3 = float;
+ 60:4|    3: &lt;21, 0, 2, 0, 1&gt;      |    &#64;t4 = void (i32, i64);
+ 65:2|    3: &lt;7, 1&gt;                |    &#64;t5 = i1;
+ 67:6|    3: &lt;4&gt;                   |    &#64;t6 = double;
+ 69:4|  0: &lt;65534&gt;                 |  }
+...
+104:0|  1: &lt;65535, 12, 2&gt;          |  function void &#64;f0(i32 %p0, i64 %p1) {
+     |                             |                    // BlockID = 12
+112:0|    3: &lt;1, 1&gt;                |    blocks 1;
+114:4|    1: &lt;65535, 11, 2&gt;        |    constants {  // BlockID = 11
+124:0|      3: &lt;1, 5&gt;              |      i1:
+126:4|      3: &lt;4, 3&gt;              |        %c0 = i1 1;
+129:0|    0: &lt;65534&gt;               |      }
+     |                             |  %b0:
+132:0|    3: &lt;3, 1, 6, 5&gt;          |    %v0 = uitofp i1 %c0 to double;
+136:0|    3: &lt;3, 4, 3, 5&gt;          |    %v1 = uitofp i32 %p0 to float;
+140:0|    3: &lt;3, 4, 3, 5&gt;          |    %v2 = uitofp i64 %p1 to float;
+144:0|    3: &lt;10&gt;                  |    ret void;
+145:6|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="signed-integer-to-floating-point-instruction">Signed Integer to Floating Point Instruction</h3>
+<p>The signed integer to floating point instruction converts signed integers to
+floating point values.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = sitofp T1 V to T2;                        &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;3, VV, TT2, 6&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The signed integer to floating point instruction converts signed integer(s) to
+its floating point equivalent of type <code>T2</code>. <code>T1</code> must be an integer type, or
+a integer vector type. <code>T2</code> must be a floating point type, or a floating point
+vector type. If either type is a vector type, they both must have the same
+number of elements.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+TypeOf(V) == T1 &amp;
+VV == RelativeIndex(V) &amp;
+%tTT2 = TypeID(T2) &amp;
+UnderlyingCount(T1) == UnderlyingCount(T2) &amp;
+IsInteger(UnderlyingType(T1)) &amp;
+IsFloat(UnderlyingType(T2)) &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T2;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+ 48:0|    3: &lt;1, 7&gt;                |    count 7;
+ 50:4|    3: &lt;7, 32&gt;               |    &#64;t0 = i32;
+ 53:6|    3: &lt;7, 64&gt;               |    &#64;t1 = i64;
+ 57:0|    3: &lt;2&gt;                   |    &#64;t2 = void;
+ 58:6|    3: &lt;3&gt;                   |    &#64;t3 = float;
+ 60:4|    3: &lt;21, 0, 2, 0, 1&gt;      |    &#64;t4 = void (i32, i64);
+ 65:2|    3: &lt;7, 8&gt;                |    &#64;t5 = i8;
+ 67:6|    3: &lt;4&gt;                   |    &#64;t6 = double;
+ 69:4|  0: &lt;65534&gt;                 |  }
+ ...
+104:0|  1: &lt;65535, 12, 2&gt;          |  function void &#64;f0(i32 %p0, i64 %p1) {
+     |                             |                    // BlockID = 12
+112:0|    3: &lt;1, 1&gt;                |    blocks 1;
+114:4|    1: &lt;65535, 11, 2&gt;        |    constants {  // BlockID = 11
+124:0|      3: &lt;1, 5&gt;              |      i8:
+126:4|      3: &lt;4, 3&gt;              |        %c0 = i8 -1;
+129:0|    0: &lt;65534&gt;               |      }
+     |                             |  %b0:
+132:0|    3: &lt;3, 1, 6, 6&gt;          |    %v0 = sitofp i8 %c0 to double;
+136:0|    3: &lt;3, 4, 3, 6&gt;          |    %v1 = sitofp i32 %p0 to float;
+140:0|    3: &lt;3, 4, 3, 6&gt;          |    %v2 = sitofp i64 %p1 to float;
+144:0|    3: &lt;10&gt;                  |    ret void;
+145:6|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="bitcast-instruction">Bitcast Instruction</h3>
+<p>The bitcast instruction converts the type of the value without changing the bit
+contents of the value. The bit size of the type of the value must be the same as
+the bit size of the cast type.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = bitcast T1 V to T2;                       &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;3, VV, TT2, 11&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The bitcast instruction converts the type of value <code>V</code> to type <code>T2</code>. <code>T1</code>
+and <code>T2</code> must be primitive types or vectors, and define the same number of
+bits.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+TypeOf(V) == T1 &amp;
+VV = RelativeIndex(V) &amp;
+%tTT2 = TypeID(T2) &amp;
+BitSizeOf(T1) == BitSizeOf(T2) &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T2;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+ 48:0|    3: &lt;1, 6&gt;                |    count 6;
+ 50:4|    3: &lt;3&gt;                   |    &#64;t0 = float;
+ 52:2|    3: &lt;7, 64&gt;               |    &#64;t1 = i64;
+ 55:4|    3: &lt;2&gt;                   |    &#64;t2 = void;
+ 57:2|    3: &lt;21, 0, 2, 0, 1&gt;      |    &#64;t3 = void (float, i64);
+ 62:0|    3: &lt;7, 32&gt;               |    &#64;t4 = i32;
+ 65:2|    3: &lt;4&gt;                   |    &#64;t5 = double;
+ 67:0|  0: &lt;65534&gt;                 |  }
+ ...
+100:0|  1: &lt;65535, 12, 2&gt;          |  function void &#64;f0(float %p0, i64 %p1)
+     |                             |      {  // BlockID = 12
+108:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+110:4|    3: &lt;3, 2, 4, 11&gt;         |    %v0 = bitcast float %p0 to i32;
+114:4|    3: &lt;3, 2, 5, 11&gt;         |    %v1 = bitcast i64 %p1 to double;
+118:4|    3: &lt;10&gt;                  |    ret void;
+120:2|  0: &lt;65534&gt;                 |  }
+</pre>
+<h2 id="comparison-instructions"><span id="link-for-compare-instructions"></span>Comparison Instructions</h2>
+<p>The comparison instructions compare values and generates a boolean (i1) result
+for each pair of compared values. There are different comparison operations for
+integer and floating point values.</p>
+<h3 id="integer-comparison-instructions">Integer Comparison Instructions</h3>
+<p>The integer comparison instruction compares integer values and returns a
+boolean (i1) result for each pair of compared values.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = icmp C T V1, V2;                          &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;9, VV1, VV2, CC&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The integer comparison instruction compares integer values and returns a boolean
+(i1) result for each pair of compared values in <code>V1</code> and <code>V2</code>. <code>V1</code> and
+<code>V2</code> must be of type <code>T</code>. <code>T</code> must be an integer type, or an integer
+vector type. Condition code <code>C</code> is the condition applied to all elements in
+<code>V1</code> and <code>V2</code>.  Each comparison always yields an i1. If <code>T</code> is a primitive
+type, the resulting type is i1. If <code>T</code> is a vector, then the resulting type is
+a vector of i1 with the same size as <code>T</code>.</p>
+<p>Legal test conditions are:</p>
+<table border="1" class="docutils">
+<colgroup>
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">C</th>
+<th class="head">CC</th>
+<th class="head">Operator</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>eq</td>
+<td>32</td>
+<td>equal</td>
+</tr>
+<tr class="row-odd"><td>ne</td>
+<td>33</td>
+<td>not equal</td>
+</tr>
+<tr class="row-even"><td>ugt</td>
+<td>34</td>
+<td>unsigned greater than</td>
+</tr>
+<tr class="row-odd"><td>uge</td>
+<td>35</td>
+<td>unsigned greater than or equal</td>
+</tr>
+<tr class="row-even"><td>ult</td>
+<td>36</td>
+<td>unsigned less than</td>
+</tr>
+<tr class="row-odd"><td>ule</td>
+<td>37</td>
+<td>unsigned less than or equal</td>
+</tr>
+<tr class="row-even"><td>sgt</td>
+<td>38</td>
+<td>signed greater than</td>
+</tr>
+<tr class="row-odd"><td>sge</td>
+<td>39</td>
+<td>signed greater than or equal</td>
+</tr>
+<tr class="row-even"><td>slt</td>
+<td>40</td>
+<td>signed less than</td>
+</tr>
+<tr class="row-odd"><td>sle</td>
+<td>41</td>
+<td>signed less than or equal</td>
+</tr>
+</tbody>
+</table>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+IsInteger(UnderlyingType(T) &amp;
+T == TypeOf(V1) == TypeOf(V2) &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+if IsVector(T) then
+  TypeOf(%vN) = &lt;UnderlyingCount(T), i1&gt;
+else
+  TypeOf(%vN) = i1
+endif
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+ 48:0|    3: &lt;1, 4&gt;                |    count 4;
+ 50:4|    3: &lt;7, 32&gt;               |    &#64;t0 = i32;
+ 53:6|    3: &lt;7, 1&gt;                |    &#64;t1 = i1;
+ 56:2|    3: &lt;2&gt;                   |    &#64;t2 = void;
+ 58:0|    3: &lt;21, 0, 2&gt;            |    &#64;t3 = void ();
+ 61:2|  0: &lt;65534&gt;                 |  }
+ ...
+108:0|  1: &lt;65535, 12, 2&gt;          |  function void &#64;f0() {
+     |                             |                   // BlockID = 12
+116:0|    3: &lt;1, 1&gt;                |    blocks 1;
+118:4|    1: &lt;65535, 11, 2&gt;        |    constants {  // BlockID = 11
+128:0|      3: &lt;1, 0&gt;              |      i32:
+130:4|      3: &lt;4, 0&gt;              |        %c0 = i32 0;
+133:0|      3: &lt;4, 2&gt;              |        %c1 = i32 1;
+135:4|    0: &lt;65534&gt;               |      }
+     |                             |  %b0:
+136:0|    3: &lt;28, 2, 1, 32&gt;        |    %v0 = icmp eq i32 %c0, %c1;
+140:6|    3: &lt;28, 3, 2, 33&gt;        |    %v1 = icmp ne i32 %c0, %c1;
+145:4|    3: &lt;28, 4, 3, 34&gt;        |    %v2 = icmp ugt i32 %c0, %c1;
+150:2|    3: &lt;28, 5, 4, 36&gt;        |    %v3 = icmp ult i32 %c0, %c1;
+155:0|    3: &lt;28, 6, 5, 37&gt;        |    %v4 = icmp ule i32 %c0, %c1;
+159:6|    3: &lt;28, 7, 6, 38&gt;        |    %v5 = icmp sgt i32 %c0, %c1;
+164:4|    3: &lt;28, 8, 7, 38&gt;        |    %v6 = icmp sgt i32 %c0, %c1;
+169:2|    3: &lt;28, 9, 8, 39&gt;        |    %v7 = icmp sge i32 %c0, %c1;
+174:0|    3: &lt;28, 10, 9, 40&gt;       |    %v8 = icmp slt i32 %c0, %c1;
+178:6|    3: &lt;28, 11, 10, 41&gt;      |    %v9 = icmp sle i32 %c0, %c1;
+183:4|    3: &lt;10&gt;                  |    ret void;
+185:2|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="floating-point-comparison-instructions">Floating Point Comparison Instructions</h3>
+<p>The floating point comparison instruction compares floating point values and
+returns a boolean (i1) result for each pair of compared values.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = fcmp C T V1, V2;                          &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;9, VV1, VV2, CC&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The floating point comparison instruction compares floating point values and
+returns a boolean (i1) result for each pair of compared values in <code>V1</code> and
+<code>V2</code>. <code>V1</code> and <code>V2</code> must be of type <code>T</code>. <code>T</code> must be a floating point
+type, or a floating point vector type. Condition code <code>C</code> is the condition
+applied to all elements in <code>V1</code> and <code>V2</code>. Each comparison always yields an
+i1. If <code>T</code> is a primitive type, the resulting type is i1. If <code>T</code> is a
+vector, then the resulting type is a vector of i1 with the same size as <code>T</code>.</p>
+<p>Legal test conditions are:</p>
+<table border="1" class="docutils">
+<colgroup>
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">C</th>
+<th class="head">CC</th>
+<th class="head">Operator</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>false</td>
+<td>0</td>
+<td>Always false</td>
+</tr>
+<tr class="row-odd"><td>oeq</td>
+<td>1</td>
+<td>Ordered and equal</td>
+</tr>
+<tr class="row-even"><td>ogt</td>
+<td>2</td>
+<td>Ordered and greater than</td>
+</tr>
+<tr class="row-odd"><td>oge</td>
+<td>3</td>
+<td>Ordered and greater than or equal</td>
+</tr>
+<tr class="row-even"><td>olt</td>
+<td>4</td>
+<td>Ordered and less than</td>
+</tr>
+<tr class="row-odd"><td>ole</td>
+<td>5</td>
+<td>Ordered and less than or equal</td>
+</tr>
+<tr class="row-even"><td>one</td>
+<td>6</td>
+<td>Ordered and not equal</td>
+</tr>
+<tr class="row-odd"><td>ord</td>
+<td>7</td>
+<td>Ordered (no NaNs)</td>
+</tr>
+<tr class="row-even"><td>uno</td>
+<td>8</td>
+<td>Unordered (either NaNs)</td>
+</tr>
+<tr class="row-odd"><td>ueq</td>
+<td>9</td>
+<td>Unordered or equal</td>
+</tr>
+<tr class="row-even"><td>ugt</td>
+<td>10</td>
+<td>Unordered or greater than</td>
+</tr>
+<tr class="row-odd"><td>uge</td>
+<td>11</td>
+<td>Unordered or greater than or equal</td>
+</tr>
+<tr class="row-even"><td>ult</td>
+<td>12</td>
+<td>Unordered or less than</td>
+</tr>
+<tr class="row-odd"><td>ule</td>
+<td>13</td>
+<td>Unordered or less than or equal</td>
+</tr>
+<tr class="row-even"><td>une</td>
+<td>14</td>
+<td>Unordered or not equal</td>
+</tr>
+<tr class="row-odd"><td>true</td>
+<td>15</td>
+<td>Always true</td>
+</tr>
+</tbody>
+</table>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+IsFloat(UnderlyingType(T) &amp;
+T == TypeOf(V1) == TypeOf(V2) &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+if IsVector(T) then
+  TypeOf(%vN) = &lt;UnderlyingCount(T), i1&gt;
+else
+  TypeOf(%vN) = i1
+endif
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+ 48:0|    3: &lt;1, 4&gt;                |    count 4;
+ 50:4|    3: &lt;3&gt;                   |    &#64;t0 = float;
+ 52:2|    3: &lt;7, 1&gt;                |    &#64;t1 = i1;
+ 54:6|    3: &lt;2&gt;                   |    &#64;t2 = void;
+ 56:4|    3: &lt;21, 0, 2&gt;            |    &#64;t3 = void ();
+ 59:6|  0: &lt;65534&gt;                 |  }
+ ...
+108:0|  1: &lt;65535, 12, 2&gt;          |  function void &#64;f0() {
+     |                             |                   // BlockID = 12
+116:0|    3: &lt;1, 1&gt;                |    blocks 1;
+118:4|    1: &lt;65535, 11, 2&gt;        |    constants {  // BlockID = 11
+128:0|      3: &lt;1, 0&gt;              |      float:
+130:4|      3: &lt;6, 0&gt;              |        %c0 = float 0;
+133:0|      3: &lt;6, 1065353216&gt;     |        %c1 = float 1;
+139:2|    0: &lt;65534&gt;               |      }
+     |                             |  %b0:
+140:0|    3: &lt;28, 2, 1, 0&gt;         |    %v0 = fcmp false float %c0, %c1;
+144:0|    3: &lt;28, 3, 2, 1&gt;         |    %v1 = fcmp oeq float %c0, %c1;
+148:0|    3: &lt;28, 4, 3, 2&gt;         |    %v2 = fcmp ogt float %c0, %c1;
+152:0|    3: &lt;28, 5, 4, 3&gt;         |    %v3 = fcmp oge float %c0, %c1;
+156:0|    3: &lt;28, 6, 5, 4&gt;         |    %v4 = fcmp olt float %c0, %c1;
+160:0|    3: &lt;28, 7, 6, 5&gt;         |    %v5 = fcmp ole float %c0, %c1;
+164:0|    3: &lt;28, 8, 7, 6&gt;         |    %v6 = fcmp one float %c0, %c1;
+168:0|    3: &lt;28, 9, 8, 7&gt;         |    %v7 = fcmp ord float %c0, %c1;
+172:0|    3: &lt;28, 10, 9, 9&gt;        |    %v8 = fcmp ueq float %c0, %c1;
+176:0|    3: &lt;28, 11, 10, 10&gt;      |    %v9 = fcmp ugt float %c0, %c1;
+180:0|    3: &lt;28, 12, 11, 11&gt;      |    %v10 = fcmp uge float %c0, %c1;
+184:0|    3: &lt;28, 13, 12, 12&gt;      |    %v11 = fcmp ult float %c0, %c1;
+188:0|    3: &lt;28, 14, 13, 13&gt;      |    %v12 = fcmp ule float %c0, %c1;
+192:0|    3: &lt;28, 15, 14, 14&gt;      |    %v13 = fcmp une float %c0, %c1;
+196:0|    3: &lt;28, 16, 15, 8&gt;       |    %v14 = fcmp uno float %c0, %c1;
+200:0|    3: &lt;28, 17, 16, 15&gt;      |    %v15 = fcmp true float %c0, %c1;
+204:0|    3: &lt;10&gt;                  |    ret void;
+205:6|  0: &lt;65534&gt;                 |  }
+208:0|0: &lt;65534&gt;                   |}
+</pre>
+<h2 id="vector-instructions"><span id="link-for-vector-instructions"></span>Vector Instructions</h2>
+<p>PNaClAsm supports several instructions that process vectors. This includes the
+<a class="reference internal" href="#link-for-integer-binary-instructions"><em>integer</em></a> and <a class="reference internal" href="#link-for-floating-point-binary-instructions"><em>floating
+point</em></a> binary instructions as well
+as <a class="reference internal" href="#link-for-compare-instructions"><em>compare</em></a> instructions. These
+instructions work with vectors and generate resulting (new) vectors. This
+section introduces the instructions to construct vectors and extract results.</p>
+<h3 id="insert-element-instruction"><span id="link-for-insert-element-instruction-section"></span>Insert Element Instruction</h3>
+<p>The <em>insert element</em> instruction inserts a scalar value into a vector at a
+specified index. The <em>insert element</em> instruction takes an existing vector and
+puts a scalar value in one of the elements of the vector.</p>
+<p>The <em>insert element</em> instruction can be used to construct a vector, one element
+at a time.  At first glance, it may appear that one can&#8217;t construct a vector,
+since the <em>insert element</em> instruction needs a vector to insert elements into.</p>
+<p>The key to understanding vector construction is understand that one can create
+an <a class="reference internal" href="#link-for-undefined-literal"><em>undefined</em></a> vector literal. Using that
+constant as a starting point, one can built up the wanted vector by a sequence
+of <em>insert element</em> instructions.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = insertelement TV V, TE E, i32 I;          &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;7, VV, EE, II&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The <em>insert element</em> instruction inserts scalar value <code>E</code> into index <code>I</code> of
+vector <code>V</code>. <code>%vN</code> holds the updated vector. Type <code>TV</code> is the type of
+vector.  It is also the type of updated vector <code>%vN</code>.  Type <code>TE</code> is the type
+of scalar value <code>E</code> and must be the element type of vector <code>V</code>. <code>I</code> must
+be an <a class="reference internal" href="#link-for-integer-literal"><em>i32 literal</em></a>.</p>
+<p>If <code>I</code> exceeds the length of <code>V</code>, the result is undefined.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+IsVector(TV) &amp;
+TypeOf(V) == TV &amp;
+UnderlyingType(TV) == TE &amp;
+TypeOf(I) == i32 &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = TV;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+ 48:0|    3: &lt;1, 5&gt;                |    count 5;
+ 50:4|    3: &lt;7, 1&gt;                |    &#64;t0 = i1;
+ 53:0|    3: &lt;12, 4, 0&gt;            |    &#64;t1 = &lt;4 x i1&gt;;
+ 56:2|    3: &lt;7, 32&gt;               |    &#64;t2 = i32;
+ 59:4|    3: &lt;2&gt;                   |    &#64;t3 = void;
+ 61:2|    3: &lt;21, 0, 3&gt;            |    &#64;t4 = void ();
+ 64:4|  0: &lt;65534&gt;                 |  }
+ ...
+116:0|  1: &lt;65535, 12, 2&gt;          |  function void &#64;f0() {
+     |                             |                   // BlockID = 12
+124:0|    3: &lt;1, 1&gt;                |    blocks 1;
+126:4|    1: &lt;65535, 11, 2&gt;        |    constants {  // BlockID = 11
+136:0|      3: &lt;1, 0&gt;              |      i1:
+138:4|      3: &lt;4, 0&gt;              |        %c0 = i1 0;
+141:0|      3: &lt;4, 3&gt;              |        %c1 = i1 1;
+143:4|      3: &lt;1, 1&gt;              |      &lt;4 x i1&gt;:
+146:0|      3: &lt;3&gt;                 |        %c2 = &lt;4 x i1&gt; undef;
+147:6|      3: &lt;1, 2&gt;              |      i32:
+150:2|      3: &lt;4, 0&gt;              |        %c3 = i32 0;
+152:6|      3: &lt;4, 2&gt;              |        %c4 = i32 1;
+155:2|      3: &lt;4, 4&gt;              |        %c5 = i32 2;
+157:6|      3: &lt;4, 6&gt;              |        %c6 = i32 3;
+160:2|    0: &lt;65534&gt;               |      }
+     |                             |  %b0:
+164:0|    3: &lt;7, 5, 7, 4&gt;          |    %v0  =  insertelement &lt;4 x i1&gt; %c2,
+     |                             |        i1 %c0, i32 %c3;
+168:0|    3: &lt;7, 1, 7, 4&gt;          |    %v1  =  insertelement &lt;4 x i1&gt; %v0,
+     |                             |        i1 %c1, i32 %c4;
+172:0|    3: &lt;7, 1, 9, 4&gt;          |    %v2  =  insertelement &lt;4 x i1&gt; %v1,
+     |                             |        i1 %c0, i32 %c5;
+176:0|    3: &lt;7, 1, 9, 4&gt;          |    %v3  =  insertelement &lt;4 x i1&gt; %v2,
+     |                             |        i1 %c1, i32 %c6;
+180:0|    3: &lt;10&gt;                  |    ret void;
+181:6|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="extract-element-instruction">Extract Element Instruction</h3>
+<p>The <em>extract element</em> instruction extracts a single scalar value from a vector
+at a specified index.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = extractelement TV V, i32 I;                &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;6, VV, II&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The <em>extract element</em> instruction extracts the scalar value at index <code>I</code> from
+vector <code>V</code>. The extracted value is assigned to <code>%vN</code>. Type <code>TV</code> is the
+type of vector <code>V</code>. <code>I</code> must be an <a class="reference internal" href="#link-for-integer-literal"><em>i32
+literal</em></a>. The type of <code>vN</code> must be the element type
+of vector <code>V</code>.</p>
+<p>If <code>I</code> exceeds the length of <code>V</code>, the result is undefined.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+IsVector(TV) &amp;
+TypeOf(V) == TV &amp;
+TypeOf(I) == i32 &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = UnderlyingType(TV);
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 96:0|  1: &lt;65535, 12, 2&gt;          |  function void &#64;f0(&lt;4 x i32&gt; %p0) {
+     |                             |                   // BlockID = 12
+104:0|    3: &lt;1, 1&gt;                |    blocks 1;
+106:4|    1: &lt;65535, 11, 2&gt;        |    constants {  // BlockID = 11
+116:0|      3: &lt;1, 0&gt;              |      i32:
+118:4|      3: &lt;4, 0&gt;              |        %c0 = i32 0;
+121:0|    0: &lt;65534&gt;               |      }
+     |                             |  %b0:
+124:0|    3: &lt;6, 2, 1&gt;             |    %v0  =
+     |                             |        extractelement &lt;4 x i32&gt; %p0,
+     |                             |        i32 %c0;
+127:2|    3: &lt;10&gt;                  |    ret void;
+129:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h2 id="other-instructions"><span id="link-for-other-pnaclasm-instructions"></span>Other Instructions</h2>
+<p>This section defines miscellaneous instructions which defy better
+classification.</p>
+<h3 id="forward-type-declaration"><span id="link-for-forward-type-declaration-section"></span>Forward Type Declaration</h3>
+<p>The forward type declaration exists to deal with the fact that all instruction
+values must have a type associated with them before they are used. For some
+simple functions one can easily topologically sort instructions so that
+instruction values are defined before they are used. However, if the
+implementation contains loops, the loop induced values can&#8217;t be defined before
+they are used.</p>
+<p>The solution is to forward declare the type of an instruction value. One could
+forward declare the types of all instructions at the beginning of the function
+block.  However, this would make the corresponding file size considerably
+larger. Rather, one should only generate these forward type declarations
+sparingly and only when needed.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+declare T %vN;                                  &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;43, N, TT&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The forward declare type declaration defines the type to be associated with a
+(not yet defined) instruction value <code>%vN</code>. <code>T</code> is the type of the value
+generated by the <code>Nth</code> value generating instruction in the function block.</p>
+<p>Note: It is an error to define the type of <code>%vN</code> with a different type than
+will be generated by the <code>Nth</code> value generating instruction in the function
+block.</p>
+<p>Also note that this construct is a declaration and not considered an
+instruction, even though it appears in the list of instruction records. Hence,
+they may appear before and between <a class="reference internal" href="#link-for-phi-instruction-section"><em>phi</em></a>
+instructions in a basic block.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA = AbbrevIndex(A) &amp;
+TT = TypeID(T)
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+TypeOf(%vN) = T;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+ 48:0|    3: &lt;1, 4&gt;                |    count 4;
+ 50:4|    3: &lt;7, 32&gt;               |    &#64;t0 = i32;
+ 53:6|    3: &lt;2&gt;                   |    &#64;t1 = void;
+ 55:4|    3: &lt;7, 1&gt;                |    &#64;t2 = i1;
+ 58:0|    3: &lt;21, 0, 1, 0&gt;         |    &#64;t3 = void (i32);
+ 62:0|  0: &lt;65534&gt;                 |  }
+ ...
+108:0|  1: &lt;65535, 12, 2&gt;          |  function void &#64;f0(i32 %p0) {
+     |                             |                   // BlockID = 12
+116:0|    3: &lt;1, 7&gt;                |    blocks 7;
+118:4|    1: &lt;65535, 11, 2&gt;        |    constants {  // BlockID = 11
+128:0|      3: &lt;1, 2&gt;              |      i1:
+130:4|      3: &lt;4, 3&gt;              |        %c0 = i1 1;
+133:0|    0: &lt;65534&gt;               |      }
+     |                             |  %b0:
+136:0|    3: &lt;11, 4&gt;               |    br label %b4;
+     |                             |  %b1:
+138:4|    3: &lt;43, 6, 0&gt;            |    declare i32 %v3;
+142:4|    3: &lt;2, 2, 4294967293, 0&gt; |    %v0 = add i32 %p0, %v3;
+151:0|    3: &lt;11, 6&gt;               |    br label %b6;
+     |                             |  %b2:
+153:4|    3: &lt;43, 7, 0&gt;            |    declare i32 %v4;
+157:4|    3: &lt;2, 3, 4294967293, 0&gt; |    %v1 = add i32 %p0, %v4;
+166:0|    3: &lt;11, 6&gt;               |    br label %b6;
+     |                             |  %b3:
+168:4|    3: &lt;2, 4, 4294967295, 0&gt; |    %v2 = add i32 %p0, %v3;
+177:0|    3: &lt;11, 6&gt;               |    br label %b6;
+     |                             |  %b4:
+179:4|    3: &lt;2, 5, 5, 0&gt;          |    %v3 = add i32 %p0, %p0;
+183:4|    3: &lt;11, 1, 5, 5&gt;         |    br i1 %c0, label %b1, label %b5;
+     |                             |  %b5:
+187:4|    3: &lt;2, 1, 6, 0&gt;          |    %v4 = add i32 %v3, %p0;
+191:4|    3: &lt;11, 2, 3, 6&gt;         |    br i1 %c0, label %b2, label %b3;
+     |                             |  %b6:
+195:4|    3: &lt;10&gt;                  |    ret void;
+197:2|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="phi-instruction"><span id="link-for-phi-instruction-section"></span>Phi Instruction</h3>
+<p>The <em>phi</em> instruction is used to implement phi nodes in the SSA graph
+representing the function. Phi instructions can only appear at the beginning of
+a basic block.  There must be no non-phi instructions (other than forward type
+declarations) between the start of the basic block and the <em>phi</em> instruction.</p>
+<p>To clarify the origin of each incoming value, the incoming value is associated
+with the incoming edge from the corresponding predecessor block that the
+incoming value comes from.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = phi T [V1, %bB1], ... , [VM, %bBM];        &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;16, TT, VV1, B1, ..., VVM, BM&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The phi instruction is used to implement phi nodes in the SSA graph representing
+the function. <code>%vN</code> is the resulting value of the corresponding phi
+node. <code>T</code> is the type of the phi node. Values <code>V1</code> through <code>VM</code> are the
+reaching definitions for the phi node while <code>%bB1</code> through <code>%bBM</code> are the
+corresponding predecessor blocks.  Each <code>VI</code> reaches via the incoming
+predecessor edge from block <code>%bBI</code> (for 1 &lt;= I &lt;= M). Type <code>T</code> must be the
+type associated with each <code>VI</code>.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+M &gt; 1 &amp;
+TT == TypeID(T) &amp;
+T = TypeOf(VI) for all I, 1 &lt;= I &lt;= M &amp;
+BI &lt; ExpectedBasicBlocks for all I, 1 &lt;= I &lt;= M &amp;
+VVI = SignRotate(RelativeIndex(VI)) for all I, 1 &lt;= I &lt;= M &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+ 48:0|    3: &lt;1, 4&gt;                |    count 4;
+ 50:4|    3: &lt;7, 32&gt;               |    &#64;t0 = i32;
+ 53:6|    3: &lt;2&gt;                   |    &#64;t1 = void;
+ 55:4|    3: &lt;21, 0, 1&gt;            |    &#64;t2 = void ();
+ 58:6|    3: &lt;7, 1&gt;                |    &#64;t3 = i1;
+ 61:2|  0: &lt;65534&gt;                 |  }
+ ...
+112:0|  1: &lt;65535, 12, 2&gt;          |  function void &#64;f0() {
+     |                             |                   // BlockID = 12
+120:0|    3: &lt;1, 4&gt;                |    blocks 4;
+122:4|    1: &lt;65535, 11, 2&gt;        |    constants {  // BlockID = 11
+132:0|      3: &lt;1, 0&gt;              |      i32:
+134:4|      3: &lt;4, 2&gt;              |        %c0 = i32 1;
+137:0|      3: &lt;1, 3&gt;              |      i1:
+139:4|      3: &lt;4, 0&gt;              |        %c1 = i1 0;
+142:0|    0: &lt;65534&gt;               |      }
+     |                             |  %b0:
+144:0|    3: &lt;11, 1, 2, 1&gt;         |    br i1 %c1, label %b1, label %b2;
+     |                             |  %b1:
+148:0|    3: &lt;2, 2, 2, 0&gt;          |    %v0 = add i32 %c0, %c0;
+152:0|    3: &lt;2, 3, 3, 1&gt;          |    %v1 = sub i32 %c0, %c0;
+156:0|    3: &lt;11, 3&gt;               |    br label %b3;
+     |                             |  %b2:
+158:4|    3: &lt;2, 4, 4, 2&gt;          |    %v2 = mul i32 %c0, %c0;
+162:4|    3: &lt;2, 5, 5, 3&gt;          |    %v3 = udiv i32 %c0, %c0;
+166:4|    3: &lt;11, 3&gt;               |    br label %b3;
+     |                             |  %b3:
+169:0|    3: &lt;16, 0, 8, 1, 4, 2&gt;   |    %v4 = phi i32 [%v0, %b1],
+     |                             |        [%v2, %b2];
+174:4|    3: &lt;16, 0, 8, 1, 4, 2&gt;   |    %v5 = phi i32 [%v1, %b1],
+     |                             |        [%v3, %b2];
+180:0|    3: &lt;10&gt;                  |    ret void;
+181:6|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="select-instruction">Select Instruction</h3>
+<p>The <em>select</em> instruction is used to choose between pairs of values, based on a
+condition, without PNaClAsm-level branching.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = select CT C, T V1, T V2;                &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;29, VV1, VV2, CC&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The <em>select</em> instruction chooses pairs of values <code>V1</code> and <code>V2</code>, based on
+condition value <code>C</code>.  The type <code>CT</code> of value <code>C</code> must either be an i1, or
+a vector of type i1. The type of values <code>V1</code> and <code>V2</code> must be of type
+<code>T</code>. Type <code>T</code> must either be a primitive type, or a vector of a primitive
+type.</p>
+<p>Both <code>CT</code> and <code>T</code> must be primitive types, or both must be vector types of
+the same size. When the contents of <code>C</code> is 1, the corresponding value from
+<code>V1</code> will be chosen. Otherwise the corresponding value from <code>V2</code> will be
+chosen.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+CC == RelativeIndex(C) &amp;
+VV1 == RelativeIndex(V1) &amp;
+VV2 == RelativeIndex(V2) &amp;
+T == TypeOf(V1) == TypeOf(V2) &amp;
+UnderlyingType(CT) == i1 &amp;
+IsInteger(UnderlyingType(T)) or IsFloat(UnderlyingType(T)) &amp;
+UnderlyingCount(C) == UnderlyingCount(T) &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = T;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 96:0|  1: &lt;65535, 12, 2&gt;          |  function i32 &#64;f0(i32 %p0, i32 %p1) {
+     |                             |                   // BlockID = 12
+104:0|    3: &lt;1, 1&gt;                |    blocks 1;
+106:4|    1: &lt;65535, 11, 2&gt;        |    constants {  // BlockID = 11
+116:0|      3: &lt;1, 2&gt;              |      i1:
+118:4|      3: &lt;4, 3&gt;              |        %c0 = i1 1;
+121:0|    0: &lt;65534&gt;               |      }
+     |                             |  %b0:
+124:0|    3: &lt;29, 3, 2, 1&gt;         |    %v0 = select i1 %c0, i32 %p0,
+     |                             |        i32 %p1;
+128:0|    3: &lt;10, 1&gt;               |    ret i32 %v0;
+130:4|  0: &lt;65534&gt;                 |  }
+</pre>
+<h3 id="call-instructions">Call Instructions</h3>
+<p>The <em>call</em> instruction does a function call. The call instruction is used to
+cause control flow to transfer to a specified routine, with its incoming
+arguments bound to the specified values. When a return instruction in the called
+function is reached, control flow continues with the instruction after the
+function call. If the call is to a function, the returned value is the value
+generated by the call instruction. Otherwise no result is defined by the call.</p>
+<p>If the <em>tail</em> flag is associated with the call instruction, then the <a class="reference internal" href="/native-client/overview.html#link-for-pnacl-translator"><em>PNaCl
+translator</em></a> is free to perform tail call
+optimization. That is, the <em>tail</em> flag is a hint that may be ignored by the
+PNaCl translator.</p>
+<p>There are two kinds of calls: <em>direct</em> and <em>indirect</em>. A <em>direct</em> call calls a
+defined <a class="reference internal" href="#link-for-function-address-section"><em>function address</em></a> (i.e. a
+reference to a bitcode ID of the form <code>%fF</code>). All other calls are <em>indirect</em>.</p>
+<h4 id="direct-procedure-call">Direct Procedure Call</h4>
+<p>The direct procedure call calls a defined <a class="reference internal" href="#link-for-function-address-section"><em>function
+address</em></a> whose <a class="reference internal" href="#link-for-function-type"><em>type
+signature</em></a> returns type void.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+TAIL call void &#64;fF (T1 A1, ... , TN AN);        &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;34, CC, F, AA1, ... , AAN&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The direct procedure call calls a define function address <code>%fF</code> whose type
+signature return type is void. The arguments <code>A1</code> through <code>AN</code> are passed in
+the order specified. The type of argument <code>AI</code> must be type <code>TI</code> (for all I,
+1 &lt;=I &lt;= N).  Flag <code>TAIL</code> is optional. If it is included, it must be the
+literal <code>tail</code>.</p>
+<p>The types of the arguments must match the corresponding types of the function
+signature associated with <code>%fF</code>. The return type of <code>%f</code> must be void.</p>
+<p>TAIL is encoded into calling convention value <code>CC</code> as follows:</p>
+<table border="1" class="docutils">
+<colgroup>
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">TAIL</th>
+<th class="head">CC</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>&#8220;&#8221;</td>
+<td>0</td>
+</tr>
+<tr class="row-odd"><td>&#8220;tail&#8221;</td>
+<td>1</td>
+</tr>
+</tbody>
+</table>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+N &gt;= 0 &amp;
+TypeOfFcn(%fF) == void (T1, ... , TN) &amp;
+TypeOf(AI) == TI for all I, 1 &lt;= I &lt;= N
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 72:0|  3: &lt;8, 3, 0, 1, 0&gt;         |  declare external
+     |                             |      void &#64;f0(i32, i64, i32);
+ ...
+116:0|  1: &lt;65535, 12, 2&gt;          |  function void &#64;f1(i32 %p0) {
+     |                             |                   // BlockID = 12
+124:0|    3: &lt;1, 1&gt;                |    blocks 1;
+126:4|    1: &lt;65535, 11, 2&gt;        |    constants {  // BlockID = 11
+136:0|      3: &lt;1, 2&gt;              |      i64:
+138:4|      3: &lt;4, 2&gt;              |        %c0 = i64 1;
+141:0|    0: &lt;65534&gt;               |      }
+     |                             |  %b0:
+144:0|    3: &lt;34, 0, 4, 2, 1, 2&gt;   |    call void
+     |                             |        &#64;f0(i32 %p0, i64 %c0, i32 %p0);
+150:2|    3: &lt;10&gt;                  |    ret void;
+152:0|  0: &lt;65534&gt;                 |  }
+</pre>
+<h4 id="direct-function-call">Direct Function Call</h4>
+<p>The direct function call calls a defined function address whose type signature
+returns a value.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = TAIL call RT %fF (T1 A1, ... , TM AM);  &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;34, CC, F, AA1, ... , AAM&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The direct function call calls a defined function address <code>%fF</code> whose type
+signature returned is not type void. The arguments <code>A1</code> through <code>AM</code> are
+passed in the order specified. The type of argument <code>AI</code> must be type <code>TI</code>
+(for all I, 1 &lt;= I &lt;= N).  Flag <code>TAIL</code> is optional. If it is included, it must
+be the literal <code>tail</code>.</p>
+<p>The types of the arguments must match the corresponding types of the function
+signature associated with <code>%fF</code>. The return type must match <code>RT</code>.</p>
+<p>Each parameter type <code>TI</code>, and return type <code>RT</code>, must either be a primitive
+type, or a vector type.  If the parameter type is an integer type, it must
+either be i32 or i64.</p>
+<p>TAIL is encoded into calling convention value <code>CC</code> as follows:</p>
+<table border="1" class="docutils">
+<colgroup>
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">TAIL</th>
+<th class="head">CC</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>&#8220;&#8221;</td>
+<td>0</td>
+</tr>
+<tr class="row-odd"><td>&#8220;tail&#8221;</td>
+<td>1</td>
+</tr>
+</tbody>
+</table>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+N &gt;= 0 &amp;
+TypeOfFcn(%fF) == RT (T1, ... , TN) &amp;
+TypeOf(AI) == TI for all I, 1 &lt;= I &lt;= M &amp;
+IsFcnArgType(TI) for all I, 1 &lt;= I &lt;= M &amp;
+IsFcnArgType(RT) &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = RT;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 72:0|  3: &lt;8, 2, 0, 1, 0&gt;         |  declare external
+     |                             |      i32 &#64;f0(i32, i64, i32);
+ ...
+116:0|  1: &lt;65535, 12, 2&gt;          |  function i32 &#64;f1(i32 %p0) {
+     |                             |                   // BlockID = 12
+124:0|    3: &lt;1, 1&gt;                |    blocks 1;
+126:4|    1: &lt;65535, 11, 2&gt;        |    constants {  // BlockID = 11
+136:0|      3: &lt;1, 1&gt;              |      i64:
+138:4|      3: &lt;4, 2&gt;              |        %c0 = i64 1;
+141:0|    0: &lt;65534&gt;               |      }
+     |                             |  %b0:
+144:0|    3: &lt;34, 0, 4, 2, 1, 2&gt;   |    %v0 = call i32
+     |                             |        &#64;f0(i32 %p0, i64 %c0, i32 %p0);
+150:2|    3: &lt;34, 1, 4, 1&gt;         |    %v1 = tail call i32 &#64;f1(i32 %v0);
+155:0|    3: &lt;10, 2&gt;               |    ret i32 %v0;
+157:4|  0: &lt;65534&gt;                 |  }
+</pre>
+<h4 id="indirect-procedure-call">Indirect Procedure Call</h4>
+<p>The indirect procedure call calls a function using an indirect function address,
+and whose type signature is assumed to return type void. It is different from
+the direct procedure call because we can&#8217;t use the type signature of the
+corresponding direct function address to type check the construct.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+TAIL call void V (T1 A1, ... , TN AN);        &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;44, CC, TV, VV, AA1, ... , AAN&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The indirect call procedure calls a function using value <code>V</code> that is an
+indirect function address, and whose type signature is assumed to return type
+void.  The arguments <code>A1</code> through <code>AN</code> are passed in the order
+specified. The type of argument <code>AI</code> must be type <code>TI</code> (for all I, 1 &lt;= I &lt;=
+N).  Flag <code>TAIL</code> is optional. If it is included, it must be the literal
+<code>tail</code>.</p>
+<p>Each parameter type <code>TI</code> (1 &lt;= I &lt;= N) must either be a primitive type, or a
+vector type.  If the parameter type is an integer type, it must either be i32
+or i64.</p>
+<p>TAIL is encoded into calling convention value <code>CC</code> as follows:</p>
+<table border="1" class="docutils">
+<colgroup>
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">TAIL</th>
+<th class="head">CC</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>&#8220;&#8221;</td>
+<td>0</td>
+</tr>
+<tr class="row-odd"><td>&#8220;tail&#8221;</td>
+<td>1</td>
+</tr>
+</tbody>
+</table>
+<p>The type signature of the called procedure is assumed to be:</p>
+<pre class="prettyprint">
+void (T1, ... , TN)
+</pre>
+<p>It isn&#8217;t necessary to define this type in the <a class="reference internal" href="#link-for-types-block-section"><em>types
+block</em></a>, since the type is inferred rather than
+used.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+N &gt;= 0 &amp;
+TV = TypeID(void) &amp;
+AbsoluteIndex(V) &gt;= NumFuncAddresses &amp;
+TypeOf(AI) == TI for all I, 1 &lt;= I &lt;= N &amp;
+IsFcnArgType(TI) for all I, 1 &lt;= I &lt;= N
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+ 48:0|    3: &lt;1, 3&gt;                |    count 3;
+ 50:4|    3: &lt;2&gt;                   |    &#64;t0 = void;
+ 52:2|    3: &lt;7, 32&gt;               |    &#64;t1 = i32;
+ 55:4|    3: &lt;21, 0, 0, 1&gt;         |    &#64;t2 = void (i32);
+ 59:4|  0: &lt;65534&gt;                 |  }
+ ...
+ 92:0|  1: &lt;65535, 12, 2&gt;          |  function void &#64;f0(i32 %p0) {
+     |                             |                   // BlockID = 12
+100:0|    3: &lt;1, 1&gt;                |    blocks 1;
+102:4|    1: &lt;65535, 11, 2&gt;        |    constants {  // BlockID = 11
+112:0|      3: &lt;1, 1&gt;              |      i32:
+114:4|      3: &lt;4, 2&gt;              |        %c0 = i32 1;
+117:0|    0: &lt;65534&gt;               |      }
+     |                             |  %b0:
+120:0|    3: &lt;44, 0, 2, 0, 1&gt;      |    call void %p0(i32 %c0);
+125:4|    3: &lt;10&gt;                  |    ret void;
+127:2|  0: &lt;65534&gt;                 |  }
+</pre>
+<h4 id="indirect-function-call">Indirect Function Call</h4>
+<p>The indirect function call calls a function using a value that is an indirect
+function address. It is different from the direct function call because we can&#8217;t
+use the type signature of the corresponding literal function address to type
+check the construct.</p>
+<p><strong>Syntax</strong>:</p>
+<pre class="prettyprint">
+%vN = TAIL call RT V (T1 A1, ... , TM AM);  &lt;A&gt;
+</pre>
+<p><strong>Record</strong>:</p>
+<pre class="prettyprint">
+AA: &lt;34, CC, RRT, VV, AA1, ... , AAM&gt;
+</pre>
+<p><strong>Semantics</strong>:</p>
+<p>The indirect function call calls a function using a value <code>V</code> that is an
+indirect function address, and is assumed to return type <code>RT</code>.  The arguments
+<code>A1</code> through <code>AM</code> are passed in the order specified. The type of argument
+<code>AI</code> must be type <code>TI</code> (for all I, 1 &lt;= I &lt;= N).  Flag <code>TAIL</code> is
+optional. If it is included, it must be the literal <code>tail</code>.</p>
+<p>Each parameter type <code>TI</code> (1 &lt;= I &lt;= M), and return type <code>RT</code>, must either be
+a primitive type, or a vector type.  If the parameter type is an integer type,
+it must either be i32 or i64.</p>
+<p>TAIL is encoded into calling convention value <code>CC</code> as follows:</p>
+<table border="1" class="docutils">
+<colgroup>
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">TAIL</th>
+<th class="head">CC</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>&#8216;&#8217;</td>
+<td>0</td>
+</tr>
+<tr class="row-odd"><td>&#8216;tail&#8217;</td>
+<td>1</td>
+</tr>
+</tbody>
+</table>
+<p>The type signature of the called function is assumed to be:</p>
+<pre class="prettyprint">
+RT (T1, ... , TN)
+</pre>
+<p>It isn&#8217;t necessary to define this type in the <a class="reference internal" href="#link-for-types-block-section"><em>types
+block</em></a>, since the type is inferred rather than
+used.</p>
+<p><strong>Constraints</strong>:</p>
+<pre class="prettyprint">
+AA == AbbrevIndex(A) &amp;
+RRT = TypeID(RT) &amp;
+VV = RelativeIndex(V) &amp;
+M &gt;= 0 &amp;
+AbsoluteIndex(V) &gt;= NumFcnAddresses &amp;
+TypeOf(AI) == TI for all I, 1 &lt;= I &lt;= M &amp;
+IsFcnArgType(TI) for all I, 1 &lt;= I &lt;= M &amp;
+IsFcnArgType(RT) &amp;
+N == NumValuedInsts
+</pre>
+<p><strong>Updates</strong>:</p>
+<pre class="prettyprint">
+++NumValuedInsts;
+TypeOf(%vN) = RT;
+</pre>
+<p><strong>Examples</strong>:</p>
+<pre class="prettyprint">
+ 40:0|  1: &lt;65535, 17, 2&gt;          |  types {  // BlockID = 17
+ 48:0|    3: &lt;1, 6&gt;                |    count 6;
+ 50:4|    3: &lt;7, 32&gt;               |    &#64;t0 = i32;
+ 53:6|    3: &lt;3&gt;                   |    &#64;t1 = float;
+ 55:4|    3: &lt;4&gt;                   |    &#64;t2 = double;
+ 57:2|    3: &lt;21, 0, 0, 0, 1, 2&gt;   |    &#64;t3 = i32 (i32, float, double);
+ 62:6|    3: &lt;21, 0, 0, 1, 2&gt;      |    &#64;t4 = i32 (float, double);
+ 67:4|    3: &lt;2&gt;                   |    &#64;t5 = void;
+ 69:2|  0: &lt;65534&gt;                 |  }
+ ...
+104:0|  1: &lt;65535, 12, 2&gt;          |  function
+     |                             |      i32
+     |                             |      &#64;f0(i32 %p0, float %p1,
+     |                             |          double %p2) {
+     |                             |                   // BlockID = 12
+112:0|    3: &lt;1, 1&gt;                |    blocks 1;
+     |                             |  %b0:
+114:4|    3: &lt;44, 0, 3, 0, 2, 1&gt;   |    %v0 = call i32
+     |                             |        %p0(float %p1, double %p2);
+120:6|    3: &lt;10, 1&gt;               |    ret i32 %v0;
+123:2|  0: &lt;65534&gt;                 |  }
+</pre>
+<h2 id="memory-blocks-and-alignment"><span id="link-for-memory-blocks-and-alignment-section"></span>Memory Blocks and Alignment</h2>
+<p>In general, variable and heap allocated data are represented as byte addressable
+memory blocks. Alignment is always a power of 2, and defines an expectation on
+the memory address. That is, an alignment is met if the memory address is
+(evenly) divisible by the alignment. Note that alignment of 0 is never allowed.</p>
+<blockquote>
+<div>Alignment plays a role at two points:</div></blockquote>
+<ul class="small-gap">
+<li>When you create a local/global variable</li>
+<li>When you load/store data using a pointer.</li>
+</ul>
+<p>PNaClAsm allows most types to be placed at any address, and therefore can
+have alignment of 1. However, many architectures can load more efficiently
+if the data has an alignment that is larger than 1. As such, choosing a larger
+alignment can make load/stores more efficient.</p>
+<p>On loads and stores, the alignment in the instruction is used to communicate
+what assumptions the <a class="reference internal" href="/native-client/overview.html#link-for-pnacl-translator"><em>PNaCl translator</em></a> can
+make when choosing the appropriate machine instructions. If the alignment is 1,
+it can&#8217;t assume anything about the memory address used by the instruction. When
+the alignment is greater than one, it can use that information to potentially
+chose a more efficient sequence of instructions to do the load/store.</p>
+<p>When laying out data within a variable, one also considers alignment. The reason
+for this is that if you want an address to be aligned, within the bytes defining
+the variable, you must choose an alignment for the variable that guarantees that
+alignment.</p>
+<p>In PNaClAsm, the valid load/store alignments are:</p>
+<table border="1" class="docutils">
+<colgroup>
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">Type</th>
+<th class="head">Alignment</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>i1</td>
+<td>1</td>
+</tr>
+<tr class="row-odd"><td>i8</td>
+<td>1</td>
+</tr>
+<tr class="row-even"><td>i16</td>
+<td>1</td>
+</tr>
+<tr class="row-odd"><td>i32</td>
+<td>1</td>
+</tr>
+<tr class="row-even"><td>i64</td>
+<td>1</td>
+</tr>
+<tr class="row-odd"><td>Float</td>
+<td>1, 4</td>
+</tr>
+<tr class="row-even"><td>Double</td>
+<td>1, 8</td>
+</tr>
+<tr class="row-odd"><td>&lt;4 x i1&gt;</td>
+<td>not applicable</td>
+</tr>
+<tr class="row-even"><td>&lt;8 x i1&gt;</td>
+<td>not applicable</td>
+</tr>
+<tr class="row-odd"><td>&lt;16 x i1&gt;</td>
+<td>not applicable</td>
+</tr>
+<tr class="row-even"><td>&lt;16 x i8&gt;</td>
+<td>1</td>
+</tr>
+<tr class="row-odd"><td>&lt;8 x i16&gt;</td>
+<td>2</td>
+</tr>
+<tr class="row-even"><td>&lt;4 x i32&gt;</td>
+<td>4</td>
+</tr>
+<tr class="row-odd"><td>&lt;4 x float&gt;</td>
+<td>4</td>
+</tr>
+</tbody>
+</table>
+<p>Note that only vectors do not have an alignment value of 1. Hence, they can&#8217;t be
+placed at an arbitrary memory address. Also, since vectors on <code>i1</code> can&#8217;t be
+loaded/stored, the alignment is not applicable for these types.</p>
+<h2 id="intrinsic-functions"><span id="link-for-intrinsic-functions-section"></span>Intrinsic Functions</h2>
+<p>Intrinsic functions are special in PNaClAsm. They are implemented as specially
+named (external) function calls. The purpose of these intrinsic functions is to
+extend the PNaClAsm instruction set with additional functionality that is
+architecture specific. Hence, they either can&#8217;t be implemented within PNaClAsm,
+or a non-architecture specific implementation may be too slow on some
+architectures. In such cases, the <a class="reference internal" href="/native-client/overview.html#link-for-pnacl-translator"><em>PNaCl
+translator</em></a> must fill in the corresponding
+implementation, since only it knows the architecture it is compiling down to.</p>
+<p>Examples of intrinsic function calls are for concurrent operations, atomic
+operations, bulk memory moves, thread pointer operations, and long jumps.</p>
+<p>It should be noted that calls to intrinsic functions do not have the same
+calling type constraints as ordinary functions. That is, an intrinsic can use
+any integer type for arguments/results, unlike ordinary functions (which
+restrict integer types to <code>i32</code> and <code>i64</code>).</p>
+<p>See the <a class="reference internal" href="/native-client/reference/pnacl-bitcode-abi.html"><em>PNaCl bitcode reference manual</em></a> for the full
+set of intrinsic functions allowed. Note that in PNaClAsm, all pointer types to
+an (LLVM) intrinsic function is converted to type i32.</p>
+<h2 id="support-functions"><span id="link-for-support-functions-section"></span>Support Functions</h2>
+<p>Defines functions used to convert syntactic representation to values in the
+corresponding record.</p>
+<h3 id="signrotate">SignRotate</h3>
+<p>The SignRotate function encodes a signed integer in an easily compressible
+form. This is done by rotating the sign bit to the rightmost bit, rather than
+the leftmost bit. By doing this rotation, both small positive and negative
+integers are small (unsigned) integers. Therefore, all small integers can be
+encoded as a small (unsigned) integers.</p>
+<p>The definition of SignRotate(N) is:</p>
+<table border="1" class="docutils">
+<colgroup>
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">Argument</th>
+<th class="head">Value</th>
+<th class="head">Condition</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>N</td>
+<td>abs(N)&lt;&lt;1</td>
+<td>N &gt;= 0</td>
+</tr>
+<tr class="row-odd"><td>N</td>
+<td>abs(N)&lt;&lt;1 + 1</td>
+<td>N &lt; 0</td>
+</tr>
+</tbody>
+</table>
+<h3 id="absoluteindex"><span id="link-for-absolute-index-section"></span>AbsoluteIndex</h3>
+<p>Bitcode IDs of the forms <code>&#64;fN</code>, <code>&#64;gN</code>, <code>%pN</code>, <code>%cN</code>, and <code>%vN</code>, are
+combined into a single index space. This can be done because of the ordering
+imposed by PNaClAsm. All function address bitcode IDs must be defined before any
+of the other forms of bitcode IDs. All global address bitcode IDs must be
+defined before any local bitcode IDs. Within a function block, the parameter
+bitcode IDs must be defined before constant IDs, and constant IDs must be
+defined before instruction value IDs.</p>
+<p>Hence, within a function block, it is safe to refer to all of these
+bitcode IDs using a single <em>absolute</em> index. The absolute index for
+each kind of bitcode ID is computed as follows:</p>
+<table border="1" class="docutils">
+<colgroup>
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">Bitcode ID</th>
+<th class="head">AbsoluteIndex</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>&#64;tN</td>
+<td>N</td>
+</tr>
+<tr class="row-odd"><td>&#64;fN</td>
+<td>N</td>
+</tr>
+<tr class="row-even"><td>&#64;gN</td>
+<td>N + NumFcnAddresses</td>
+</tr>
+<tr class="row-odd"><td>&#64;pN</td>
+<td>N + NumFcnAddresses + NumGlobalAddresses</td>
+</tr>
+<tr class="row-even"><td>&#64;cN</td>
+<td>N + NumFcnAddresses + NumGlobalAddresses + NumParams</td>
+</tr>
+<tr class="row-odd"><td>&#64;vN</td>
+<td>N + NumFcnAddresses + NumGlobalAddresses + NumParams + NumFcnConsts</td>
+</tr>
+</tbody>
+</table>
+<h3 id="relativeindex"><span id="link-for-relative-index"></span>RelativeIndex</h3>
+<p>Relative indices are used to refer to values within instructions of a function.
+The relative index of an ID is always defined in terms of the index associated
+with the next value generating instruction. It is defined as follows:</p>
+<pre class="prettyprint">
+RelativeIndex(J) = AbsoluteIndex(%vN) - AbsoluteIndex(J)
+</pre>
+<p>where:</p>
+<pre class="prettyprint">
+N = NumValuedInsts
+</pre>
+<h3 id="abbrevindex">AbbrevIndex</h3>
+<p>This function converts user-defined abbreviation indices to the corresponding
+internal abbreviation index saved in the bitcode file. It adds 4 to its
+argument, since there are 4 predefined internal abbreviation indices (0, 1, 2,
+and 3).</p>
+<table border="1" class="docutils">
+<colgroup>
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">N</th>
+<th class="head">AbbrevIndex(N)</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>undefined</td>
+<td>3</td>
+</tr>
+<tr class="row-odd"><td>%aA</td>
+<td>A + 4</td>
+</tr>
+<tr class="row-even"><td>&#64;aA</td>
+<td>A + 4</td>
+</tr>
+</tbody>
+</table>
+<h3 id="log2">Log2</h3>
+<p>This is the 32-bit log2 value of its argument.</p>
+<h3 id="bitsizeof">BitSizeOf</h3>
+<p>Returns the number of bits needed to represent its argument (a type).</p>
+<table border="1" class="docutils">
+<colgroup>
+</colgroup>
+<thead valign="bottom">
+<tr class="row-odd"><th class="head">T</th>
+<th class="head">BitSizeOf</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr class="row-even"><td>i1</td>
+<td>1</td>
+</tr>
+<tr class="row-odd"><td>i8</td>
+<td>8</td>
+</tr>
+<tr class="row-even"><td>i16</td>
+<td>16</td>
+</tr>
+<tr class="row-odd"><td>i32</td>
+<td>32</td>
+</tr>
+<tr class="row-even"><td>i64</td>
+<td>64</td>
+</tr>
+<tr class="row-odd"><td>float</td>
+<td>32</td>
+</tr>
+<tr class="row-even"><td>double</td>
+<td>64</td>
+</tr>
+<tr class="row-odd"><td>&lt;N X T&gt;</td>
+<td>N * BitSizeOf(T)</td>
+</tr>
+</tbody>
+</table>
+<h3 id="underlyingtype">UnderlyingType</h3>
+<p>Returns the primitive type of the type construct. For primitive types, the
+<em>UnderlyingType</em> is itself. For vector types, the base type of the vector is the
+underlying type.</p>
+<h3 id="underlyingcount">UnderlyingCount</h3>
+<p>Returns the size of the vector if given a vector, and 0 for primitive types.
+Note that this function is used to check if two vectors are of the same size.
+It is also used to test if two types are either primitive (i.e. UnderlyingCount
+returns 0 for both types) or are vectors of the same size (i.e. UnderlyingCount
+returns the same non-zero value).</p>
+<h3 id="isinteger">IsInteger</h3>
+<p>Returns true if the argument is in {i1, i8, i16, i32, i64}.</p>
+<h3 id="isfloat">IsFloat</h3>
+<p>Returns true if the argument is in {<code>float</code>, <code>double</code>}.</p>
+<h3 id="isvector">IsVector</h3>
+<p>Returns true if the argument is a vector type.</p>
+<h3 id="isprimitive">IsPrimitive</h3>
+<p>Returns true if the argument is a primitive type. That is:</p>
+<pre class="prettyprint">
+IsPrimitive(T) == IsInteger(T) or IsFloat(T)
+</pre>
+<h3 id="isfcnargtype">IsFcnArgType</h3>
+<p>Returns true if the argument is a primitive type or a vector type. Further,
+if it is an integer type, it must be i32 or i64. That is:</p>
+<pre class="prettyprint">
+IsFcnArgType(T) = (IsInteger(T) and (i32 = BitSizeOf(T)
+                                     or i64 == BitSizeOf(T)))
+                  or IsFloat(T) or IsVector(T)
+</pre>
+<h2 id="abbreviations"><span id="link-for-abbreviations-section"></span>Abbreviations</h2>
+<p>Abbreviations are used to convert PNaCl records to a sequence of bits. PNaCl
+uses the same strategy as <a class="reference external" href="http://llvm.org/docs/BitCodeFormat.html">LLVM&#8217;s bitcode file format</a>.  See that document for more
+details.</p>
+<p>It should be noted that we replace LLVM&#8217;s header (called the <em>Bitcode Wrapper
+Format</em>) with the bytes of the <a class="reference internal" href="#link-for-header-record-section"><em>PNaCl record
+header</em></a>.  In addition, PNaCl bitcode files do
+not allow <em>blob</em> abbreviation.</p>
+<h3 id="abbreviations-block"><span id="link-for-abbreviations-block-section"></span>Abbreviations Block</h3>
+<p>The abbreviations block is the first block in the module build. The
+block is divided into sections.  Each section is a sequence of records. Each
+record in the sequence defines a user-defined abbreviation.  Each section
+defines abbreviations that can be applied to all (succeeding) blocks of a
+particular kind. These abbreviations are denoted by the (global) ID of the form
+<em>&#64;aN</em>.</p>
+<p>In terms of <a class="reference external" href="http://llvm.org/docs/BitCodeFormat.html">LLVM&#8217;s bitcode file format</a>, the abbreviations block is called a
+<em>BLOCKINFO</em> block. Records <em>SETBID</em> and <em>DEFINE_ABBREV</em> are the only records
+allowed in PNaCl&#8217;s abbreviation block (i.e. it doesn&#8217;t allow <em>BLOCKNAME</em> and
+<em>SETRECORDNAME</em> records).</p>
+<h3 id="todo">TODO</h3>
+<p>Extend this document to describe PNaCl&#8217;s bitcode bit sequencer
+without requiring the reader to refer to <a class="reference external" href="http://llvm.org/docs/BitCodeFormat.html">LLVM&#8217;s bitcode file
+format</a>.</p>
+</section>
+
+{{/partials.standard_nacl_article}}