.. include:: /migration/deprecation.inc
===============================
Contents Of PNaCl Bitcode Files
===============================
.. contents::
:local:
:backlinks: none
:depth: 3
Introduction
============
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 *PNaClAsm*, and defines the textual form of the bitcode
file. The textual form is then lowered to a sequence of :ref:`PNaCl
records<link_for_pnacl_records>`. The final layer applies abbreviations that
convert each PNaCl record into a corresponding sequence of bits.
.. image:: /images/PNaClBitcodeFlow.png
PNaClAsm uses a *static single assignment* (SSA) based representation that
requires generated results to have a single (assignment) source.
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 :ref:`abbreviations<link_for_abbreviations_section>` are used to convert
PNaCl records into the sequence of bits.
Each construct in PNaClAsm defines a corresponding :ref:`PNaCl
record<link_for_pnacl_records>`. 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.
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 *code*). PNaCl records can be nested. Nesting is defined by a
corresponding :ref:`enter<link_for_enter_block_record_section>` and
:ref:`exit<link_for_exit_block_record_section>` block record.
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.
The *PNaCl bitcode writer* 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.
For every kind of record, there is a method for converting records into bit
sequences. These methods correspond to a notion of
:ref:`abbreviations<link_for_abbreviations_section>`. Each abbreviation defines
a specific bit sequence conversion to be applied.
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.
Each abbreviation defines how a record is converted to a bit sequence. The
:ref:`PNaCl translator<link_for_pnacl_translator>` 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.
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.
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.
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.
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 :ref:`pnacl-compress<pnacl_compress>` is provided as part of the SDK to do
this job.
Data Model
==========
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 ``long
long``).
Integers are assumed to be modeled using two's complement. Floating point
support is fixed at :ref:`IEEE 754<c_cpp_floating_point>` 32-bit and 64-bit
values (float and double, respectively).
PNaCl Blocks
============
Blocks are used to organize records in the bitcode file. The kinds of blocks
defined in PNaClAsm are:
Module block
A top-level block defining the program. The :ref:`module
block<link_for_module_block>` 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.
Types block
The :ref:`types block<link_for_types_block_section>` 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.
Globals block
The :ref:`globals block<link_for_globals_block_section>` 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.
Valuesymtab block
The :ref:`valuesymtab block<link_for_valuesymtab_block_section>` defines
textual names for external function addresses.
Function block
Each function (implemented) in a program has its own :ref:`function
block<link_for_function_blocks_section>` that defines the implementation of
the corresponding function.
Constants block
Each implemented function that uses constants in its instructions defines a
:ref:`constants block<link_for_constants_block_section>`. Constants blocks
appear within the corresponding function block of the implemented function.
Abbreviations block
Defines global abbreviations that are used to compress PNaCl records. The
:ref:`abbreviations block<link_for_abbreviations_block_section>` is segmented
into multiple sections, one section for each kind of block. This block appears
at the beginning of the module block.
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.
A PNaCl program consists of a :ref:`header
record<link_for_header_record_section>` and a :ref:`module
block<link_for_module_block>`. The header record defines a sequence of bytes
uniquely identifying the file as a bitcode file. The module block defines the
program to run.
Each block, within a bitcode file, defines values. These values are associated
with IDs. Each type of block defines different kinds of IDs. The
:ref:`module<link_for_module_block>`,
:ref:`types<link_for_types_block_section>`,
:ref:`globals<link_for_globals_block_section>`, and
:ref:`abbreviations<link_for_abbreviations_block_section>` blocks define global
identifiers, and only a single instance can appear. The
:ref:`function<link_for_function_blocks_section>` and
:ref:`constant<link_for_constants_block_section>` blocks define local
identifiers, and can have multiple instances (one for each implemented
function).
The only records in the module block that define values, are :ref:`function
address<link_for_function_address_section>` records. Each function address
record defines a different function address, and the :ref:`type
signature<link_for_function_type>` associated with that function address.
Each :ref:`function block<link_for_function_blocks_section>` 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
:ref:`constants block<link_for_constants_block_section>`, nested within the
corresponding function block.
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
:ref:`defining<link_for_function_address_section>` (rather than declared)
function address record in the module block.
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.
.. _link_for_pnacl_records:
PNaCl Records
=============
A PNaCl record is a non-empty sequence of unsigned, 64-bit, integers. A record
is identified by the record *code*, 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.
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 `LLVM records
<http://llvm.org/docs/BitCodeFormat.html>`_). For backward compatibility,
obsolete numbers have not been reused, leaving gaps in the actual record code
values used.
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 :ref:`global record
codes<link_for_global_record_codes>`. 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`\ . Note: Well-formed PNaCl bitcode files
do not have record codes >= 2\ :sup:`16`\ .
A PNaCl record is denoted as follows: ::
a: <v0, v1, ... , vN>
The value ``v0`` is the record code. The remaining values, ``v1`` through
``vN``, 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. ``a`` is the index to the abbreviation used to convert
the record to a bit sequence.
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.
The *PNaCl bitstream writer*, 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
:ref:`abbreviations<link_for_abbreviations_section>`. However, at the record
level, one important aspect of this appears in :ref:`block
enter<link_for_enter_block_record_section>` records. These records must define
how many bits are required to hold abbreviation indices associated with records
of that block.
.. _link_for_default_abbreviations:
Default Abbreviations
=====================
There are 4 predefined (default) abbreviation indices, used as the default
abbreviations for PNaCl records. They are:
0
Abbreviation index for the abbreviation used to bit-encode an exit block
record.
1
Abbreviation index for the abbreviation used to bit-encode an enter block
record.
2
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.
3
Abbreviation index for the default abbreviation to bit-encode all other
records in the bitcode file.
A block may, in addition, define a list of block specific, user-defined,
abbreviations (of length ``U``). The number of bits ``B`` specified for an enter
record must be sufficiently large such that::
2**B >= U + 4
In addition, the upper limit for ``B`` is ``16``.
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.
PNaCl Identifiers
=================
A program is defined by a :ref:`module block<link_for_module_block>`. Blocks can
be nested within other blocks, including the module block. Each block defines a
sequence of records.
Most of the records, within a block, also define unique values. Each unique
value is given a corresponding unique identifier (i.e. *ID*). In PNaClAsm, each
kind of block defines its own kind of identifiers. The names of these
identifiers are defined by concatenating a prefix character (``'@'`` or
``'%'``), 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.
Identifiers are categorized into two types, *local* and *global*. 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.
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 :ref:`PNaCl
translator<link_for_pnacl_translator>` uses this separation to parallelize the
compilation of functions.
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.
Global identifiers use the prefix character ``'@'`` while local identifiers use
the prefix character ``'%'``.
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 :ref:`PNaCl
translator<link_for_pnacl_translator>`, when downloaded into Chrome.
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.
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.
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)
:ref:`forward type
declarations<link_for_forward_type_declaration_section>`. 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.
The kinds of identifiers used in PNaClAsm are:
@a
Global abbreviation identifier.
%a
Local abbreviation identifier.
%b
Function basic block identifier.
%c
Function constant identifier.
@f
Global function address identifier.
@g
Global variable/constant address identifier.
%p
Function parameter identifier.
@t
Global type identifier.
%v
Value generated by an instruction in a function block.
Conventions For Describing Records
==================================
PNaClAsm is the textual representation of :ref:`PNaCl
records<link_for_pnacl_records>`. 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 :ref:`global state<link_for_global_state_section>`. The global
state is updated by syntax rules. The purpose of the global state is to track
positional dependencies between records.
For each PNaCl construct, we define multiple sections. The **Syntax**
section defines a syntax rule for the construct. The **Record** section
defines the corresponding record associated with the syntax rule. The
**Semantics** 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.
The **Constraints** section (if present) defines any constraints associated
with the construct, including the global state. The **Updates** section (if
present) defines how the global state is updated when the construct is
processed. The **Examples** section gives one or more examples of using the
corresponding PNaClAsm construct.
Some semantics sections use functions to compute values. The meaning of
functions can be found in :ref:`support
functions<link_for_support_functions_section>`.
The syntax rule may include the
:ref:`abbreviation<link_for_abbreviations_section>` to use, when converting to a
bit-sequence. These abbreviations, if allowed, are at the end of the construct,
and enclosed in ``<`` and ``>`` 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.
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.
For example, consider the following syntax rule::
%vN = add T O1, O2; <A>
This rule defines a PNaClAsm add instruction. This construct defines an
instruction that adds two values (``O1`` and ``O2``) to generate instruction
value ``%vN``. The types of the arguments, and the result, are all of type
``T``. If abbreviation ID ``A`` is present, the record is encoded using that
abbreviation. Otherwise the corresponding :ref:`default abbreviation
index<link_for_default_abbreviations>` is used.
To be concrete, the syntactic rule above defines the structure of the following
PNaClAsm examples::
%v10 = add i32 %v1, %v2; <@a5>
%v11 = add i32 %v10, %v3;
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.
Factorial Example
=================
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.
In C, the factorial function can be defined as::
int fact(int n) {
if (n == 1) return 1;
return n * fact(n-1);
}
Compiling this into a PNaCl bitcode file, and dumping out its contents with
utility :ref:`pnacl-bcdis<pnacl-bcdis>`, the corresponding output is::
0:0|<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> |
16:0|1: <65535, 8, 2> |module { // BlockID = 8
24:0| 3: <1, 1> | version 1;
26:4| 1: <65535, 0, 2> | abbreviations { // BlockID = 0
36:0| 0: <65534> | }
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 4> | count 4;
50:4| 3: <7, 32> | @t0 = i32;
53:6| 3: <2> | @t1 = void;
55:4| 3: <21, 0, 0, 0> | @t2 = i32 (i32);
59:4| 3: <7, 1> | @t3 = i1;
62:0| 0: <65534> | }
64:0| 3: <8, 2, 0, 0, 0> | define external i32 @f0(i32);
68:6| 1: <65535, 19, 2> | globals { // BlockID = 19
76:0| 3: <5, 0> | count 0;
78:4| 0: <65534> | }
80:0| 1: <65535, 14, 2> | valuesymtab { // BlockID = 14
88:0| 3: <1, 0, 102, 97, 99, | @f0 : "fact";
| 116> |
96:4| 0: <65534> | }
100:0| 1: <65535, 12, 2> | function i32 @f0(i32 %p0) {
| | // BlockID = 12
108:0| 3: <1, 3> | blocks 3;
110:4| 1: <65535, 11, 2> | constants { // BlockID = 11
120:0| 3: <1, 0> | i32:
122:4| 3: <4, 2> | %c0 = i32 1;
125:0| 0: <65534> | }
| | %b0:
128:0| 3: <28, 2, 1, 32> | %v0 = icmp eq i32 %p0, %c0;
132:6| 3: <11, 1, 2, 1> | br i1 %v0, label %b1, label %b2;
| | %b1:
136:6| 3: <10, 2> | ret i32 %c0;
| | %b2:
139:2| 3: <2, 3, 2, 1> | %v1 = sub i32 %p0, %c0;
143:2| 3: <34, 0, 5, 1> | %v2 = call i32 @f0(i32 %v1);
148:0| 3: <2, 5, 1, 2> | %v3 = mul i32 %p0, %v2;
152:0| 3: <10, 1> | ret i32 %v3;
154:4| 0: <65534> | }
156:0|0: <65534> |}
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.
Bit positions are defined by a pair ``B:N``. ``B`` is the number of bytes, while
``N`` is the bit offset within the ``B``-th byte. Hence, the bit position (in
bits) is::
B*8 + N
Hence, the first record is at bit offset ``0`` (``0*8+0``). The second record is
at bit offset ``128`` (``16*8+0``). The third record is at bit offset ``192``
(``24*8+0``). The fourth record is at bit offset ``212`` (``26*8+4``).
The :ref:`header record<link_for_header_record_section>` 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. 'PEXE'. All PEXE
bitcode files begin with these four bytes.
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.
The types block (starting at bit address ``40:0``), defines 4 types: ``i1``,
``i32``, ``void``, and function signature ``i32 (i32)``.
Bit address ``64:0`` declares the factorial function address ``@f0``, and its
corresponding type signature. Bit address ``88:0`` associates the name ``fact``
with function address ``@f0``.
Bit address ``100:0`` defines the function block that implements function
``fact``. The entry point is ``%b0`` (at bit address ``128:0``). It uses the
32-bit integer constant ``1`` (defined at bit addresses ``122:4``). Bit address
``128:0`` defines an equality comparison of the argument ``%p0`` with ``1``
(constant ``%c0``). Bit address ``132:6`` defines a conditional branch. If the
result of the previous comparison (``%v0``) is true, the program will branch to
block ``%b1``. Otherwise it will branch to block ``%b2``.
Bit address ``136:6`` returns constant ``1`` (``%c0``) when the input parameter
is 1. Instructions between bit address ``139:2`` and ``154:4`` compute and
return ``n * fact(n-1)``.
Road Map
========
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.
Many records have implicit information associated with them, and must be
maintained across records. :ref:`Global state<link_for_global_state_section>`
describes how this implicit information is modeled. In addition, there are
various :ref:`support functions<link_for_support_functions_section>` that are
used to define the semantics of records, and how they update the global state.
There are just a handful of global records (records that either don't appear in
any block, or can appear in all blocks). :ref:`Global
records<link_for_global_record_codes>` describes these records. This includes
the block delimiter records :ref:`enter<link_for_enter_block_record_section>`
and :ref:`exit<link_for_exit_block_record_section>` that define block
boundaries.
PNaClAsm is a strongly typed language, and most block values are typed.
:ref:`types<link_for_types_block_section>` describes the set of legal types, and
how to define types.
Global variables and their initializers are presented in the :ref:`globals
block<link_for_globals_block_section>`. :ref:`Function
addresses<link_for_function_address_section>` are part of the :ref:`module
block<link_for_module_block>`, but must be defined before any global variables.
Names to be associated with global variables and function addresses, are defined
in the :ref:`valuesymtab block<link_for_valuesymtab_block_section>`, and must
appear after the :ref:`globals block<link_for_globals_block_section>`, but
before any :ref:`function definition<link_for_function_blocks_section>`.
The :ref:`module block<link_for_module_block>` 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.
Constants used within a :ref:`function
definition<link_for_function_blocks_section>` must be defined using a
:ref:`constants block<link_for_constants_block_section>`. Each function
definition is defined by a :ref:`function
block<link_for_function_blocks_section>` and constant blocks can only appear
within function blocks. Constants defined within a constant block can only be
used in the enclosing function block.
Function definitions are defined by a sequence of instructions. There are
several types of instructions.
A :ref:`terminator instruction<link_for_terminator_instruction_section>` is the
last instruction in a :ref:`basic block<link_for_function_blocks_section>`, and
is a branch, return, or unreachable instruction.
There are :ref:`integer<link_for_integer_binary_instructions>` and
:ref:`floating point<link_for_floating_point_binary_instructions>` binary
operations. Integer binary instructions include both arithmetic and logical
operations. Floating point instructions define arithmetic operations.
There are also :ref:`memory
access<link_for_memory_creation_and_access_instructions>` instructions that
allow one to load and store values. That section also includes how to define
local variables using the :ref:`alloca
instruction<link_for_alloca_instruction>`.
One can also convert integer and floating point values using :ref:`conversion
instructions<link_for_conversion_instructions>`.
:ref:`Comparison instructions<link_for_compare_instructions>`
allow you to compare values.
:ref:`Vector instructions<link_for_vector_instructions>` allow you to build and
update vectors. Corresponding :ref:`intrinsic
functions<link_for_intrinsic_functions_section>`, as well as
:ref:`integer<link_for_integer_binary_instructions>` and :ref:`floating
point<link_for_floating_point_binary_instructions>` binary instructions allow
you to apply operations to vectors.
In addition, :ref:`other instructions<link_for_other_pnaclasm_instructions>` are
available. This includes function and procedure calls.
There are also :ref:`memory
alignment<link_for_memory_blocks_and_alignment_section>` issues that should be
considered for global and local variables, as well as load and store
instructions.
Finally, how to pack records is described in the
:ref:`abbreviations<link_for_abbreviations_section>` section.
.. _link_for_global_state_section:
Global State
============
This section describes the global state associated with PNaClAsm. It is used to
define contextual data that is carried between records.
In particular, PNaClAsm is a strongly typed language, and hence, we must track
the type associated with values. Subsection :ref:`link_to_typing_functions`
describes the functions used to maintain typing information associated with
values.
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 :ref:`link_to_ID_Counters` defines counters maintained in the global
state.
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 :ref:`PNaCl translator<link_for_pnacl_translator>` space requirements, or
a limit so that it can detect bad references to values. Subsection
:ref:`link_for_Size_Variables` defines variables that hold size definitions in
the corresponding records.
Finally, the function and constants block contain implicit context between
records in those blocks. Subsection :ref:`link_to_Other_Variables` defines the
variables that contain this implicit context.
.. _link_to_typing_functions:
Typing Functions
----------------
Associated with most identifiers is a type. This type defines what type the
corresponding value has. It is defined by the (initially empty) map::
TypeOf: ID -> Type
For each type in the :ref:`types block<link_for_types_block_section>`, a
corresponding inverse map::
TypeID: Type -> ID
is maintained to convert syntactic types to the corresponding type ID.
Note: This document assumes that map ``TypeID`` is automatically maintained
during updates to map ``TypeOf`` (when given a type ``ID``). Hence, *Updates*
subsections will not contain assignments to this map.
Associated with each function identifier is its :ref:`type
signature<link_for_function_type>`. 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).
Function type signatures are maintained using::
TypeOfFcn: ID -> Type
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::
DefiningFcnIDs: set(ID)
.. _link_to_ID_Counters:
ID Counters
-----------
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:
NumTypes
The number of types defined so far (in the :ref:`types
block<link_for_types_block_section>`).
NumFuncAddresses
The number of function addresses defined so far (in the :ref:`module
block<link_for_module_block>`).
NumGlobalAddresses
The number of global variable/constant addresses defined so far (in the
:ref:`globals block<link_for_globals_block_section>`).
NumParams
The number of parameters defined for a function. Note: Unlike other counters,
this value is set once, at the beginning of the corresponding :ref:`function
block<link_for_function_blocks_section>`, based on the type signature
associated with the function.
NumFcnConsts
The number of constants defined in a function so far (in the corresponding
nested :ref:`constants block<link_for_constants_block_section>`).
NumBasicBlocks
The number of basic blocks defined so far (within a :ref:`function
block<link_for_function_blocks_section>`).
NumValuedInsts
The number of instructions, generating values, defined so far (within a
:ref:`function block<link_for_function_blocks_section>`).
.. _link_for_Size_Variables:
Size Variables
--------------
A number of blocks define expected sizes of constructs. These sizes are recorded
in the following size variables:
ExpectedBasicBlocks
The expected :ref:`number of basic blocks<link_for_basic_blocks_count>` within
a function implementation.
ExpectedTypes
The expected :ref:`number of types<link_for_types_count_record>` defined in
the types block.
ExpectedGlobals
The expected :ref:`number of global variable/constant
addresses<link_for_globals_count_record>` in the globals block.
ExpectedInitializers
The expected :ref:`number of initializers<link_for_compound_initializer>` for
a global variable/constant address in the globals block.
It is assumed that the corresponding :ref:`ID counters<link_to_ID_counters>` are
always smaller than the corresponding size variables (except
ExpectedInitializers). That is::
NumBasicBlocks < ExpectedBasicBlocks
NumTypes < ExpectedTypes
NumGlobalAddresses < ExpectedGlobals
.. _link_to_Other_Variables:
Other Variables
---------------
EnclosingFcnID
The function ID of the function block being processed.
ConstantsSetType
Holds the type associated with the last :ref:`set type
record<link_for_constants_set_type_record>` in the constants block. Note: at
the beginning of each constants block, this variable is set to type void.
.. _link_for_global_record_codes:
Global Records
==============
Global records are records that can appear in any block. These records have
the same meaning in multiple kinds of blocks.
There are four global PNaCl records, each having its own record code. These
global records are:
Header
The :ref:`header record<link_for_header_record_section>` is the first record
of a PNaCl bitcode file, and identifies the file'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.
Enter
An :ref:`enter record<link_for_enter_block_record_section>` defines the
beginning of a block. Since blocks can be nested, one can appear inside other
blocks, as well as at the top level.
Exit
An :ref:`exit record<link_for_exit_block_record_section>` defines the end of a
block. Hence, it must appear in every block, to end the block.
Abbreviation
An :ref:`abbreviation record<link_for_abbreviation_record>` 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.
All global records can't have user-defined abbreviations associated with
them. The :ref:`default abbreviation<link_for_default_abbreviations>` is always
used.
.. _link_for_header_record_section:
Header Record
-------------
The header record must be the first record in the file. It is the only record in
the bitcode file that doesn't have a corresponding construct in PNaClAsm. In
addition, no abbreviation index is associated with it.
**Syntax**:
There is no syntax for header records in PNaClAsm.
**Record**::
<65532, 80, 69, 88, 69, 1, 0, 8, 0, 17, 0, 4, 0, 2, 0, 0, 0>
**Semantics**:
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.
**Examples**::
0:0|<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> |
.. _link_for_enter_block_record_section:
Enter Block Record
------------------
Block records can be top-level, as well as nested in other blocks. Blocks must
begin with an *enter* record, and end with an
:ref:`exit<link_for_exit_block_record_section>` record.
**Syntax**::
N { <B>
**Record**::
1: <65535, ID, B>
**Semantics**:
Enter block records define the beginning of a block. ``B``, if present, is the
number of bits needed to represent all possible abbreviation indices used within
the block. If omitted, ``B=2`` is assumed.
The block ``ID`` value is dependent on the name ``N``. Valid names and
corresponding ``BlockID`` values are defined as follows:
============= ========
N Block ID
============= ========
abbreviations 0
constants 11
function 12
globals 19
module 8
types 17
valuesymtab 14
============= ========
Note: For readability, PNaClAsm defines a more readable form of a function block
enter record. See :ref:`function blocks<link_for_function_blocks_section>` for
more details.
**Examples**::
16:0|1: <65535, 8, 2> |module { // BlockID = 8
24:0| 3: <1, 1> | version 1;
26:4| 1: <65535, 0, 2> | abbreviations { // BlockID = 0
36:0| 0: <65534> | }
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 2> | count 2;
50:4| 3: <2> | @t0 = void;
52:2| 3: <21, 0, 0> | @t1 = void ();
55:4| 0: <65534> | }
56:0| 3: <8, 1, 0, 1, 0> | declare external void @f0();
60:6| 1: <65535, 19, 2> | globals { // BlockID = 19
68:0| 3: <5, 0> | count 0;
70:4| 0: <65534> | }
72:0|0: <65534> |}
.. _link_for_exit_block_record_section:
Exit Block Record
-----------------
Block records can be top-level, as well as nested, records. Blocks must begin
with an :ref:`enter<link_for_enter_block_record_section>` record, and end with
an *exit* record.
**Syntax**::
}
**Record**::
0: <65534>
**Semantics**:
All exit records are identical, no matter what block they are ending. An exit
record defines the end of the block.
**Examples**::
16:0|1: <65535, 8, 2> |module { // BlockID = 8
24:0| 3: <1, 1> | version 1;
26:4| 1: <65535, 0, 2> | abbreviations { // BlockID = 0
36:0| 0: <65534> | }
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 2> | count 2;
50:4| 3: <2> | @t0 = void;
52:2| 3: <21, 0, 0> | @t1 = void ();
55:4| 0: <65534> | }
56:0| 3: <8, 1, 0, 1, 0> | declare external void @f0();
60:6| 1: <65535, 19, 2> | globals { // BlockID = 19
68:0| 3: <5, 0> | count 0;
70:4| 0: <65534> | }
72:0|0: <65534> |}
.. _link_for_abbreviation_record:
Abbreviation Record
-------------------
Abbreviation records define abbreviations. See
:ref:`abbreviations<link_for_abbreviations_section>` for details on how
abbreviations should be written. This section only presents the mechanical
details for converting an abbreviation into a PNaCl record.
**Syntax**::
A = abbrev <E1, ... , EM>;
**Record**::
2: <65533, M, EE1, ... , EEM>
**Semantics**:
Defines an abbreviation ``A`` as the sequence of encodings ``E1`` through
``EM``. If the abbreviation appears within the :ref:`abbreviations
block<link_for_abbreviations_block_section>`, ``A`` must be a global
abbreviation. Otherwise, ``A`` must be a local abbreviation.
Abbreviations within a block (or a section within the abbreviations block), must
be enumerated in order, starting at index ``0``.
Valid encodings ``Ei``, and the corresponding sequence of (unsigned) integers
``EEi``, ( for ``1 <= i <= M``) are defined by the following table:
========= ======= ==================================================
Ei EEi Form
========= ======= ==================================================
C 1, C Literal C in corresponding position in record.
fixed(N) 0, 1, N Encode value as a fixed sequence of N bits.
vbr(N) 0, 2, N Encode value using a variable bit rate of N.
char6 0, 4 Encode value as 6-bit char containing
characters [a-zA-Z0-9._].
array 0, 3 Allow zero or more of the succeeding abbreviation.
========= ======= ==================================================
Note that 'array' can only appear as the second to last element in the
abbreviation. Notationally, ``array(EM)`` is used in place of ``array`` and
``EM``, the last two entries in an abbreviation.
**Examples**::
0:0|<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> |
16:0|1: <65535, 8, 2> |module { // BlockID = 8
24:0| 3: <1, 1> | version 1;
26:4| 1: <65535, 0, 2> | abbreviations { // BlockID = 0
36:0| 1: <1, 14> | valuesymtab:
38:4| 2: <65533, 4, 0, 1, 3, 0,| @a0 = abbrev <fixed(3), vbr(8),
| 2, 8, 0, 3, 0, 1, 8> | array(fixed(8))>;
43:2| 2: <65533, 4, 1, 1, 0, 2,| @a1 = abbrev <1, vbr(8),
| 8, 0, 3, 0, 1, 7> | array(fixed(7))>;
48:0| 2: <65533, 4, 1, 1, 0, 2,| @a2 = abbrev <1, vbr(8),
| 8, 0, 3, 0, 4> | array(char6)>;
52:1| 2: <65533, 4, 1, 2, 0, 2,| @a3 = abbrev <2, vbr(8),
| 8, 0, 3, 0, 4> | array(char6)>;
56:2| 1: <1, 11> | constants:
58:6| 2: <65533, 2, 1, 1, 0, 1,| @a0 = abbrev <1, fixed(2)>;
| 2> |
61:7| 2: <65533, 2, 1, 4, 0, 2,| @a1 = abbrev <4, vbr(8)>;
| 8> |
65:0| 2: <65533, 2, 1, 4, 1, 0>| @a2 = abbrev <4, 0>;
68:1| 2: <65533, 2, 1, 6, 0, 2,| @a3 = abbrev <6, vbr(8)>;
| 8> |
71:2| 1: <1, 12> | function:
73:6| 2: <65533, 4, 1, 20, 0, | @a0 = abbrev <20, vbr(6), vbr(4),
| 2, 6, 0, 2, 4, 0, 2, | vbr(4)>;
| 4> |
79:1| 2: <65533, 4, 1, 2, 0, 2,| @a1 = abbrev <2, vbr(6), vbr(6),
| 6, 0, 2, 6, 0, 1, 4> | fixed(4)>;
84:4| 2: <65533, 4, 1, 3, 0, 2,| @a2 = abbrev <3, vbr(6),
| 6, 0, 1, 2, 0, 1, 4> | fixed(2), fixed(4)>;
89:7| 2: <65533, 1, 1, 10> | @a3 = abbrev <10>;
91:7| 2: <65533, 2, 1, 10, 0, | @a4 = abbrev <10, vbr(6)>;
| 2, 6> |
95:0| 2: <65533, 1, 1, 15> | @a5 = abbrev <15>;
97:0| 2: <65533, 3, 1, 43, 0, | @a6 = abbrev <43, vbr(6),
| 2, 6, 0, 1, 2> | fixed(2)>;
101:2| 2: <65533, 4, 1, 24, 0, | @a7 = abbrev <24, vbr(6), vbr(6),
| 2, 6, 0, 2, 6, 0, 2, | vbr(4)>;
| 4> |
106:5| 1: <1, 19> | globals:
109:1| 2: <65533, 3, 1, 0, 0, 2,| @a0 = abbrev <0, vbr(6),
| 6, 0, 1, 1> | fixed(1)>;
113:3| 2: <65533, 2, 1, 1, 0, 2,| @a1 = abbrev <1, vbr(8)>;
| 8> |
116:4| 2: <65533, 2, 1, 2, 0, 2,| @a2 = abbrev <2, vbr(8)>;
| 8> |
119:5| 2: <65533, 3, 1, 3, 0, 3,| @a3 = abbrev <3, array(fixed(8))>
| 0, 1, 8> | ;
123:2| 2: <65533, 2, 1, 4, 0, 2,| @a4 = abbrev <4, vbr(6)>;
| 6> |
126:3| 2: <65533, 3, 1, 4, 0, 2,| @a5 = abbrev <4, vbr(6), vbr(6)>;
| 6, 0, 2, 6> |
130:5| 0: <65534> | }
132:0| 1: <65535, 17, 3> | types { // BlockID = 17
140:0| 2: <65533, 4, 1, 21, 0, | %a0 = abbrev <21, fixed(1),
| 1, 1, 0, 3, 0, 1, 2> | array(fixed(2))>;
144:7| 3: <1, 3> | count 3;
147:4| 3: <7, 32> | @t0 = i32;
150:7| 4: <21, 0, 0, 0, 0> | @t1 = i32 (i32, i32); <%a0>
152:7| 3: <2> | @t2 = void;
154:6| 0: <65534> | }
156:0| 3: <8, 1, 0, 0, 0> | define external i32 @f0(i32, i32);
160:6| 1: <65535, 19, 4> | globals { // BlockID = 19
168:0| 3: <5, 0> | count 0;
170:6| 0: <65534> | }
172:0| 1: <65535, 14, 3> | valuesymtab { // BlockID = 14
180:0| 6: <1, 0, 102> | @f0 : "f"; <@a2>
182:7| 0: <65534> | }
184:0| 1: <65535, 12, 4> | function i32 @f0(i32 %p0, i32 %p1) {
| | // BlockID = 12
192:0| 3: <1, 1> | blocks 1;
| | %b0:
194:6| 5: <2, 2, 1, 0> | %v0 = add i32 %p0, %p1; <@a1>
197:2| 5: <2, 3, 1, 0> | %v1 = add i32 %p0, %v0; <@a1>
199:6| 8: <10, 1> | ret i32 %v1; <@a4>
201:0| 0: <65534> | }
204:0|0: <65534> |}
Note that the example above shows the standard abbreviations used by
*pnacl-finalize*.
.. _link_for_types_block_section:
Types Block
===========
The types block defines all types used in a program. It must appear in the
:ref:`module block<link_for_module_block>`, before any :ref:`function
address<link_for_function_address_section>` records, the :ref:`globals
block<link_for_globals_block_section>`, the :ref:`valuesymtab
block<link_for_valuesymtab_block_section>`, and any :ref:`function
blocks<link_for_function_blocks_section>`.
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.
Each record in the types block defines a type used by the program. Types can be
broken into the following groups:
Primitive value types
Defines the set of base types for values. This includes various sizes of
integer and floating point types.
Void type
A primitive type that doesn't represent any value and has no size.
Function types
The type signatures of functions.
Vector type
Defines vectors of primitive types.
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.
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.
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't be used in a PNaCl program.
The first record of a types block must be a :ref:`count
record<link_for_types_count_record>`, 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.
To make this more concrete, consider the following example types block::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 4> | count 4;
50:4| 3: <7, 32> | @t0 = i32;
53:6| 3: <3> | @t1 = float;
55:4| 3: <2> | @t2 = void;
57:2| 3: <21, 0, 2, 0, 1> | @t3 = void (i32, float);
62:0| 0: <65534> | }
This example defines a types block that defines four type IDs:
@t0
A 32-bit integer type.
@t1
A 32-bit floating point type.
@t2
The void type.
@t3
A function, taking 32-bit integer and float point arguments that returns
void.
.. _link_for_types_count_record:
Count Record
------------
The *count record* 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.
**Syntax**::
count N; <A>
**Record**::
AA: <1, N>
**Semantics**:
This construct defines the number of types used by the PNaCl program. ``N`` is
the number of types defined in the types block. It is an error to define more
(or fewer) types than value ``N``, within the enclosing types block.
**Constraints**::
AA == AbbrevIndex(A) &
0 == NumTypes
**Updates**::
ExpectedTypes = N;
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 4> | count 4;
50:4| 3: <7, 32> | @t0 = i32;
53:6| 3: <3> | @t1 = float;
55:4| 3: <2> | @t2 = void;
57:2| 3: <21, 0, 2, 0, 1> | @t3 = void (i32, float);
62:0| 0: <65534> | }
Void Type
---------
The *void* type record defines the void type, which corresponds to the type that
doesn't define any value, and has no size.
**Syntax**::
@tN = void; <A>
**Record**::
AA: <2>
**Semantics**:
The void type record defines the type that has no values and has no size.
**Constraints**::
AA == AbbrevIndex(A) &
N == NumTypes
**Updates**::
++NumTypes;
TypeOf(@tN) = void;
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 4> | count 4;
50:4| 3: <7, 32> | @t0 = i32;
53:6| 3: <3> | @t1 = float;
55:4| 3: <2> | @t2 = void;
62:0| 0: <65534> | }
Integer Types
-------------
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.
It should be noted that in PNaClAsm, all pointers are implemented as 32-bit
(unsigned) integers. There isn'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).
**Syntax**::
@tN = iB; <A>
**Record**::
AA: <7, B>
**Semantics**:
An integer type record defines an integer type. ``B`` defines the number of bits
of the integer type.
**Constraints**::
AA == AbbrevIndex(A) &
N == NumTypes &
B in {1, 8, 16, 32, 64}
**Updates**::
++NumTypes;
TypeOf(@tN) = iB;
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 7> | count 7;
50:4| 3: <7, 64> | @t0 = i64;
53:6| 3: <7, 1> | @t1 = i1;
56:2| 3: <7, 8> | @t2 = i8;
58:6| 3: <7, 16> | @t3 = i16;
61:2| 3: <7, 32> | @t4 = i32;
64:4| 3: <21, 0, 0, 1> | @t5 = i64 (i1);
68:4| 3: <2> | @t6 = void;
70:2| 0: <65534> | }
32-Bit Floating Point Type
--------------------------
PNaClAsm allows computation on 32-bit floating point values. A floating point
type record defines the 32-bit floating point type.
**Syntax**::
@tN = float; <A>
**Record**::
AA: <3>
**Semantics**:
A floating point type record defines the 32-bit floating point type.
**Constraints**::
AA == AbbrevIndex(A) &
N == NumTypes
**Updates**::
++NumTypes;
TypeOf(@tN) = float;
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 4> | count 4;
50:4| 3: <4> | @t0 = double;
52:2| 3: <3> | @t1 = float;
54:0| 3: <21, 0, 0, 1> | @t2 = double (float);
58:0| 3: <2> | @t3 = void;
59:6| 0: <65534> | }
64-bit Floating Point Type
--------------------------
PNaClAsm allows computation on 64-bit floating point values. A 64-bit floating
type record defines the 64-bit floating point type.
**Syntax**::
@tN = double; <A>
**Record**::
AA: <4>
**Semantics**:
A double type record defines the 64-bit floating point type.
**Constraints**::
AA == AbbrevIndex(A) &
N == NumTypes
**Updates**::
++NumTypes;
TypeOf(@tN) = double;
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 4> | count 4;
50:4| 3: <4> | @t0 = double;
52:2| 3: <3> | @t1 = float;
54:0| 3: <21, 0, 0, 1> | @t2 = double (float);
58:0| 3: <2> | @t3 = void;
59:6| 0: <65534> | }
Vector Types
------------
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) :ref:`vector instruction<link_for_vector_instructions>`. A
vector type requires a size (number of elements) and an underlying primitive
data type.
**Syntax**::
@tN = < E x T > <A>
**Record**::
AA: <12, E, TT>
**Semantics**:
The vector type defines a vector of elements. ``T`` is the type of each
element. ``E`` is the number of elements in the vector.
Vector types can only be defined on ``i1``, ``i8``, ``i16``, ``i32``, and
``float``. All vector types, except those on ``i1``, must contain exactly 128
bits. The valid element sizes are restricted as follows:
====== ===================
Type Valid element sizes
====== ===================
i1 4, 8, 16
i8 16
i16 8
i32 4
float 4
====== ===================
**Constraints**::
AA == AbbrevIndex(A) &
TT == AbsoluteIndex(TypeID(T)) &
N == NumTypes
**Updates**::
++NumTypes
TypeOf(@tN) = <E x T>
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 14> | count 14;
50:4| 3: <7, 32> | @t0 = i32;
53:6| 3: <7, 1> | @t1 = i1;
56:2| 3: <2> | @t2 = void;
58:0| 3: <12, 4, 1> | @t3 = <4 x i1>;
61:2| 3: <12, 8, 1> | @t4 = <8 x i1>;
64:4| 3: <12, 16, 1> | @t5 = <16 x i1>;
67:6| 3: <7, 8> | @t6 = i8;
70:2| 3: <12, 16, 6> | @t7 = <16 x i8>;
73:4| 3: <7, 16> | @t8 = i16;
76:0| 3: <12, 8, 8> | @t9 = <8 x i16>;
79:2| 3: <12, 4, 0> | @t10 = <4 x i32>;
82:4| 3: <3> | @t11 = float;
84:2| 3: <12, 4, 11> | @t12 = <4 x float>;
87:4| 3: <21, 0, 2> | @t13 = void ();
90:6| 0: <65534> | }
.. _link_for_function_type:
Function Type
-------------
The *function* type can be thought of as a function signature. It consists of a
return type, and a (possibly empty) list of formal parameter types.
**Syntax**::
%tN = RT (T1, ... , TM) <A>
**Record**::
AA: <21, 0, IRT, IT1, ... , ITM>
**Semantics**:
The function type defines the signature of a function. ``RT`` is the return type
of the function, while types ``T1`` through ``TM`` are the types of the
arguments. Indices to the corresponding type identifiers are stored in the
corresponding record.
The return value must either be a primitive type, type ``void``, or a vector
type. Parameter types can be a primitive or vector type.
For ordinary functions, the only valid integer types that can be used for a
return or parameter type are ``i32`` and ``i64``. All other integer types are
not allowed.
For :ref:`intrinsic functions<link_for_intrinsic_functions_section>`, all
integer types are allowed for both return and parameter types.
**Constraints**::
AA == AbbrevIndex(A) &
M >= 0 &
IRT == AbsoluteIndex(TypeID(RT)) &
IT1 == AbsoluteIndex(TypeID(T1)) &
...
ITM == AbsoluteIndex(TypeID(TM)) &
N == NumTypes
**Updates**::
++NumTypes
TypeOf(@tN) = RT (T1, ... , TM)
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 7> | count 7;
50:4| 3: <7, 32> | @t0 = i32;
53:6| 3: <3> | @t1 = float;
55:4| 3: <4> | @t2 = double;
57:2| 3: <21, 0, 2, 1> | @t3 = double (float);
61:2| 3: <2> | @t4 = void;
63:0| 3: <21, 0, 4> | @t5 = void ();
66:2| 3: <21, 0, 0, 0, 1, 0, 2>| @t6 =
| | i32 (i32, float, i32, double);
72:4| 0: <65534> | }
.. _link_for_globals_block_section:
Globals Block
=============
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 :ref:`module block<link_for_module_block>`. It must appear after the
:ref:`types block<link_for_types_block_section>`, as well as after all
:ref:`function address<link_for_function_address_section>` records. But, it must
also appear before the :ref:`valuesymtab
block<link_for_valuesymtab_block_section>`, and any
:ref:`function blocks<link_for_function_blocks_section>`.
The globals block begins with a :ref:`count
record<link_for_globals_count_record>`, 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.
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 :ref:`compound
record<link_for_compound_initializer>`, specifying a number *N*, followed by
sequence of *N* simple initializer records.
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.
For notational convenience, PNaClAsm begins a compound record with a "{", and
inserts a "}" after the last initializer record associated with the compound
record. This latter "}" 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.
Explicit alignment is specified for global addresses, and must be a power of
2. See :ref:`memory blocks and
alignment<link_for_memory_blocks_and_alignment_section>` for a more detailed
discussion on how to define alignment.
For example, consider the following pnacl-bcdis output snippet::
52:0| 1: <65535, 19, 2> | globals { // BlockID = 19
60:0| 3: <5, 2> | count 2;
62:4| 3: <0, 1, 1> | const @g0, align 1,
65:6| 3: <2, 8> | zerofill 8;
68:2| 3: <0, 1, 0> | var @g1, align 1,
71:4| 3: <1, 2> | initializers 2 {
74:0| 3: <3, 1, 2, 3, 4> | { 1, 2, 3, 4}
78:6| 3: <2, 2> | zerofill 2;
| | }
81:2| 0: <65534> | }
This snippet defines the global constant ``@g0``, and the global variable
``@g1``. ``@g0`` is 8 bytes long, and initialized to zero. ``@g1`` is
initialized with 6 bytes: ``1 2 3 4 0 0``.
.. _link_for_globals_count_record:
Count Record
------------
The count record defines the number of global addresses used by the PNaCl
program.
**Syntax**::
count N; <A>
**Record**::
AA: <5, N>
**Semantics**:
This record must appear first in the globals block. The count record defines
the number of global addresses used by the program.
**Constraints**::
AA == AbbrevIndex(A)
**Updates**::
ExpectedGlobals = N;
ExpectedInitializers = 0;
**Examples**::
52:0| 1: <65535, 19, 2> | globals { // BlockID = 19
60:0| 3: <5, 2> | count 2;
62:4| 3: <0, 1, 1> | const @g0, align 1,
65:6| 3: <2, 8> | zerofill 8;
68:2| 3: <0, 1, 0> | var @g1, align 1,
71:4| 3: <1, 2> | initializers 2 {
74:0| 3: <3, 1, 2, 3, 4> | { 1, 2, 3, 4}
78:6| 3: <2, 2> | zerofill 2;
| | }
81:2| 0: <65534> | }
.. _link_for_global_variable_address:
Global Variable Addresses
-------------------------
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.
**Syntax**::
var @gN, align V, <A>
**Record**::
AA: <0, VV, 0>
**Semantics**:
A global variable address record defines a global address for a global variable.
``V`` is the :ref:`memory
alignment<link_for_memory_blocks_and_alignment_section>` for the global variable
address, and is a power of 2.
It is assumed that the memory, referenced by the global variable address, can be
both read and written to.
**Constraints**::
AA == AbbrevIndex(A) &
N == NumGlobalAddresses &
ExpectedInitializers == 0 &
VV == Log2(V+1)
**Updates**::
++NumGlobalAddresses;
ExpectedInitializers = 1;
TypeOf(@gN) = i32;
**Examples**::
52:0| 1: <65535, 19, 2> | globals { // BlockID = 19
60:0| 3: <5, 2> | count 2;
62:4| 3: <0, 3, 0> | var @g0, align 4,
65:6| 3: <2, 8> | zerofill 8;
68:2| 3: <0, 1, 0> | var @g1, align 1,
71:4| 3: <3, 1, 2, 3, 4> | { 1, 2, 3, 4}
76:2| 0: <65534> | }
80:0|0: <65534> |}
.. _link_for_global_constant_address:
Global Constant Addresses
-------------------------
A global constant address record defines an address corresponding to a global
constant that can'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.
**Syntax**::
const @gN, align V, <A>
**Record**::
AA: <0, VV, 1>
**Semantics**:
A global constant address record defines a global address for a global constant.
``V`` is the :ref:`memory
alignment<link_for_memory_blocks_and_alignment_section>` for the global constant
address, and is a power of 2.
It is assumed that the memory, referenced by the global constant address, is
only read, and can't be written to.
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.
**Constraints**::
AA == AbbrevIndex(A) &
N == NumGlobalAddresses &
ExpectedInitializers == 0 &
VV == Log2(V+1)
**Updates**::
++NumGlobalAddresses;
ExpectedInitializers = 1;
TypeOf(@gN) = i32;
**Examples**::
52:0| 1: <65535, 19, 2> | globals { // BlockID = 19
60:0| 3: <5, 2> | count 2;
62:4| 3: <0, 3, 1> | const @g0, align 4,
65:6| 3: <2, 8> | zerofill 8;
68:2| 3: <0, 1, 1> | const @g1, align 1,
71:4| 3: <3, 1, 2, 3, 4> | { 1, 2, 3, 4}
76:2| 0: <65534> | }
Zerofill Initializer
--------------------
The zerofill initializer record initializes a sequence of bytes, associated with
a global address, with zeros.
**Syntax**::
zerofill N; <A>
**Record**::
AA: <2, N>
**Semantics**:
A zerofill initializer record initializes a sequence of bytes, associated with a
global address, with zeros. The number of bytes initialized to zero is ``N``.
**Constraints**::
AA == AbbrevIndex(A) &
ExpectedInitializers > 0
**Updates**::
--ExpectedInitializers;
**Examples**::
52:0| 1: <65535, 19, 2> | globals { // BlockID = 19
60:0| 3: <5, 2> | count 2;
62:4| 3: <0, 3, 1> | const @g0, align 4,
65:6| 3: <2, 8> | zerofill 8;
68:2| 3: <0, 1, 0> | var @g1, align 1,
71:4| 3: <2, 4> | zerofill 4;
74:0| 0: <65534> | }
Data Initializer
----------------
Data records define a sequence of bytes. These bytes define the initial value of
the contents of the corresponding memory.
**Syntax**::
{ B1 , .... , BN } <A>
**Record**::
AA: <3, B1, ..., BN>
**Semantics**:
A data record defines a sequence of (unsigned) bytes ``B1`` through ``BN``, that
initialize ``N`` bytes of memory.
**Constraints**::
AA == AbbrevIndex(A) &
ExpectedInitializers > 0
**Updates**::
--ExpectedInitializers;
**Examples**::
56:0| 3: <8, 1, 0, 1, 0> | declare external void @f0();
60:6| 1: <65535, 19, 2> | globals { // BlockID = 19
68:0| 3: <5, 2> | count 2;
70:4| 3: <0, 1, 1> | const @g0, align 1,
73:6| 3: <3, 1, 2, 97, 36, 44, | { 1, 2, 97, 36, 44, 88,
| 88, 44, 50> | 44, 50}
86:0| 3: <0, 1, 1> | const @g1, align 1,
89:2| 3: <1, 3> | initializers 3 {
91:6| 3: <3, 1, 2, 3, 4> | { 1, 2, 3, 4}
96:4| 3: <4, 0> | reloc @f0;
99:0| 3: <3, 99, 66, 22, 12> | { 99, 66, 22, 12}
| | }
105:2| 0: <65534> | }
Relocation Initializer
----------------------
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
:ref:`function<link_for_function_address_section>`,
:ref:`variable<link_for_global_variable_address>`, or
:ref:`constant<link_for_global_constant_address>`). Since addresses are
pointers, a relocation initializer record defines 4 bytes of memory.
**Syntax**::
reloc V; <A>
**Record**::
AA: <4, VV>
**Semantics**:
A relocation initializer record defines a 4-byte value containing the specified
global address ``V``.
**Constraints**::
AA == AbbrevIndex(A) &
VV == AbsoluteIndex(V) &
VV >= NumFuncAddresses &
VV < NumFuncAddresses + ExpectedGlobals &
ExpectedInitializers > 0
**Updates**::
--ExpectedInitializers;
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 2> | count 2;
50:4| 3: <2> | @t0 = void;
52:2| 3: <21, 0, 0> | @t1 = void ();
55:4| 0: <65534> | }
56:0| 3: <8, 1, 0, 1, 0> | declare external void @f0();
60:6| 1: <65535, 19, 2> | globals { // BlockID = 19
68:0| 3: <5, 2> | count 2;
70:4| 3: <0, 1, 0> | var @g0, align 1,
73:6| 3: <1, 3> | initializers 3 {
76:2| 3: <4, 0> | reloc @f0;
78:6| 3: <4, 1> | reloc @g0;
81:2| 3: <4, 2> | reloc @g1;
| | }
83:6| 3: <0, 3, 0> | var @g1, align 4,
87:0| 3: <2, 4> | zerofill 4;
89:4| 0: <65534> | }
This example defines global address ``@g0`` and ``@g1``. ``@g0`` defines 12
bytes of memory, and is initialized with three addresses ``@f1``, ``@g0``, and
``@g1``. Note that all global addresses can be used in a relocation
initialization record, even if it isn't defined yet.
Subfield Relocation Initializer
-------------------------------
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 :ref:`variable<link_for_global_variable_address>` or
:ref:`constant<link_for_global_constant_address>` address), plus a
constant. Since addresses are pointers, a relocation initializer record defines
4 bytes of memory.
**Syntax**::
reloc V + X; <A>
reloc V - X; <A>
**Record**::
AA: <4, VV, XXX>
**Semantics**:
A subfield relocation initializer record defines a 4-byte value containing the
specified global (non-function) address ``V``, modified by the unsigned offset
``X``. ``XX`` is the corresponding signed offset. In the first form, ``XX ==
X``. In the second form, ``XX == -X``.
**Constraints**::
AA == AbbrevIndex(A)
VV == AbsoluteIndex(V)
VV >= NumFuncAddresses
VV < NumFuncAddresses + ExpectedGlobals
ExpectedInitializers > 0
XXX == SignRotate(XX)
**Updates**::
--ExpectedInitializers;
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 0> | count 0;
50:4| 0: <65534> | }
52:0| 1: <65535, 19, 2> | globals { // BlockID = 19
60:0| 3: <5, 3> | count 3;
62:4| 3: <0, 1, 0> | var @g0, align 1,
65:6| 3: <1, 3> | initializers 3 {
68:2| 3: <4, 0, 1> | reloc @g0 + 1;
71:4| 3: <4, 1, 4294967295> | reloc @g1 - 1;
79:2| 3: <4, 2, 4> | reloc @g2 + 4;
| | }
82:4| 3: <0, 3, 0> | var @g1, align 4,
85:6| 3: <2, 4> | zerofill 4;
88:2| 3: <0, 3, 0> | var @g2, align 4,
91:4| 3: <2, 8> | zerofill 8;
94:0| 0: <65534> | }
.. _link_for_compound_initializer:
Compound Initializer
--------------------
The compound initializer record must immediately follow a global
:ref:`variable<link_for_global_variable_address>` or
:ref:`constant<link_for_global_constant_address>` 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.
Note that a compound initializer can't be used as a simple initializer of
another compound initializer (i.e. nested compound initializers are not
allowed).
**Syntax**::
initializers N { <A>
...
}
**Record**::
AA: <1, N>
**Semantics**:
Defines that the next `N` initializers should be associated with the global
address of the previous record.
**Constraints**::
AA == AbbrevIndex(A) &
ExpectedInitializers == 1
**Updates**::
ExpectedInitializers = N;
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 0> | count 0;
50:4| 0: <65534> | }
52:0| 1: <65535, 19, 2> | globals { // BlockID = 19
60:0| 3: <5, 2> | count 2;
62:4| 3: <0, 0, 1> | const @g0, align 0,
65:6| 3: <1, 2> | initializers 2 {
68:2| 3: <2, 8> | zerofill 8;
70:6| 3: <3, 3, 2, 1, 0> | { 3, 2, 1, 0}
| | }
75:4| 3: <0, 0, 0> | var @g1, align 0,
78:6| 3: <1, 2> | initializers 2 {
81:2| 3: <3, 1, 2, 3, 4> | { 1, 2, 3, 4}
86:0| 3: <2, 2> | zerofill 2;
| | }
88:4| 0: <65534> | }
.. _link_for_valuesymtab_block_section:
Valuesymtab Block
=================
The valuesymtab block does not define any values. Its only goal is to associate
text names with external :ref:`function
addresses<link_for_function_address_section>`. Each association is defined by a
record in the valuesymtab block. Currently, only
:ref:`intrinsic<link_for_intrinsic_functions_section>` function addresses and
the (external) start function (``_start``) can be named. All named function
addresses must be external. Each record in the valuesymtab block is a *entry*
record, defining a single name association.
Entry Record
------------
The *entry* record defines a name for a function address.
**Syntax**::
V : "NAME"; <A>
**Record**::
AA: <1, B1, ... , BN>
**Semantics**:
The *entry* record defines a name ``NAME`` for function address ``V``. ``NAME``
is a sequence of ASCII characters ``B1`` through ``BN``.
**Examples**::
72:0| 3: <8, 4, 0, 1, 0> | declare external
| | void @f0(i32, i32, i32, i32, i1);
76:6| 3: <8, 4, 0, 1, 0> | declare external
| | void @f1(i32, i32, i32, i32, i1);
81:4| 3: <8, 5, 0, 0, 0> | define external void @f2(i32);
86:2| 1: <65535, 19, 2> | globals { // BlockID = 19
92:0| 3: <5, 0> | count 0;
94:4| 0: <65534> | }
96:0| 1: <65535, 14, 2> | valuesymtab { // BlockID = 14
104:0| 3: <1, 1, 108, 108, 118, | @f1 : "llvm.memmove.p0i8.p0i8.i32";
| 109, 46, 109, 101, |
| 109, 109, 111, 118, |
| 101, 46, 112, 48, |
| 105, 56, 46, 112, 48,|
| 105, 56, 46, 105, 51,|
| 50> |
145:4| 3: <1, 2, 95, 115, 116, | @f2 : "_start";
| 97, 114, 116> |
157:0| 3: <1, 0, 108, 108, 118, | @f0 : "llvm.memcpy.p0i8.p0i8.i32";
| 109, 46, 109, 101, |
| 109, 99, 112, 121, |
| 46, 112, 48, 105, 56,|
| 46, 112, 48, 105, 56,|
| 46, 105, 51, 50> |
197:0| 0: <65534> | }
.. _link_for_module_block:
Module Block
============
The module block, like all blocks, is enclosed in a pair of
:ref:`enter<link_for_enter_block_record_section>` /
:ref:`exit<link_for_exit_block_record_section>` records, using block ID 8. A
well-formed module block consists of the following records (in order):
A version record
The :ref:`version record<link_for_version_record>` 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.
Optional local abbreviations
Defines a list of local :ref:`abbreviations<link_for_abbreviations_section>`
to use for records within the module block.
An abbreviations block
The :ref:`abbreviations block<link_for_abbreviations_block_section>` defines
user-defined, global abbreviations that are used to convert PNaCl records to
bit sequences in blocks following the abbreviations block.
A types block
The :ref:`types block<link_for_types_block_section>` defines the set of all
types used in the program.
A non-empty sequence of function address records
Each record defines a :ref:`function
address<link_for_function_address_section>` 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 :ref:`function
block<link_for_function_blocks_section>` (appearing later in the module) that
defines the sequence of instructions for each defined function.
A globals block defining the global variables.
This :ref:`block<link_for_globals_block_section>` defines the set of
global :ref:`variable<link_for_global_variable_address>` and
:ref:`constant<link_for_global_constant_address>` addresses used by the
program. In addition to the addresses, each global variable also defines how
the corresponding global variable is initialized.
An optional value symbol table block.
This :ref:`block<link_for_valuesymtab_block_section>`, if defined, provides
textual names for :ref:`function
addresses<link_for_function_address_section>` (previously defined in the
module). Note that only names for intrinsic functions and the start function
are specified.
A sequence of function blocks.
Each :ref:`function block<link_for_Function_blocks_section>` defines the
corresponding intermediate representation for each defined function. The
order of function blocks is used to associate them with :ref:`function
addresses<link_for_function_address_section>`. The order of the defined
function blocks must follow the same order as the corresponding function
addresses defined in the module block.
Descriptions of the :ref:`abbreviations<link_for_abbreviations_section>`,
:ref:`types<link_for_types_block_section>`,
:ref:`globals<link_for_globals_block_section>`, :ref:`value symbol
table<link_for_valuesymtab_block_section>`, and
:ref:`function<link_for_function_blocks_section>` 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.
.. _link_for_version_record:
Version Record
--------------
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.
Note that currently, only PNaCl bitcode version 2, and version record value 1 is
defined.
**Syntax**::
version N; <A>
**Record**::
AA: <1, N>
**Semantics**:
The version record defines which PNaCl reader/writer rules should be
followed. ``N`` is the version number. Currently ``N`` must be 1. Future
versions of PNaCl may define additional legal values.
**Constraints**::
AA == AbbrevIndex(A)
*Examples*::
16:0|1: <65535, 8, 2> |module { // BlockID = 8
24:0| 3: <1, 1> | version 1;
26:4| 1: <65535, 0, 2> | abbreviations { // BlockID = 0
36:0| 0: <65534> | }
.. _link_for_function_address_section:
Function Address
----------------
A function address record describes a function address. *Defined* function
addresses define :ref:`implementations<link_for_function_blocks_section>` while
*declared* function addresses do not.
Since a PNaCl program is assumed to be a complete (statically linked)
executable, All functions should be *defined* and *internal*. The exception to
this are :ref:`intrinsic functions<link_for_intrinsic_functions_section>`, which
should only be *declared* and *external*, since intrinsic functions will be
automatically converted to appropriate code by the :ref:`PNaCl
translator<link_for_pnacl_translator>`.
The implementation of a *defined* function address is provided by a
corresponding function block, appearing later in the module block. The
association of a *defined* function address with the corresponding function
block is based on position. The *Nth* defined function address record, in the
module block, has its implementation in the *Nth* function block of that module
block.
**Syntax**::
PN LN T0 @fN ( T1 , ... , TM ); <A>
**Record**::
AA: <8, T, C, P, L>
**Semantics**:
Describes the function address ``@fN``. ``PN`` is the name that specifies the
prototype value ``P`` associated with the function. A function address is
*defined* only if ``P == 0``. Otherwise, it is only *declared*. The type of the
function is :ref:`function type<link_for_function_type>` ``@tT``. ``L`` is the
linkage specification corresponding to name ``LN``. ``C`` is the calling
convention used by the function.
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 ``void``,
or a vector type.
For ordinary functions, integer parameter and types can only be ``i32`` and
``i64``. All other integer types are not allowed. For intrinsic functions, all
integer types are allowed.
Valid prototype names ``PN``, and corresponding ``P`` values, are:
= =======
P PN
= =======
1 declare
0 define
= =======
Valid linkage names ``LN``, and corresponding ``L`` values, are:
= ========
L LN
= ========
3 internal
0 external
= ========
Currently, only one calling convention ``C`` is supported:
= ====================
C Calling Convention
= ====================
0 C calling convention
= ====================
**Constraints**::
AA = AbbrevIndex(A) &
T = TypeID(TypeOf(T0 ( T1 , ... , TN ))) &
N = NumFuncAddresses
**Updates**::
++NumFuncAddresses;
TypeOf(@fN) = TypeOf(TypeID(i32));
TypeOfFcn(@fN) = TypeOf(@tT);
if PN == 0:
DefiningFcnIDs += @FN;
++NumDefinedFunctionAddresses;
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 7> | count 7;
50:4| 3: <7, 32> | @t0 = i32;
53:6| 3: <3> | @t1 = float;
55:4| 3: <4> | @t2 = double;
57:2| 3: <2> | @t3 = void;
59:0| 3: <21, 0, 2, 1> | @t4 = double (float);
63:0| 3: <21, 0, 0, 0, 1, 0, 2>| @t5 =
| | i32 (i32, float, i32, double);
69:2| 3: <21, 0, 3> | @t6 = void ();
72:4| 0: <65534> | }
76:0| 3: <8, 4, 0, 1, 0> | declare external double @f0(float);
80:6| 3: <8, 5, 0, 1, 0> | declare external
| | i32 @f1(i32, float, i32, double);
85:4| 3: <8, 6, 0, 0, 0> | define external void @f2();
.. _link_for_constants_block_section:
Constants Blocks
================
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 :ref:`function block<link_for_function_blocks_section>`, and must appear
before any instructions in the function block.
Currently, only integer literals, floating point literals, and undefined vector
constants can be defined.
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 :ref:`set type
record<link_for_constants_set_type_record>`, followed by a sequence of literal
constants. These literal constants all get converted to the type of the
preceding set type record.
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.
To make this more concrete, consider the following example constants block::
106:4| 1: <65535, 11, 2> | constants { // BlockID = 11
116:0| 3: <1, 0> | i32:
118:4| 3: <4, 2> | %c0 = i32 1;
121:0| 3: <4, 4> | %c1 = i32 2;
123:4| 3: <1, 2> | i8:
126:0| 3: <4, 8> | %c2 = i8 4;
128:4| 3: <4, 6> | %c3 = i8 3;
131:0| 3: <1, 1> | float:
133:4| 3: <6, 1065353216> | %c4 = float 1;
139:6| 0: <65534> | }
.. _link_for_constants_set_type_record:
Set Type Record
---------------
The *set type* record defines the type to use for the (immediately) succeeding
literals.
**Syntax**::
T: <A>
**Record**::
AA: <1, TT>
**Semantics**:
The *set type* record defines type ``T`` to be used to type the (immediately)
succeeding literals. ``T`` must be a non-void primitive value type or a vector
type.
**Constraints**::
TT == TypeID(T)
**Updates**::
ConstantsSetType = T;
**Examples**::
106:4| 1: <65535, 11, 2> | constants { // BlockID = 11
116:0| 3: <1, 0> | i32:
118:4| 3: <4, 2> | %c0 = i32 1;
121:0| 3: <4, 4> | %c1 = i32 2;
123:4| 3: <1, 2> | i8:
126:0| 3: <4, 8> | %c2 = i8 4;
128:4| 3: <4, 6> | %c3 = i8 3;
131:0| 3: <1, 1> | float:
133:4| 3: <6, 1065353216> | %c4 = float 1;
139:6| 0: <65534> | }
.. _link_for_undefined_literal:
Undefined Literal
-----------------
The *undefined* literal record creates an undefined literal for the type *T*
defined by the preceding *set type* record.
Note: See :ref:`insert element
instruction<link_for_insert_element_instruction_section>` for an example of how
you would use the undefined literal with vector types.
**Syntax**::
%cN = T undef; <50>
**Record**::
AA: <3>
**Semantics**:
The *undefined* literal record creates an undefined literal constant ``%cN`` for
type ``T``. ``T`` must be the type defined by the preceding *set type* record,
and be a primitive value type or a vector type.
**Constraints**::
N == NumFcnConsts &
T == ConstantsSetType &
IsPrimitive(T) or IsVector(T)
**Updates**::
++NumFcnConsts;
TypeOf(%cN) = T;
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 5> | count 5;
50:4| 3: <7, 32> | @t0 = i32;
53:6| 3: <3> | @t1 = float;
55:4| 3: <2> | @t2 = void;
57:2| 3: <12, 4, 0> | @t3 = <4 x i32>;
60:4| 3: <21, 0, 2> | @t4 = void ();
63:6| 0: <65534> | }
...
106:4| 1: <65535, 11, 2> | constants { // BlockID = 11
116:0| 3: <1, 0> | i32:
118:4| 3: <3> | %c0 = i32 undef;
120:2| 3: <4, 2> | %c1 = i32 1;
122:6| 3: <1, 3> | <4 x i32>:
125:2| 3: <3> | %c2 = <4 x i32> undef;
127:0| 3: <1, 1> | float:
129:4| 3: <3> | %c3 = float undef;
131:2| 0: <65534> | }
.. _link_for_integer_literal:
Integer Literal
---------------
The *integer literal* record creates an integer literal for the integer type *T*
defined by the preceding *set type* record.
**Syntax**::
%cN = T V; <A>
**Record**::
AA: <4, VV>
**Semantics**:
The *integer literal* record creates an integer literal constant ``%cN`` for
type ``T``. ``T`` must be the type defined by the preceding *set type* record,
and an integer type. The literal ``V`` can be signed, but must be definable by
type ``T``.
**Constraints**::
N == NumFcnConsts &
T == ConstantsSetType &
VV == SignRotate(V) &
IsInteger(T)
**Updates**::
TypeOf(%cN) = T;
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 7> | count 7;
50:4| 3: <7, 8> | @t0 = i8;
53:0| 3: <7, 16> | @t1 = i16;
55:4| 3: <7, 32> | @t2 = i32;
58:6| 3: <7, 64> | @t3 = i64;
62:0| 3: <7, 1> | @t4 = i1;
64:4| 3: <2> | @t5 = void;
66:2| 3: <21, 0, 5> | @t6 = void ();
69:4| 0: <65534> | }
...
114:4| 1: <65535, 11, 2> | constants { // BlockID = 11
124:0| 3: <1, 0> | i8:
126:4| 3: <4, 2> | %c0 = i8 1;
129:0| 3: <4, 4> | %c1 = i8 2;
131:4| 3: <1, 1> | i16:
134:0| 3: <4, 6> | %c2 = i16 3;
136:4| 3: <4, 8> | %c3 = i16 4;
139:0| 3: <1, 2> | i32:
141:4| 3: <4, 10> | %c4 = i32 5;
144:0| 3: <4, 12> | %c5 = i32 6;
146:4| 3: <1, 3> | i64:
149:0| 3: <4, 3> | %c6 = i64 -1;
151:4| 3: <4, 5> | %c7 = i64 -2;
154:0| 3: <1, 4> | i1:
156:4| 3: <4, 3> | %c8 = i1 1;
159:0| 3: <4, 0> | %c9 = i1 0;
161:4| 0: <65534> | }
Floating Point Literal
----------------------
The *floating point literal* record creates a floating point literal for the
floating point type *T* defined by the preceding *set type* record.
**Syntax**::
%cN = T V; <A>
**Record**::
AA: <6, VV>
**Semantics**:
The *floating point literal* record creates a floating point literal constant
``%cN`` for type ``T``. ``T`` must the type type defined by the preceding *set
type* record, and be a floating point type. The literal ``V`` is the floating
value to be defined. The value ``VV`` if the corresponding IEEE unsigned integer
that defines value ``V``. That is, the literal ``VV`` must be a valid IEEE 754
32-bit (unsigned integer) value if ``T`` is ``float``, and a valid IEEE 754
64-bit (unsigned integer) value if ``T`` is ``double``.
**Constraints**::
N == NumFcnConsts
T == ConstantsSetType
IsFloat(T)
**Updates**::
TypeOf(%cN) = T;
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 4> | count 4;
50:4| 3: <3> | @t0 = float;
52:2| 3: <4> | @t1 = double;
54:0| 3: <2> | @t2 = void;
55:6| 3: <21, 0, 2> | @t3 = void ();
59:0| 0: <65534> | }
...
102:4| 1: <65535, 11, 2> | constants { // BlockID = 11
112:0| 3: <1, 0> | float:
114:4| 3: <6, 0> | %c0 = float 0;
117:0| 3: <6, 1065353216> | %c1 = float 1;
123:2| 3: <6, 1088421888> | %c2 = float 7;
130:2| 3: <6, 1090519040> | %c3 = float 8;
137:2| 3: <3> | %c4 = float undef;
139:0| 3: <6, 2143289344> | %c5 = float nan;
146:0| 3: <6, 2139095040> | %c6 = float inf;
153:0| 3: <6, 4286578688> | %c7 = float -inf;
160:0| 3: <1, 1> | double:
162:4| 3: <6, | %c8 = double 1;
| 4607182418800017408> |
174:0| 3: <6, 0> | %c9 = double 0;
176:4| 3: <6, | %c10 = double 5;
| 4617315517961601024> |
188:0| 3: <6, | %c11 = double 6;
| 4618441417868443648> |
199:4| 3: <6, | %c12 = double nan;
| 9221120237041090560> |
211:0| 3: <6, | %c13 = double inf;
| 9218868437227405312> |
222:4| 3: <6, | %c14 = double -inf;
| 18442240474082181120>|
234:0| 0: <65534> | }
.. _link_for_function_blocks_section:
Function Blocks
===============
A function block defines the implementation of a defined :ref:`function
address<link_for_function_address_section>`. 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.
A function implementation contains a list of basic blocks, forming the control
flow graph. Each *basic block* contains a list of instructions, and ends with a
:ref:`terminator instruction<link_for_terminator_instruction_section>`
(e.g. branch).
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.
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't be any branches to the entry block of a
function). Because the entry block has no predecessors, it also can't have any
:ref:`phi<link_for_phi_instruction_section>` instructions.
The parameters are implied by the type of the corresponding function
address. One parameter is defined for each argument of the function :ref:`type
signature<link_for_function_type>` of the corresponding :ref:`function
address<link_for_function_address_section>`.
The number of basic blocks is defined by the :ref:`count
record<link_for_basic_blocks_count>`. Each :ref:`terminator
instruction<link_for_terminator_instruction_section>` 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 ``%bN``, where ``N`` corresponds to the position of the basic block
within the function block.
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.
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.
Operands of instructions are defined using an :ref:`absolute
index<link_for_absolute_index_section>`. 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.
To save space in the encoded bitcode file, most operands are encoded using a
:ref:`relative index<link_for_relative_index>` value, rather than
:ref:`absolute<link_for_absolute_index_section>`. 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.
Note that instructions that can appear in a function block are defined in
sections :ref:`link_for_terminator_instruction_section`,
:ref:`link_for_integer_binary_instructions`,
:ref:`link_for_floating_point_binary_instructions`,
:ref:`link_for_memory_creation_and_access_instructions`,
:ref:`link_for_conversion_instructions`, :ref:`link_for_compare_instructions`,
:ref:`link_for_vector_instructions`, and
:ref:`link_for_other_pnaclasm_instructions`.
The following subsections define the remaining records that can appear in a
function block.
Function Enter
--------------
PNaClAsm defines a function enter block construct. The corresponding record is
simply an :ref:`enter block<link_for_enter_block_record_section>` record, with
BlockID value ``12``. All context about the defining address is implicit by the
position of the function block, and the corresponding defining :ref:`function
address<link_for_function_address_section>`. To improve readability, PNaClAsm
includes the function signature into the syntax rule.
**Syntax**::
function TR @fN ( T0 %p0, ... , TM %pM ) { <B>
**Record**::
1: <65535, 12, B>
**Semantics**:
``B`` is the number of bits reserved for abbreviations in the block. If it is
omitted, 2 is assumed. See :ref:`enter<link_for_enter_block_record_section>`
block records for more details.
The value of ``N`` corresponds to the positional index of the corresponding
defining function address this block is associated with. ``M`` is the number of
defined parameters (minus one) in the function heading.
**Constraints**::
N == NumFcnImpls &
@fN in DefiningFcnIDs &
TypeOfFcn(@fN) == TypeOf(TypeID(TR (T0, ... , TM)))
**Updates**::
++NumFcnImpls;
EnclosingFcnID = @fN;
NumBasicBlocks = 0;
ExpectedBlocks = 0;
NumParams = M;
for I in [0..M]:
TypeOf(%pI) = TypeOf(TypeID(TI));
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 4> | count 4;
50:4| 3: <7, 32> | @t0 = i32;
53:6| 3: <2> | @t1 = void;
55:4| 3: <21, 0, 1> | @t2 = void ();
58:6| 3: <21, 0, 0, 0> | @t3 = i32 (i32);
62:6| 0: <65534> | }
...
104:0| 1: <65535, 12, 2> | function void @f0() {
| | // BlockID = 12
112:0| 3: <1, 1> | blocks 1;
| | %b0:
114:4| 3: <10> | ret void;
116:2| 0: <65534> | }
120:0| 1: <65535, 12, 2> | function i32 @f1(i32 %p0) {
| | // BlockID = 12
128:0| 3: <1, 1> | blocks 1;
| | %b0:
130:4| 3: <10, 1> | ret i32 %p0;
133:0| 0: <65534> | }
.. _link_for_basic_blocks_count:
Count Record
------------
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.
**Syntax**::
blocks: N; <A>
%b0:
**Record**::
AA: <1, N>
**Semantics**:
The count record defines the number ``N`` of basic blocks in the implemented
function.
**Constraints**::
AA == AbbrevIndex(A) &
ExpectedBasicBlocks == N &
NumBasicBlocks == 0
**Updates**::
104:0| 1: <65535, 12, 2> | function void @f0() {
| | // BlockID = 12
112:0| 3: <1, 1> | blocks 1;
| | %b0:
114:4| 3: <10> | ret void;
116:2| 0: <65534> | }
120:0| 1: <65535, 12, 2> | function i32 @f1(i32 %p0) {
| | // BlockID = 12
128:0| 3: <1, 1> | blocks 1;
| | %b0:
130:4| 3: <10, 1> | ret i32 %p0;
133:0| 0: <65534> | }
.. _link_for_terminator_instruction_section:
Terminator Instructions
=======================
Terminator instructions are instructions that appear in a :ref:`function
block<link_for_function_blocks_section>`, 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 :ref:`count
record<link_for_basic_blocks_count>`.
Note that any branch instruction to label ``%bN``, where ``N >=
ExpectedBasicBlocks``, is illegal. For ease of readability, this constraint
hasn't been put on branch instructions. Rather it is only implied.
In addition, it must be the case that ``NumBasicBlocks < ExpectedBasicBlocks``,
and will not be listed as a constraint. Further, if ``B = NumBasicBlocks + 1``
is the number associated with the next basic block. Label `%bB:` only appears
if::
B < ExpectedBasicBlocks
That is, the label is omitted only if this terminator instruction is the last
instruction in the function block.
Return Void Instruction
-----------------------
The return void instruction is used to return control from a function back to
the caller, without returning any value.
**Syntax**::
ret void; <A>
%bB:
**Record**::
AA: <10>
**Semantics**:
The return void instruction returns control to the calling function.
**Constraints**::
AA == AbbrevIndex(A) &
B == NumBasicBlocks + 1 &
ReturnType(TypeOf(EnclosingFcnID)) == void
**Updates**::
++NumBasicBlocks;
**Examples**::
104:0| 1: <65535, 12, 2> | function void @f0() {
| | // BlockID = 12
112:0| 3: <1, 1> | blocks 1;
| | %b0:
114:4| 3: <10> | ret void;
116:2| 0: <65534> | }
Return Value Instruction
------------------------
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.
**Syntax**::
ret T V; <A>
%bB:
**Record**::
AA: <10, VV>
**Semantics**:
The return value instruction returns control to the calling function, returning
the provided value.
``V`` is the value to return. Type ``T`` must be of the type returned by the
function. It must also be the type associated with value ``V``.
The return type ``T`` 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 ``i32`` or ``i64``.
**Constraints**::
AA == AbbrevIndex(A) &
VV == RelativeIndex(V) &
B == NumBasicBlocks + 1 &
T == TypeOf(V) == ReturnType(TypeOf(EnclosingFcnID))
**Updates**::
++NumBasicBlocks;
**Examples**::
120:0| 1: <65535, 12, 2> | function i32 @f1(i32 %p0) {
| | // BlockID = 12
128:0| 3: <1, 1> | blocks 1;
| | %b0:
130:4| 3: <10, 1> | ret i32 %p0;
Unconditional Branch Instruction
--------------------------------
The unconditional branch instruction is used to cause control flow to transfer
to a different basic block of the function.
**Syntax**::
br %bN; <A>
%bB:
**Record**::
AA: <11, N>
**Semantics**:
The unconditional branch instruction causes control flow to transfer to basic
block ``N``.
**Constraints**::
AA == AbbrevIndex(A) &
B == NumBasicBlocks + 1 &
0 < N &
N < ExpectedBasicBlocks
**Updates**::
++NumBasicBlocks;
**Examples**::
88:0| 1: <65535, 12, 2> | function void @f0() {
| | // BlockID = 12
96:0| 3: <1, 5> | blocks 5;
| | %b0:
98:4| 3: <11, 3> | br label %b3;
| | %b1:
101:0| 3: <11, 4> | br label %b4;
| | %b2:
103:4| 3: <11, 1> | br label %b1;
| | %b3:
106:0| 3: <11, 2> | br label %b2;
| | %b4:
108:4| 3: <10> | ret void;
110:2| 0: <65534> | }
Conditional Branch Instruction
------------------------------
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.
**Syntax**::
br i1 C, %bT, %bBF; <A>
%bB:
**Record**::
AA: <11, T, F, CC>
**Semantics**:
Upon execution of a conditional branch instruction, the *i1* (boolean) argument
``C`` is evaluated. If the value is ``true``, control flows to basic block
``%bT``. Otherwise control flows to basic block ``%bF``.
**Constraints**::
AA == AbbrevIndex(A) &
CC == RelativeIndex(C) &
B == NumBasicBlocks + 1 &
0 < T &
B1 < ExpectedBasicBlocks &
0 < F &
B2 < ExpectedBasicBlocks &
TypeOf(C) == i1
**Updates**::
++NumBasicBlocks;
**Examples**::
92:0| 1: <65535, 12, 2> | function void @f0() {
| | // BlockID = 12
100:0| 3: <1, 5> | blocks 5;
102:4| 1: <65535, 11, 2> | constants { // BlockID = 11
112:0| 3: <1, 1> | i1:
114:4| 3: <4, 3> | %c0 = i1 1;
117:0| 3: <4, 0> | %c1 = i1 0;
119:4| 0: <65534> | }
| | %b0:
120:0| 3: <11, 3> | br label %b3;
| | %b1:
122:4| 3: <11, 2, 4, 2> | br i1 %c0, label %b2, label %b4;
| | %b2:
126:4| 3: <11, 3> | br label %b3;
| | %b3:
129:0| 3: <10> | ret void;
| | %b4:
130:6| 3: <11, 2, 3, 1> | br i1 %c1, label %b2, label %b3;
134:6| 0: <65534> | }
Unreachable
-----------
The unreachable instruction has no defined semantics. The instruction is used to
inform the :ref:`PNaCl translator<link_for_pnacl_translator>` that control
can't reach this instruction.
**Syntax**::
unreachable; <A>
%bB:
**Record**::
AA: <15>
**Semantics**:
Directive to the :ref:`PNaCl translator<link_for_pnacl_translator>` that
this instruction is unreachable.
**Constraints**::
AA == AbbrevIndex(A)
B == NumBasicBlocks + 1 &
**Updates**::
++NumBasicBlocks;
**Examples**::
108:0| 1: <65535, 12, 2> | function void @f0(i32 %p0) {
| | // BlockID = 12
116:0| 3: <1, 5> | blocks 5;
118:4| 1: <65535, 11, 2> | constants { // BlockID = 11
128:0| 3: <1, 2> | i1:
130:4| 3: <4, 3> | %c0 = i1 1;
133:0| 3: <4, 0> | %c1 = i1 0;
135:4| 0: <65534> | }
| | %b0:
136:0| 3: <11, 1, 2, 2> | br i1 %c0, label %b1, label %b2;
| | %b1:
140:0| 3: <11, 3, 4, 1> | br i1 %c1, label %b3, label %b4;
| | %b2:
144:0| 3: <15> | unreachable;
| | %b3:
145:6| 3: <15> | unreachable;
| | %b4:
147:4| 3: <10> | ret void;
149:2| 0: <65534> | }
Switch Instruction
------------------
The *switch* instruction transfers control flow to one of several different
places, based on a selector value. It is a generalization of the conditional
branch instruction.
**Syntax**::
switch T V0 {
default: br label %bB0;
T V1: br label %bB1;
...
T VN: br label %bBN;
} <A>
%bB:
**Record**::
AA: <12, TT, B0, N, (1, 1, VVI, BI | 1 <= i <= N)>
**Semantics**:
The switch instruction transfers control to a basic block in ``B0`` through
``BN``. Value ``V`` is used to conditionally select which block to branch
to. ``T`` is the type of ``V`` and ``V1`` through ``VN``, and must be an integer
type. Value ``V1`` through ``VN`` are integers to compare against ``V``. If
selector ``V`` matches ``VI`` (for some ``I``, ``1 <= I <= N``), then the
instruction branches to block ``BI``. If ``V`` is not in ``V1`` through ``VN``,
the instruction branches to block ``B0``.
**Constraints**::
AA == AbbrevIndex(A) &
B == NumBasicBlocks + 1 &
TT == TypeID(T) &
VI == SignRotate(VI) for all I, 1 <= I <= N &
**Updates**::
++NumBasicBlocks;
**Examples**::
116:0| 1: <65535, 12, 2> | function void @f0(i32 %p0) {
| | // BlockID = 12
124:0| 3: <1, 6> | blocks 6;
| | %b0:
126:4| 3: <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>| i32 1: br label %b3;
| | i32 2: br label %b3;
| | i32 4: br label %b4;
| | i32 5: br label %b4;
| | }
| | %b1:
143:2| 3: <11, 5> | br label %b5;
| | %b2:
145:6| 3: <11, 5> | br label %b5;
| | %b3:
148:2| 3: <11, 5> | br label %b5;
| | %b4:
150:6| 3: <11, 5> | br label %b5;
| | %b5:
153:2| 3: <10> | ret void;
155:0| 0: <65534> | }
156:0| 1: <65535, 12, 2> | function void @f1(i64 %p0) {
| | // BlockID = 12
164:0| 3: <1, 6> | blocks 6;
| | %b0:
166:4| 3: <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> | i64 2: br label %b3;
| | i64 4: br label %b4;
| | i64 19888777666: br label %b4;
| | }
| | %b1:
188:4| 3: <11, 5> | br label %b5;
| | %b2:
191:0| 3: <11, 5> | br label %b5;
| | %b3:
193:4| 3: <11, 5> | br label %b5;
| | %b4:
196:0| 3: <11, 5> | br label %b5;
| | %b5:
198:4| 3: <10> | ret void;
200:2| 0: <65534> | }
.. _link_for_integer_binary_instructions:
Integer Binary Instructions
===========================
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.
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.
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.
For most binary operations (except some of the logical operations), integer
type i1 is disallowed.
Integer Add
-----------
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.
**Syntax**::
%vN = add T V1, V2; <A>
**Record**::
AA: <2, VV1, VV2, 0>
**Semantics**:
The integer add instruction returns the sum of its two arguments. Arguments
``V1`` and ``V2``, and the result ``%vN``, must be of type ``T``. ``T`` must be
an integer type, or an integer vector type. ``N`` is defined by the record
position, defining the corresponding value generated by the instruction.
The result returned is the mathematical result modulo 2\ :sup:`n`\ , where ``n``
is the bit width of the integer result.
Because integers are assumed to use a two's complement representation,
this instruction is appropriate for both signed and unsigned integers.
In the add instruction, integer type ``i1`` (and a vector of integer type
``i1``) is disallowed.
**Constraints**::
AA == AbbrevIndex(A) &
VV1 == RelativeIndex(V1) &
VV2 == RelativeIndex(V2) &
T == TypeOf(V1) == TypeOf(V2) &
IsInteger(UnderlyingType(T)) &
UnderlyingType(T) != i1 &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T
**Examples**::
96:0| 1: <65535, 12, 2> | function i32 @f0(i32 %p0, i32 %p1) {
| | // BlockID = 12
104:0| 3: <1, 1> | blocks 1;
| | %b0:
106:4| 3: <2, 2, 1, 0> | %v0 = add i32 %p0, %p1;
110:4| 3: <2, 3, 1, 0> | %v1 = add i32 %p0, %v0;
114:4| 3: <10, 1> | ret i32 %v1;
117:0| 0: <65534> | }
Integer Subtract
----------------
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.
Note: Since there isn't a negate instruction, subtraction from constant zero
should be used to negate values.
**Syntax**::
%vN = sub T V1, V2; <A>
**Record**::
AA: <2, VV1, VV2, 1>
**Semantics**:
The integer subtract returns the difference of its two arguments. Arguments
``V1`` and ``V2``, and the result ``%vN`` must be of type ``T``. ``T`` must be
an integer type, or an integer vector type. ``N`` is defined by the record
position, defining the corresponding value generated by the instruction.
The result returned is the mathematical result modulo 2\ :sup:`n`\ , where ``n``
is the bit width of the integer result.
Because integers are assumed to use a two's complement representation,
this instruction is appropriate for both signed and unsigned integers.
In the subtract instruction, integer type ``i1`` (and a vector of integer type
``i1``) is disallowed.
**Constraints**::
AA == AbbrevIndex(A) &
VV1 == RelativeIndex(V1) &
VV2 == RelativeIndex(V2) &
T == TypeOf(V1) == TypeOf(V2) &
IsInteger(UnderlyingType(T)) &
UnderlyingType(T) != i1 &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T
**Examples**::
96:0| 1: <65535, 12, 2> | function i32 @f0(i32 %p0, i32 %p1) {
| | // BlockID = 12
104:0| 3: <1, 1> | blocks 1;
| | %b0:
106:4| 3: <2, 2, 1, 1> | %v0 = sub i32 %p0, %p1;
110:4| 3: <2, 3, 1, 1> | %v1 = sub i32 %p0, %v0;
114:4| 3: <10, 1> | ret i32 %v1;
117:0| 0: <65534> | }
Integer Multiply
----------------
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.
**Syntax**::
&vN = mul T V1, V2; <A>
**Record**::
AA: <2, VV1, VV2, 2>
**Semantics**:
The integer multiply instruction returns the product of its two
arguments. Arguments ``V1`` and ``V2``, and the result ``%vN``, must be of type
``T``. ``T`` must be an integer type, or an integer vector type. ``N`` is
defined by the record position, defining the corresponding value generated by
the instruction.
The result returned is the mathematical result modulo 2\ :sup:`n`\ , where ``n``
is the bit width of the integer result.
Because integers are assumed to use a two's complement representation,
this instruction is appropriate for both signed and unsigned integers.
In the subtract instruction, integer type ``i1`` (or a vector on integer type
``i1``) is disallowed.
**Constraints**::
AA == AbbrevIndex(A) &
VV1 == RelativeIndex(V1) &
VV2 == RelativeIndex(V2) &
T == TypeOf(V1) == TypeOf(V2) &
IsInteger(UnderlyingType(T)) &
UnderlyingType(T) != i1 &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T
**Examples**::
96:0| 1: <65535, 12, 2> | function i32 @f0(i32 %p0, i32 %p1) {
| | // BlockID = 12
104:0| 3: <1, 1> | blocks 1;
| | %b0:
106:4| 3: <2, 2, 1, 2> | %v0 = mul i32 %p0, %p1;
110:4| 3: <2, 1, 3, 2> | %v1 = mul i32 %v0, %p0;
114:4| 3: <10, 1> | ret i32 %v1;
117:0| 0: <65534> | }
Signed Integer Divide
---------------------
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.
**Syntax**::
%vN = sdiv T V1, V2; <A>
**Record**::
AA: <2, VV1, VV2, 4>
**Semantics**:
The signed integer divide instruction returns the quotient of its two
arguments. Arguments ``V1`` and ``V2``, and the result ``%vN``, must be of type
``T``. ``T`` must be a integer type, or an integer vector type. ``N`` is defined
by the record position, defining the corresponding value generated by the
instruction.
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).
In the signed integer divide instruction, integer type ``i1`` (and a vector of
integer type ``i1``) is disallowed. Integer division by zero is guaranteed to
trap.
Note that overflow can happen with this instruction when dividing the maximum
negative integer by ``-1``. The behavior for this case is currently undefined.
**Constraints**::
AA == AbbrevIndex(A) &
VV1 == RelativeIndex(V1) &
VV2 == RelativeIndex(V2) &
T == TypeOf(V1) == TypeOf(V2) &
IsInteger(UnderlyingType(T)) &
UnderlyingType(T) != i1 &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T
**Examples**::
96:0| 1: <65535, 12, 2> | function i32 @f0(i32 %p0, i32 %p1) {
| | // BlockID = 12
104:0| 3: <1, 1> | blocks 1;
| | %b0:
106:4| 3: <2, 2, 1, 4> | %v0 = sdiv i32 %p0, %p1;
110:4| 3: <2, 1, 2, 4> | %v1 = sdiv i32 %v0, %p1;
114:4| 3: <10, 1> | ret i32 %v1;
117:0| 0: <65534> | }
Unsigned Integer Divide
-----------------------
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.
**Syntax**::
%vN = udiv T V1, V2; <a>
**Record**::
AA: <2, A1, A2, 3>
**Semantics**:
The unsigned integer divide instruction returns the quotient of its two
arguments. Arguments ``V1`` and ``V2``, and the result ``%vN``, must be of type
``T``. ``T`` must be an integer type, or an integer vector type. ``N`` is
defined by the record position, defining the corresponding value generated by
the instruction.
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).
In the unsigned integer divide instruction, integer type ``i1`` (and a vector of
integer type ``i1``) is disallowed. Division by zero is guaranteed to trap.
**Constraints**::
AA == AbbrevIndex(A) &
VV1 == RelativeIndex(V1) &
VV2 == RelativeIndex(V2) &
T == TypeOf(V1) == TypeOf(V2) &
IsInteger(UnderlyingType(T)) &
UnderlyingType(T) != i1 &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T
**Examples**::
96:0| 1: <65535, 12, 2> | function i32 @f0(i32 %p0, i32 %p1) {
| | // BlockID = 12
104:0| 3: <1, 1> | blocks 1;
| | %b0:
106:4| 3: <2, 2, 1, 3> | %v0 = udiv i32 %p0, %p1;
110:4| 3: <2, 1, 2, 3> | %v1 = udiv i32 %v0, %p1;
114:4| 3: <10, 1> | ret i32 %v1;
117:0| 0: <65534> | }
Signed Integer Remainder
------------------------
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.
**Syntax**::
%vN = srem T V1, V2; <A>
**Record**::
AA: <2, VV1, VV2, 6>
**Semantics**:
The signed integer remainder instruction returns the remainder of the quotient
of its two arguments. Arguments ``V1`` and ``V2``, and the result ``%vN``, must
be of type ``T``. ``T`` must be a integer type, or an integer vector type. ``N``
is defined by the record position, defining the corresponding value generated by
the instruction.
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).
In the signed integer remainder instruction, integer type ``i1`` (and a vector
of integer type ``i1``) is disallowed. Division by zero is guaranteed to trap.
Note that overflow can happen with this instruction when dividing the maximum
negative integer by ``-1``. The behavior for this case is currently undefined.
**Constraints**::
AA == AbbrevIndex(A) &
VV1 == RelativeIndex(V1) &
VV2 == RelativeIndex(V2) &
T == TypeOf(V1) == TypeOf(V2) &
IsInteger(UnderlyingType(T)) &
UnderlyingType(T) != i1 &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T
**Examples**::
96:0| 1: <65535, 12, 2> | function i32 @f0(i32 %p0, i32 %p1) {
| | // BlockID = 12
104:0| 3: <1, 1> | blocks 1;
| | %b0:
106:4| 3: <2, 2, 1, 6> | %v0 = srem i32 %p0, %p1;
110:4| 3: <2, 1, 2, 6> | %v1 = srem i32 %v0, %p1;
114:4| 3: <10, 1> | ret i32 %v1;
117:0| 0: <65534> | }
Unsigned Integer Remainder Instruction
--------------------------------------
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.
**Syntax**::
%vN = urem T V1, V2; <A>
**Record**::
AA: <2, A1, A2, 5>
**Semantics**:
The unsigned integer remainder instruction returns the remainder of the quotient
of its two arguments. Arguments ``V1`` and ``V2``, and the result ``%vN``, must
be of type ``T``. ``T`` must be an integer type, or an integer vector type.
``N`` is defined by the record position, defining the corresponding value
generated by the instruction.
Unsigned values are assumed. Note that signed and unsigned integer division are
distinct operations. For signed integer division use the remainder instruction
(srem).
In the unsigned integer remainder instruction, integer type ``i1`` (and a vector
of integer type ``i1``) is disallowed. Division by zero is guaranteed to trap.
**Constraints**::
AA == AbbrevIndex(A) &
VV1 == RelativeIndex(V1) &
VV2 == RelativeIndex(V2) &
T == TypeOf(V1) == TypeOf(V2) &
IsInteger(UnderlyingType(T)) &
UnderlyingType(T) != i1 &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T
**Examples**::
96:0| 1: <65535, 12, 2> | function i32 @f0(i32 %p0, i32 %p1) {
| | // BlockID = 12
104:0| 3: <1, 1> | blocks 1;
| | %b0:
106:4| 3: <2, 2, 1, 5> | %v0 = urem i32 %p0, %p1;
110:4| 3: <2, 1, 2, 5> | %v1 = urem i32 %v0, %p1;
114:4| 3: <10, 1> | ret i32 %v1;
117:0| 0: <65534> | }
Shift Left
----------
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.
**Syntax**::
%vN = shl T V1, V2; <A>
**Record**::
AA: <2, VV1, VV2, 7>
**Semantics**:
This instruction performs a shift left operation. Arguments ``V1`` and ``V2``
and the result ``%vN`` must be of type ``T``. ``T`` must be an integer, or a
vector of integers. ``N`` is defined by the record position, defining the
corresponding value generated by the instruction.
``V2`` is assumed to be unsigned. The least significant bits of the result will
be filled with zero bits after the shift. If ``V2`` is (statically or
dynamically) negative or equal to or larger than the number of bits in
``V1``, the result is undefined. If the arguments are vectors, each vector
element of ``V1`` is shifted by the corresponding shift amount in ``V2``.
In the shift left instruction, integer type ``i1`` (and a vector of integer type
``i1``) is disallowed.
**Constraints**::
AA == AbbrevIndex(A) &
VV1 == RelativeIndex(V1) &
VV2 == RelativeIndex(V2) &
T == TypeOf(V1) == TypeOf(V2) &
IsInteger(UnderlyingType(T)) &
UnderlyingType(T) != i1 &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T
**Examples**::
96:0| 1: <65535, 12, 2> | function i32 @f0(i32 %p0, i32 %p1) {
| | // BlockID = 12
104:0| 3: <1, 1> | blocks 1;
| | %b0:
106:4| 3: <2, 2, 1, 7> | %v0 = shl i32 %p0, %p1;
110:4| 3: <2, 1, 2, 7> | %v1 = shl i32 %v0, %p1;
114:4| 3: <10, 1> | ret i32 %v1;
117:0| 0: <65534> | }
Logical Shift Right
-------------------
The logical shift right instruction returns the first operand, shifted to the
right a specified number of bits with zero fill.
**Syntax**::
%vN = lshr T V1, V2; <A>
**Record**::
AA: <2, VV1, VV2, 8>
**Semantics**:
This instruction performs a logical shift right operation. Arguments ``V1`` and
``V2`` and the result ``%vN`` must be of type ``T``. ``T`` must be an integer,
or a vector of integers. ``N`` is defined by the record position, defining the
corresponding value generated by the instruction.
``V2`` is assumed to be unsigned. The most significant bits of the result will
be filled with zero bits after the shift. If ``V2`` is (statically or
dynamically) negative or equal to or larger than the number of bits in ``V1``,
the result is undefined. If the arguments are vectors, each vector element of
``V1`` is shifted by the corresponding shift amount in ``V2``.
In the logical shift right instruction, integer type ``i1`` (and a vector of
integer type ``i1``) is disallowed.
**Constraints**::
AA == AbbrevIndex(A) &
VV1 == RelativeIndex(V1) &
VV2 == RelativeIndex(V2) &
T == TypeOf(V1) == TypeOf(V2) &
IsInteger(UnderlyingType(T)) &
UnderlyingType(T) != i1 &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T
**Examples**::
96:0| 1: <65535, 12, 2> | function i32 @f0(i32 %p0, i32 %p1) {
| | // BlockID = 12
104:0| 3: <1, 1> | blocks 1;
| | %b0:
106:4| 3: <2, 2, 1, 8> | %v0 = lshr i32 %p0, %p1;
110:4| 3: <2, 1, 2, 8> | %v1 = lshr i32 %v0, %p1;
114:4| 3: <10, 1> | ret i32 %v1;
117:0| 0: <65534> | }
Arithmetic Shift Right
----------------------
The arithmetic shift right instruction returns the first operand, shifted to the
right a specified number of bits with sign extension.
**Syntax**::
%vN = ashr T V1, V2; <A>
**Record**::
AA: <2, VV1, VVA2, 9>
**Semantics**:
This instruction performs an arithmetic shift right operation. Arguments ``V1``
and ``V2`` and and the result ``%vN`` must be of type ``T``. ``T`` must be an
integer, or a vector of integers. ``N`` is defined by the record position,
defining the corresponding value generated by the instruction.
``V2`` is assumed to be unsigned. The most significant bits of the result will
be filled with the sign bit of ``V1``. If ``V2`` is (statically or dynamically)
negative or equal to or larger than the number of bits in ``V1``, the result is
undefined. If the arguments are vectors, each vector element of ``V1`` is
shifted by the corresponding shift amount in ``V2``.
In the arithmetic shift right instruction, integer type ``i1`` (and a vector of
integral type ``i1``) is disallowed.
**Constraints**::
AA == AbbrevIndex(A) &
VV1 == RelativeIndex(V1) &
VV2 == RelativeIndex(V2) &
T == TypeOf(V1) == TypeOf(V2) &
IsInteger(UnderlyingType(T)) &
UnderlyingType(T) != i1 &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T
**Examples**::
96:0| 1: <65535, 12, 2> | function i32 @f0(i32 %p0, i32 %p1) {
| | // BlockID = 12
104:0| 3: <1, 1> | blocks 1;
| | %b0:
106:4| 3: <2, 2, 1, 9> | %v0 = ashr i32 %p0, %p1;
110:4| 3: <2, 1, 2, 9> | %v1 = ashr i32 %v0, %p1;
114:4| 3: <10, 1> | ret i32 %v1;
117:0| 0: <65534> | }
Logical And
-----------
The *and* instruction returns the bitwise logical and of its two operands.
**Syntax**::
%vN = and T V1, V2; <A>
**Record**::
AA: <2, VV1, VV2, 10>
**Semantics**:
This instruction performs a bitwise logical and of its arguments. Arguments
``V1`` and ``V2``, and the result ``%vN`` must be of type ``T``. ``T`` must be
an integer, or a vector of integers. ``N`` is defined by the record position,
defining the corresponding value generated by the instruction. ``A`` is the
(optional) abbreviation associated with the corresponding record.
The truth table used for the *and* instruction is:
===== ===== ======
Arg 1 Arg 2 Result
===== ===== ======
0 0 0
0 1 0
1 0 0
1 1 1
===== ===== ======
**Constraints**::
AA == AbbrevIndex(A) &
VV1 == RelativeIndex(V1) &
VV2 == RelativeIndex(V2) &
T == TypeOf(V1) == TypeOf(V2) &
IsInteger(UnderlyingType(T))) &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T
**Examples**::
96:0| 1: <65535, 12, 2> | function i32 @f0(i32 %p0, i32 %p1) {
| | // BlockID = 12
104:0| 3: <1, 1> | blocks 1;
| | %b0:
106:4| 3: <2, 2, 1, 10> | %v0 = and i32 %p0, %p1;
110:4| 3: <2, 1, 2, 10> | %v1 = and i32 %v0, %p1;
114:4| 3: <10, 1> | ret i32 %v1;
117:0| 0: <65534> | }
Logical Or
----------
The *or* instruction returns the bitwise logical inclusive or of its
two operands.
**Syntax**::
%vN = or T V1, V2; <A>
**Record**::
AA: <2, VV1, VV2, 11>
**Semantics**:
This instruction performs a bitwise logical inclusive or of its arguments.
Arguments ``V1`` and ``V2``, and the result ``%vN`` must be of type ``T``. ``T``
must be an integer, or a vector of integers. ``N`` is defined by the record
position, defining the corresponding value generated by the instruction.
The truth table used for the *or* instruction is:
===== ===== ======
Arg 1 Arg 2 Result
===== ===== ======
0 0 0
0 1 1
1 0 1
1 1 1
===== ===== ======
**Constraints**::
AA == AbbrevIndex(A) &
VV1 == RelativeIndex(V1) &
VV2 == RelativeIndex(V2) &
T == TypeOf(V1) == TypeOf(V2) &
IsInteger(UnderlyingType(T))) &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T
**Examples**::
96:0| 1: <65535, 12, 2> | function i32 @f0(i32 %p0, i32 %p1) {
| | // BlockID = 12
104:0| 3: <1, 1> | blocks 1;
| | %b0:
106:4| 3: <2, 2, 1, 11> | %v0 = or i32 %p0, %p1;
110:4| 3: <2, 1, 2, 11> | %v1 = or i32 %v0, %p1;
114:4| 3: <10, 1> | ret i32 %v1;
117:0| 0: <65534> | }
Logical Xor
-----------
The *xor* instruction returns the bitwise logical exclusive or of its
two operands.
**Syntax**::
%vN = xor T V1, V2; <A>
**Record**::
AA: <2, VV1, VV2, 12>
**Semantics**:
This instruction performs a bitwise logical exclusive or of its arguments.
Arguments ``V1`` and ``V2``, and the result ``%vN`` must be of type ``T``. ``T``
must be an integer, or a vector of integers. ``N`` is defined by the record
position, defining the corresponding value generated by the instruction.
The truth table used for the *xor* instruction is:
===== ===== ======
Arg 1 Arg 2 Result
===== ===== ======
0 0 0
0 1 1
1 0 1
1 1 0
===== ===== ======
**Constraints**::
AA == AbbrevIndex(A) &
A1 == RelativeIndex(V1) &
A2 == RelativeIndex(V2) &
T == TypeOf(V1) == TypeOf(V2) &
IsInteger(UnderlyingType(T))) &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T
**Examples**::
96:0| 1: <65535, 12, 2> | function i32 @f0(i32 %p0, i32 %p1) {
| | // BlockID = 12
104:0| 3: <1, 1> | blocks 1;
| | %b0:
106:4| 3: <2, 2, 1, 12> | %v0 = xor i32 %p0, %p1;
110:4| 3: <2, 1, 2, 12> | %v1 = xor i32 %v0, %p1;
114:4| 3: <10, 1> | ret i32 %v1;
117:0| 0: <65534> | }
.. _link_for_floating_point_binary_instructions:
Floating Point Binary Instructions
==================================
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.
Floating Point Add
------------------
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.
**Syntax**::
%vN = fadd T V1, V2; <A>
**Record**::
AA: <2, VV1, VV2, 0>
**Semantics**:
The floating point add instruction returns the sum of its two arguments.
Arguments ``V1`` and ``V2`` and the result ``%vN`` must be of type ``T``. ``T``
must be a floating point type, or a vector of a floating point type. ``N`` is
defined by the record position, defining the corresponding value generated by
the instruction.
**Constraints**::
AA == AbbrevIndex(A) &
VV1 == RelativeIndex(V1) &
VV2 == RelativeIndex(V2) &
T == TypeOf(V1) == TypeOf(V2) &
IsFloat(UnderlyingType(T)) &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T
**Examples**::
92:0| 1: <65535, 12, 2> | function
| | float @f0(float %p0, float %p1) {
| | // BlockID = 12
100:0| 3: <1, 1> | blocks 1;
| | %b0:
102:4| 3: <2, 2, 1, 0> | %v0 = fadd float %p0, %p1;
106:4| 3: <2, 3, 1, 0> | %v1 = fadd float %p0, %v0;
110:4| 3: <10, 1> | ret float %v1;
113:0| 0: <65534> | }
Floating Point Subtract
-----------------------
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.
**Syntax**::
%vN = fsub T V1, V2; <a>
**Record**::
AA: <2, VV1, VV2, 1>
**Semantics**:
The floating point subtract instruction returns the difference of its two
arguments. Arguments ``V1`` and ``V2``, and the result ``%vN`` must be of type
``T``. ``T`` must be a floating point type, or a vector of a floating point
type. ``N`` is defined by the record position, defining the corresponding value
generated by the instruction.
**Constraints**::
AA == AbbrevIndex(A) &
VV1 == RelativeIndex(V1) &
VV2 == RelativeIndex(V2) &
T == TypeOf(V1) == TypeOf(V2) &
IsFloat(UnderlyingType(T)) &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T
**Examples**::
92:0| 1: <65535, 12, 2> | function
| | float @f0(float %p0, float %p1) {
| | // BlockID = 12
100:0| 3: <1, 1> | blocks 1;
| | %b0:
102:4| 3: <2, 2, 1, 1> | %v0 = fsub float %p0, %p1;
106:4| 3: <2, 3, 1, 1> | %v1 = fsub float %p0, %v0;
110:4| 3: <10, 1> | ret float %v1;
113:0| 0: <65534> | }
Floating Point Multiply
-----------------------
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.
**Syntax**::
&vN = fmul T V1, V2; <A>
**Record**::
AA: <2, VV1, VV2, 2>
**Semantics**:
The floating point multiply instruction returns the product of its two
arguments. Arguments ``V1`` and ``V2``, and the result ``%vN`` must be of type
``T``. ``T`` must be a floating point type, or a vector of a floating point
type. ``N`` is defined by the record position, defining the corresponding value
generated by the instruction.
**Constraints**::
AA == AbbrevIndex(A) &
VV1 == RelativeIndex(V1) &
VV2 == RelativeIndex(V2) &
T == TypeOf(V1) == TypeOf(V2) &
IsFloat(UnderlyingType(T)) &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T
**Examples**::
92:0| 1: <65535, 12, 2> | function
| | float @f0(float %p0, float %p1) {
| | // BlockID = 12
100:0| 3: <1, 1> | blocks 1;
| | %b0:
102:4| 3: <2, 2, 1, 2> | %v0 = fmul float %p0, %p1;
106:4| 3: <2, 3, 1, 2> | %v1 = fmul float %p0, %v0;
110:4| 3: <10, 1> | ret float %v1;
113:0| 0: <65534> | }
Floating Point Divide
---------------------
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.
**Syntax**::
%vN = fdiv T V1, V2; <A>
**Record**::
AA: <2, V1, V2, 4>
**Semantics**:
The floating point divide instruction returns the quotient of its two
arguments. Arguments ``V1`` and ``V2``, and the result ``%vN`` must be of type
``T``. ``T`` must be a floating point type, or a vector of a floating point
type. ``N`` is defined by the record position, defining the corresponding value
generated by the instruction.
**Constraints**::
AA == AbbrevIndex(A) &
VV1 == RelativeIndex(V1) &
VV22 == RelativeIndex(V2) &
T == TypeOf(V1) == TypeOf(V2) &
IsFloat(UnderlyingType(T)) &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T;
**Examples**::
92:0| 1: <65535, 12, 2> | function
| | double
| | @f0(double %p0, double %p1) {
| | // BlockID = 12
100:0| 3: <1, 1> | blocks 1;
| | %b0:
102:4| 3: <2, 2, 1, 4> | %v0 = fdiv double %p0, %p1;
106:4| 3: <2, 3, 1, 4> | %v1 = fdiv double %p0, %v0;
110:4| 3: <10, 1> | ret double %v1;
113:0| 0: <65534> | }
Floating Point Remainder
------------------------
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.
**Syntax**::
%vN = frem T V1, V2; <A>
**Record**::
AA: <2, VV1, VV2, 6>
**Semantics**:
The floating point remainder instruction returns the remainder of the quotient
of its two arguments. Arguments ``V1`` and ``V2``, and the result ``%vN`` must
be of type ``T``. ``T`` must be a floating point type, or a vector of a floating
point type. ``N`` is defined by the record position, defining the corresponding
value generated by the instruction.
**Constraints**::
AA == AbbrevIndex(A) &
VV1 == RelativeIndex(V1) &
VV2 == RelativeIndex(V2) &
T == TypeOf(V1) == TypeOf(V2) &
IsFloat(UnderlyingType(T)) &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T
**Examples**::
92:0| 1: <65535, 12, 2> | function
| | double
| | @f0(double %p0, double %p1) {
| | // BlockID = 12
100:0| 3: <1, 1> | blocks 1;
| | %b0:
102:4| 3: <2, 2, 1, 6> | %v0 = frem double %p0, %p1;
106:4| 3: <2, 3, 1, 6> | %v1 = frem double %p0, %v0;
110:4| 3: <10, 1> | ret double %v1;
113:0| 0: <65534> | }
.. _link_for_memory_creation_and_access_instructions:
Memory Creation and Access Instructions
=======================================
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.
.. _link_for_alloca_instruction:
Alloca Instruction
------------------
The *alloca* instruction allocates memory on the stack frame of the
currently executing function. This memory is automatically released
when the function returns to its caller.
**Syntax**::
%vN = alloca i8, i32 S, align V; <A>
**Record**::
AA: <19, SS, VV>
**Semantics**:
The *alloca* 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). ``S`` is the number of bytes that are allocated on the
stack. ``S`` must be of integer type i32. ``V`` is the alignment of the
generated stack address.
Alignment must be a power of 2. See :ref:`memory blocks and
alignment<link_for_memory_blocks_and_alignment_section>` for a more detailed
discussion on how to define alignment.
**Constraints**::
AA == AbbrevIndex(A) &
VV == Log2(V+1) &
SS == RelativeIndex(S) &
i32 == TypeOf(S) &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = i32;
**Examples**::
112:0| 1: <65535, 12, 2> | function void @f1() {
| | // BlockID = 12
120:0| 3: <1, 1> | blocks 1;
122:4| 1: <65535, 11, 2> | constants { // BlockID = 11
132:0| 3: <1, 0> | i32:
134:4| 3: <4, 4> | %c0 = i32 2;
137:0| 3: <4, 8> | %c1 = i32 4;
139:4| 3: <4, 16> | %c2 = i32 8;
142:0| 0: <65534> | }
| | %b0:
144:0| 3: <19, 3, 1> | %v0 = alloca i8, i32 %c0, align 1;
147:2| 3: <19, 3, 3> | %v1 = alloca i8, i32 %c1, align 4;
150:4| 3: <19, 3, 4> | %v2 = alloca i8, i32 %c2, align 8;
153:6| 3: <10> | ret void;
155:4| 0: <65534> | }
Load Instruction
----------------
The *load* instruction is used to read from memory.
**Syntax**::
%vN = load T* P, align V; <A>
**Record**::
AA: <20, PP, VV, TT>
**Semantics**:
The load instruction is used to read from memory. ``P`` is the identifier of the
memory address to read. The type of ``P`` must be an ``i32``. ``T`` is the type
of value to read. ``V`` is the alignment of the memory address.
Type ``T`` must be a vector, integer, or floating point type. Both ``float`` and
``double`` types are allowed for floating point types. All integer types except
i1 are allowed.
Alignment must be a power of 2. See :ref:`memory blocks and
alignment<link_for_memory_blocks_and_alignment_section>` for a more detailed
discussion on how to define alignment.
**Constraints**::
AA == AbbrevIndex(A) &
i32 == TypeOf(P) &
PP == RelativeIndex(P) &
VV == Log2(V+1) &
%tTT == TypeID(T) &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T;
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 4> | count 4;
50:4| 3: <7, 32> | @t0 = i32;
53:6| 3: <2> | @t1 = void;
55:4| 3: <4> | @t2 = double;
57:2| 3: <21, 0, 1, 0> | @t3 = void (i32);
61:2| 0: <65534> | }
...
96:0| 1: <65535, 12, 2> | function void @f0(i32 %p0) {
| | // BlockID = 12
104:0| 3: <1, 1> | blocks 1;
| | %b0:
106:4| 3: <20, 1, 1, 0> | %v0 = load i32* %p0, align 1;
110:4| 3: <20, 1, 4, 2> | %v1 = load double* %v0, align 8;
114:4| 3: <10> | ret void;
116:2| 0: <65534> | }
Store Instruction
-----------------
The *store* instruction is used to write to memory.
**Syntax**::
store T S, T* P, align V; <A>
**Record**::
AA: <24, PP, SS, VV>
**Semantics**:
The store instruction is used to write to memory. ``P`` is the identifier of the
memory address to write to. The type of ``P`` must be an i32 integer. ``T`` is
the type of value to store. ``S`` is the value to store, and must be of type
``T``. ``V`` is the alignment of the memory address. ``A`` is the (optional)
abbreviation index associated with the record.
Type ``T`` must be an integer or floating point type. Both ``float`` and
``double`` types are allowed for floating point types. All integer types except
i1 are allowed.
Alignment must be a power of 2. See :ref:`memory blocks and
alignment<link_for_memory_Blocks_and_alignment_section>` for a more detailed
discussion on how to define alignment.
**Constraints**::
AA == AbbrevIndex(A) &
i32 == TypeOf(P) &
PP == RelativeIndex(P) &
VV == Log2(V+1)
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 4> | count 4;
50:4| 3: <7, 32> | @t0 = i32;
53:6| 3: <2> | @t1 = void;
55:4| 3: <4> | @t2 = double;
57:2| 3: <21, 0, 1, 0, 0, 0, 2>| @t3 = void (i32, i32, i32, double);
63:4| 0: <65534> | }
...
96:0| 1: <65535, 12, 2> | function
| | void
| | @f0(i32 %p0, i32 %p1, i32 %p2,
| | double %p3) {
| | // BlockID = 12
104:0| 3: <1, 1> | blocks 1;
| | %b0:
106:4| 3: <24, 4, 3, 1> | store i32 %p1, i32* %p0, align 1;
110:4| 3: <24, 2, 1, 4> | store double %p3, double* %p2,
| | align 8;
114:4| 3: <10> | ret void;
116:2| 0: <65534> | }
.. _link_for_conversion_instructions:
Conversion Instructions
=======================
Conversion instructions all take a single operand and a type. The value is
converted to the corresponding type.
Integer Truncating Instruction
------------------------------
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.
**Syntax**::
%vN = trunc T1 V to T2; <A>
**Record**::
AA: <3, VV, TT2, 0>
**Semantics**:
The integer truncating instruction takes a value ``V``, and truncates to type
``T2``. Both ``T1`` and ``T2`` must be integer types, or integer vectors with
the same number of elements. ``T1`` has to be wider than ``T2``. If the value
doesn't fit in in ``T2``, then the higher order bits are dropped.
**Constraints**::
AA == AbbrevIndex(A) &
TypeOf(V) == T1 &
VV == RelativeIndex(V) &
%tTT2 == TypeID(T2) &
BitSizeOf(UnderlyingType(T1)) > BitSizeOf(UnderlyingType(T2)) &
UnderlyingCount(T1) == UnderlyingCount(T2) &
IsInteger(UnderlyingType(T1)) &
IsInteger(UnderlyingType(T2)) &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T2;
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 5> | count 5;
50:4| 3: <7, 32> | @t0 = i32;
53:6| 3: <2> | @t1 = void;
55:4| 3: <7, 16> | @t2 = i16;
58:0| 3: <21, 0, 1, 0> | @t3 = void (i32);
62:0| 3: <7, 8> | @t4 = i8;
64:4| 0: <65534> | }
...
100:0| 1: <65535, 12, 2> | function void @f0(i32 %p0) {
| | // BlockID = 12
108:0| 3: <1, 1> | blocks 1;
| | %b0:
110:4| 3: <3, 1, 2, 0> | %v0 = trunc i32 %p0 to i16;
114:4| 3: <3, 1, 4, 0> | %v1 = trunc i16 %v0 to i8;
118:4| 3: <10> | ret void;
120:2| 0: <65534> | }
Floating Point Truncating Instruction
--------------------------------------
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
``double`` while the destination is ``float``. If the source is a vector, the
destination must also be vector with the same size as the source.
**Syntax**::
%vN = fptrunc T1 V to T2; <A>
**Record**::
AA: <3, VV, TT2, 7>
**Semantics**
The floating point truncating instruction takes a value ``V``, and truncates to
type ``T2``. Both ``T1`` and ``T2`` must be floating point types, or floating
point vectors with the same number of elements. ``T1`` must be defined on
``double`` while ``T2`` is defined on ``float``. If the value can't fit within
the destination type ``T2``, the results are undefined.
**Constraints**::
TypeOf(V) == T1 &
double == UnderlyingType(T1) &
float == UnderlyingType(T2) &
VV == RelativeIndex(V) &
%tTT2 == TypeID(T2) &
BitSizeOf(UnderlyingType(T1)) > BitSizeOf(UnderlyingType(T2)) &
UnderlyingCount(T1) == UnderlyingCount(T2) &
IsFloat(UnderlyingType(T1)) &
IsFloat(UnderlyingType(T2)) &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T2;
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 4> | count 4;
50:4| 3: <3> | @t0 = float;
52:2| 3: <4> | @t1 = double;
54:0| 3: <21, 0, 0, 1> | @t2 = float (double);
58:0| 3: <2> | @t3 = void;
59:6| 0: <65534> | }
...
92:0| 1: <65535, 12, 2> | function float @f0(double %p0) {
| | // BlockID = 12
100:0| 3: <1, 1> | blocks 1;
| | %b0:
102:4| 3: <3, 1, 0, 7> | %v0 = fptrunc double %p0 to float;
106:4| 3: <10, 1> | ret float %v0;
109:0| 0: <65534> | }
Zero Extending Instruction
--------------------------
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.
**Syntax**::
%vN = zext T1 V to T2; <A>
**Record**::
AA: <3, VV, TT2, 1>
**Semantics**:
The zero extending instruction takes a value ``V``, and expands it to type
``T2``. Both ``T1`` and ``T2`` must be integer types, or integer vectors with
the same number of elements. ``T2`` must be wider than ``T1``.
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.
**Constraints**::
AA == AbbrevIndex(A) &
TypeOf(V) == T1 &
VV == RelativeIndex(V) &
%tTT2 == TypeID(T2) &
BitSizeOf(UnderlyingType(T1)) < BitSizeOf(UnderlyingType(T2)) &
UnderlyingCount(T1) == UnderlyingCount(T2) &
IsInteger(UnderlyingType(T1)) &
IsInteger(UnderlyingType(T2)) &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T2;
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 5> | count 5;
50:4| 3: <7, 64> | @t0 = i64;
53:6| 3: <7, 32> | @t1 = i32;
57:0| 3: <21, 0, 0> | @t2 = i64 ();
60:2| 3: <7, 8> | @t3 = i8;
62:6| 3: <2> | @t4 = void;
64:4| 0: <65534> | }
...
100:0| 1: <65535, 12, 2> | function i64 @f0() { // BlockID = 12
108:0| 3: <1, 1> | blocks 1;
110:4| 1: <65535, 11, 2> | constants { // BlockID = 11
120:0| 3: <1, 3> | i8:
122:4| 3: <4, 2> | %c0 = i8 1;
125:0| 0: <65534> | }
| | %b0:
128:0| 3: <3, 1, 1, 1> | %v0 = zext i8 %c0 to i32;
132:0| 3: <3, 1, 0, 1> | %v1 = zext i32 %v0 to i64;
136:0| 3: <10, 1> | ret i64 %v1;
138:4| 0: <65534> | }
Sign Extending Instruction
--------------------------
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.
**Syntax**::
%vN = sext T1 V to T2; <A>
**Record**::
AA: <3, VV, TT2, 2>
**Semantics**:
The sign extending instruction takes a value ``V``, and expands it to type
``T2``. Both ``T1`` and ``T2`` must be integer types, or integer vectors with
the same number of integers. ``T2`` has to be wider than ``T1``.
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.
**Constraints**::
AA == AbbrevIndex(A) &
TypeOf(V) == T1 &
VV == RelativeIndex(V) &
%tTT2 == TypeID(T2) &
BitSizeOf(UnderlyingType(T1)) < BitSizeOf(UnderlyingType(T2)) &
UnderlyingCount(T1) == UnderlyingCount(T2) &
IsInteger(UnderlyingType(T1)) &
IsInteger(UnderlyingType(T2)) &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T2;
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 5> | count 5;
50:4| 3: <7, 64> | @t0 = i64;
53:6| 3: <7, 32> | @t1 = i32;
57:0| 3: <21, 0, 0> | @t2 = i64 ();
60:2| 3: <7, 8> | @t3 = i8;
62:6| 3: <2> | @t4 = void;
64:4| 0: <65534> | }
...
100:0| 1: <65535, 12, 2> | function i64 @f0() { // BlockID = 12
108:0| 3: <1, 1> | blocks 1;
110:4| 1: <65535, 11, 2> | constants { // BlockID = 11
120:0| 3: <1, 3> | i8:
122:4| 3: <4, 3> | %c0 = i8 -1;
125:0| 0: <65534> | }
| | %b0:
128:0| 3: <3, 1, 1, 2> | %v0 = sext i8 %c0 to i32;
132:0| 3: <3, 1, 0, 2> | %v1 = sext i32 %v0 to i64;
136:0| 3: <10, 1> | ret i64 %v1;
138:4| 0: <65534> | }
Floating Point Extending Instruction
------------------------------------
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
``float`` while the destination is ``double``. If the source is a vector, the
destination must also be vector with the same size as the source.
**Syntax**::
%vN = fpext T1 V to T2; <A>
**Record**::
AA: <3, VV, TT2, 8>
**Semantics**:
The floating point extending instruction converts floating point values.
``V`` is the value to extend, and ``T2`` is the type to extend it
to. Both ``T1`` and ``T2`` must be floating point types, or floating point
vector types with the same number of floating point values. ``T1`` contains
``float`` while ``T2`` contains ``double``.
**Constraints**::
AA == AbbrevIndex(A) &
TypeOf(V) == T1 &
VV == RelativeIndex(V) &
%tTT2 == TypeID(T2) &
BitSizeOf(UnderlyingType(T1)) < BitSizeOf(UnderlyingType(T2)) &
UnderlyingCount(T1) == UnderlyingCount(T2) &
IsFloat(UnderlyingType(T1)) &
IsFloat(UnderlyingType(T2)) &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T2;
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 4> | count 4;
50:4| 3: <4> | @t0 = double;
52:2| 3: <3> | @t1 = float;
54:0| 3: <21, 0, 0, 1> | @t2 = double (float);
58:0| 3: <2> | @t3 = void;
59:6| 0: <65534> | }
...
92:0| 1: <65535, 12, 2> | function double @f0(float %p0) {
| | // BlockID = 12
100:0| 3: <1, 1> | blocks 1;
| | %b0:
102:4| 3: <3, 1, 0, 8> | %v0 = fpext float %p0 to double;
106:4| 3: <10, 1> | ret double %v0;
109:0| 0: <65534> | }
Floating Point to Unsigned Integer Instruction
----------------------------------------------
The floating point to unsigned integer instruction converts floating point
values to unsigned integers.
**Syntax**::
%vN = fptoui T1 V to T2; <A>
**Record**::
AA: <3, VV, TT2, 3>
**Semantics**:
The floating point to unsigned integer instruction converts floating point
value(s) in ``V`` to its unsigned integer equivalent of type ``T2``. ``T1`` must
be a floating point type, or a floating point vector type. ``T2`` 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.
**Constraints**::
AA == AbbrevIndex(A) &
TypeOf(V) == T1 &
VV == RelativeIndex(V) &
%tTT2 == TypeID(T2) &
UnderlyingCount(T1) == UnderlyingCount(T2) &
IsFloat(UnderlyingType(T1)) &
IsInteger(UnderlyingType(T2)) &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T2;
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 6> | count 6;
50:4| 3: <3> | @t0 = float;
52:2| 3: <4> | @t1 = double;
54:0| 3: <2> | @t2 = void;
55:6| 3: <21, 0, 2, 0, 1> | @t3 = void (float, double);
60:4| 3: <7, 32> | @t4 = i32;
63:6| 3: <7, 16> | @t5 = i16;
66:2| 0: <65534> | }
...
100:0| 1: <65535, 12, 2> | function
| | void @f0(float %p0, double %p1) {
| | // BlockID = 12
108:0| 3: <1, 1> | blocks 1;
| | %b0:
110:4| 3: <3, 2, 4, 3> | %v0 = fptoui float %p0 to i32;
114:4| 3: <3, 2, 5, 3> | %v1 = fptoui double %p1 to i16;
118:4| 3: <10> | ret void;
120:2| 0: <65534> | }
Floating Point to Signed Integer Instruction
--------------------------------------------
The floating point to signed integer instruction converts floating point
values to signed integers.
**Syntax**::
%vN = fptosi T1 V to T2; <A>
**Record**::
AA: <3, VV, TT2, 4>
**Semantics**:
The floating point to signed integer instruction converts floating point
value(s) in ``V`` to its signed integer equivalent of type ``T2``. ``T1`` must
be a floating point type, or a floating point vector type. ``T2`` 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.
**Constraints**::
AA == AbbrevIndex(A) &
TypeOf(V) == T1 &
VV == RelativeIndex(V) &
%tTT2 = TypeID(T2) &
UnderlyingCount(T1) = UnderlyingCount(T2) &
IsFloat(UnderlyingType(T1)) &
IsInteger(UnderlyingType(T2)) &
N = NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T2;
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 6> | count 6;
50:4| 3: <3> | @t0 = float;
52:2| 3: <4> | @t1 = double;
54:0| 3: <2> | @t2 = void;
55:6| 3: <21, 0, 2, 0, 1> | @t3 = void (float, double);
60:4| 3: <7, 8> | @t4 = i8;
63:0| 3: <7, 16> | @t5 = i16;
65:4| 0: <65534> | }
...
100:0| 1: <65535, 12, 2> | function
| | void @f0(float %p0, double %p1) {
| | // BlockID = 12
108:0| 3: <1, 1> | blocks 1;
| | %b0:
110:4| 3: <3, 2, 4, 4> | %v0 = fptosi float %p0 to i8;
114:4| 3: <3, 2, 5, 4> | %v1 = fptosi double %p1 to i16;
118:4| 3: <10> | ret void;
120:2| 0: <65534> | }
Unsigned Integer to Floating Point Instruction
----------------------------------------------
The unsigned integer to floating point instruction converts unsigned integers to
floating point values.
**Syntax**::
%vN = uitofp T1 V to T2; <A>
**Record**::
AA: <3, VV, TT2, 5>
**Semantics**:
The unsigned integer to floating point instruction converts unsigned integer(s)
to its floating point equivalent of type ``T2``. ``T1`` must be an integer type,
or a integer vector type. ``T2`` 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.
**Constraints**::
AA == AbbrevIndex(A) &
TypeOf(V) == T1 &
VV == RelativeIndex(V) &
%tTT2 = TypeID(T2) &
UnderlyingCount(T1) == UnderlyingCount(T2) &
IsInteger(UnderlyingType(T1)) &
IsFloat(UnderlyingType(T2)) &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) == T2;
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 7> | count 7;
50:4| 3: <7, 32> | @t0 = i32;
53:6| 3: <7, 64> | @t1 = i64;
57:0| 3: <2> | @t2 = void;
58:6| 3: <3> | @t3 = float;
60:4| 3: <21, 0, 2, 0, 1> | @t4 = void (i32, i64);
65:2| 3: <7, 1> | @t5 = i1;
67:6| 3: <4> | @t6 = double;
69:4| 0: <65534> | }
...
104:0| 1: <65535, 12, 2> | function void @f0(i32 %p0, i64 %p1) {
| | // BlockID = 12
112:0| 3: <1, 1> | blocks 1;
114:4| 1: <65535, 11, 2> | constants { // BlockID = 11
124:0| 3: <1, 5> | i1:
126:4| 3: <4, 3> | %c0 = i1 1;
129:0| 0: <65534> | }
| | %b0:
132:0| 3: <3, 1, 6, 5> | %v0 = uitofp i1 %c0 to double;
136:0| 3: <3, 4, 3, 5> | %v1 = uitofp i32 %p0 to float;
140:0| 3: <3, 4, 3, 5> | %v2 = uitofp i64 %p1 to float;
144:0| 3: <10> | ret void;
145:6| 0: <65534> | }
Signed Integer to Floating Point Instruction
--------------------------------------------
The signed integer to floating point instruction converts signed integers to
floating point values.
**Syntax**::
%vN = sitofp T1 V to T2; <A>
**Record**::
AA: <3, VV, TT2, 6>
**Semantics**:
The signed integer to floating point instruction converts signed integer(s) to
its floating point equivalent of type ``T2``. ``T1`` must be an integer type, or
a integer vector type. ``T2`` 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.
**Constraints**::
AA == AbbrevIndex(A) &
TypeOf(V) == T1 &
VV == RelativeIndex(V) &
%tTT2 = TypeID(T2) &
UnderlyingCount(T1) == UnderlyingCount(T2) &
IsInteger(UnderlyingType(T1)) &
IsFloat(UnderlyingType(T2)) &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T2;
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 7> | count 7;
50:4| 3: <7, 32> | @t0 = i32;
53:6| 3: <7, 64> | @t1 = i64;
57:0| 3: <2> | @t2 = void;
58:6| 3: <3> | @t3 = float;
60:4| 3: <21, 0, 2, 0, 1> | @t4 = void (i32, i64);
65:2| 3: <7, 8> | @t5 = i8;
67:6| 3: <4> | @t6 = double;
69:4| 0: <65534> | }
...
104:0| 1: <65535, 12, 2> | function void @f0(i32 %p0, i64 %p1) {
| | // BlockID = 12
112:0| 3: <1, 1> | blocks 1;
114:4| 1: <65535, 11, 2> | constants { // BlockID = 11
124:0| 3: <1, 5> | i8:
126:4| 3: <4, 3> | %c0 = i8 -1;
129:0| 0: <65534> | }
| | %b0:
132:0| 3: <3, 1, 6, 6> | %v0 = sitofp i8 %c0 to double;
136:0| 3: <3, 4, 3, 6> | %v1 = sitofp i32 %p0 to float;
140:0| 3: <3, 4, 3, 6> | %v2 = sitofp i64 %p1 to float;
144:0| 3: <10> | ret void;
145:6| 0: <65534> | }
Bitcast Instruction
-------------------
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.
**Syntax**::
%vN = bitcast T1 V to T2; <A>
**Record**::
AA: <3, VV, TT2, 11>
**Semantics**:
The bitcast instruction converts the type of value ``V`` to type ``T2``. ``T1``
and ``T2`` must be primitive types or vectors, and define the same number of
bits.
**Constraints**::
AA == AbbrevIndex(A) &
TypeOf(V) == T1 &
VV = RelativeIndex(V) &
%tTT2 = TypeID(T2) &
BitSizeOf(T1) == BitSizeOf(T2) &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T2;
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 6> | count 6;
50:4| 3: <3> | @t0 = float;
52:2| 3: <7, 64> | @t1 = i64;
55:4| 3: <2> | @t2 = void;
57:2| 3: <21, 0, 2, 0, 1> | @t3 = void (float, i64);
62:0| 3: <7, 32> | @t4 = i32;
65:2| 3: <4> | @t5 = double;
67:0| 0: <65534> | }
...
100:0| 1: <65535, 12, 2> | function void @f0(float %p0, i64 %p1)
| | { // BlockID = 12
108:0| 3: <1, 1> | blocks 1;
| | %b0:
110:4| 3: <3, 2, 4, 11> | %v0 = bitcast float %p0 to i32;
114:4| 3: <3, 2, 5, 11> | %v1 = bitcast i64 %p1 to double;
118:4| 3: <10> | ret void;
120:2| 0: <65534> | }
.. _link_for_compare_instructions:
Comparison Instructions
=======================
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.
Integer Comparison Instructions
-------------------------------
The integer comparison instruction compares integer values and returns a
boolean (i1) result for each pair of compared values.
**Syntax**::
%vN = icmp C T V1, V2; <A>
**Record**::
AA: <9, VV1, VV2, CC>
**Semantics**:
The integer comparison instruction compares integer values and returns a boolean
(i1) result for each pair of compared values in ``V1`` and ``V2``. ``V1`` and
``V2`` must be of type ``T``. ``T`` must be an integer type, or an integer
vector type. Condition code ``C`` is the condition applied to all elements in
``V1`` and ``V2``. Each comparison always yields an i1. If ``T`` is a primitive
type, the resulting type is i1. If ``T`` is a vector, then the resulting type is
a vector of i1 with the same size as ``T``.
Legal test conditions are:
=== == ==============================
C CC Operator
=== == ==============================
eq 32 equal
ne 33 not equal
ugt 34 unsigned greater than
uge 35 unsigned greater than or equal
ult 36 unsigned less than
ule 37 unsigned less than or equal
sgt 38 signed greater than
sge 39 signed greater than or equal
slt 40 signed less than
sle 41 signed less than or equal
=== == ==============================
**Constraints**::
AA == AbbrevIndex(A) &
IsInteger(UnderlyingType(T) &
T == TypeOf(V1) == TypeOf(V2) &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
if IsVector(T) then
TypeOf(%vN) = <UnderlyingCount(T), i1>
else
TypeOf(%vN) = i1
endif
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 4> | count 4;
50:4| 3: <7, 32> | @t0 = i32;
53:6| 3: <7, 1> | @t1 = i1;
56:2| 3: <2> | @t2 = void;
58:0| 3: <21, 0, 2> | @t3 = void ();
61:2| 0: <65534> | }
...
108:0| 1: <65535, 12, 2> | function void @f0() {
| | // BlockID = 12
116:0| 3: <1, 1> | blocks 1;
118:4| 1: <65535, 11, 2> | constants { // BlockID = 11
128:0| 3: <1, 0> | i32:
130:4| 3: <4, 0> | %c0 = i32 0;
133:0| 3: <4, 2> | %c1 = i32 1;
135:4| 0: <65534> | }
| | %b0:
136:0| 3: <28, 2, 1, 32> | %v0 = icmp eq i32 %c0, %c1;
140:6| 3: <28, 3, 2, 33> | %v1 = icmp ne i32 %c0, %c1;
145:4| 3: <28, 4, 3, 34> | %v2 = icmp ugt i32 %c0, %c1;
150:2| 3: <28, 5, 4, 36> | %v3 = icmp ult i32 %c0, %c1;
155:0| 3: <28, 6, 5, 37> | %v4 = icmp ule i32 %c0, %c1;
159:6| 3: <28, 7, 6, 38> | %v5 = icmp sgt i32 %c0, %c1;
164:4| 3: <28, 8, 7, 38> | %v6 = icmp sgt i32 %c0, %c1;
169:2| 3: <28, 9, 8, 39> | %v7 = icmp sge i32 %c0, %c1;
174:0| 3: <28, 10, 9, 40> | %v8 = icmp slt i32 %c0, %c1;
178:6| 3: <28, 11, 10, 41> | %v9 = icmp sle i32 %c0, %c1;
183:4| 3: <10> | ret void;
185:2| 0: <65534> | }
Floating Point Comparison Instructions
--------------------------------------
The floating point comparison instruction compares floating point values and
returns a boolean (i1) result for each pair of compared values.
**Syntax**::
%vN = fcmp C T V1, V2; <A>
**Record**::
AA: <9, VV1, VV2, CC>
**Semantics**:
The floating point comparison instruction compares floating point values and
returns a boolean (i1) result for each pair of compared values in ``V1`` and
``V2``. ``V1`` and ``V2`` must be of type ``T``. ``T`` must be a floating point
type, or a floating point vector type. Condition code ``C`` is the condition
applied to all elements in ``V1`` and ``V2``. Each comparison always yields an
i1. If ``T`` is a primitive type, the resulting type is i1. If ``T`` is a
vector, then the resulting type is a vector of i1 with the same size as ``T``.
Legal test conditions are:
===== == ==================================
C CC Operator
===== == ==================================
false 0 Always false
oeq 1 Ordered and equal
ogt 2 Ordered and greater than
oge 3 Ordered and greater than or equal
olt 4 Ordered and less than
ole 5 Ordered and less than or equal
one 6 Ordered and not equal
ord 7 Ordered (no NaNs)
uno 8 Unordered (either NaNs)
ueq 9 Unordered or equal
ugt 10 Unordered or greater than
uge 11 Unordered or greater than or equal
ult 12 Unordered or less than
ule 13 Unordered or less than or equal
une 14 Unordered or not equal
true 15 Always true
===== == ==================================
**Constraints**::
AA == AbbrevIndex(A) &
IsFloat(UnderlyingType(T) &
T == TypeOf(V1) == TypeOf(V2) &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
if IsVector(T) then
TypeOf(%vN) = <UnderlyingCount(T), i1>
else
TypeOf(%vN) = i1
endif
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 4> | count 4;
50:4| 3: <3> | @t0 = float;
52:2| 3: <7, 1> | @t1 = i1;
54:6| 3: <2> | @t2 = void;
56:4| 3: <21, 0, 2> | @t3 = void ();
59:6| 0: <65534> | }
...
108:0| 1: <65535, 12, 2> | function void @f0() {
| | // BlockID = 12
116:0| 3: <1, 1> | blocks 1;
118:4| 1: <65535, 11, 2> | constants { // BlockID = 11
128:0| 3: <1, 0> | float:
130:4| 3: <6, 0> | %c0 = float 0;
133:0| 3: <6, 1065353216> | %c1 = float 1;
139:2| 0: <65534> | }
| | %b0:
140:0| 3: <28, 2, 1, 0> | %v0 = fcmp false float %c0, %c1;
144:0| 3: <28, 3, 2, 1> | %v1 = fcmp oeq float %c0, %c1;
148:0| 3: <28, 4, 3, 2> | %v2 = fcmp ogt float %c0, %c1;
152:0| 3: <28, 5, 4, 3> | %v3 = fcmp oge float %c0, %c1;
156:0| 3: <28, 6, 5, 4> | %v4 = fcmp olt float %c0, %c1;
160:0| 3: <28, 7, 6, 5> | %v5 = fcmp ole float %c0, %c1;
164:0| 3: <28, 8, 7, 6> | %v6 = fcmp one float %c0, %c1;
168:0| 3: <28, 9, 8, 7> | %v7 = fcmp ord float %c0, %c1;
172:0| 3: <28, 10, 9, 9> | %v8 = fcmp ueq float %c0, %c1;
176:0| 3: <28, 11, 10, 10> | %v9 = fcmp ugt float %c0, %c1;
180:0| 3: <28, 12, 11, 11> | %v10 = fcmp uge float %c0, %c1;
184:0| 3: <28, 13, 12, 12> | %v11 = fcmp ult float %c0, %c1;
188:0| 3: <28, 14, 13, 13> | %v12 = fcmp ule float %c0, %c1;
192:0| 3: <28, 15, 14, 14> | %v13 = fcmp une float %c0, %c1;
196:0| 3: <28, 16, 15, 8> | %v14 = fcmp uno float %c0, %c1;
200:0| 3: <28, 17, 16, 15> | %v15 = fcmp true float %c0, %c1;
204:0| 3: <10> | ret void;
205:6| 0: <65534> | }
208:0|0: <65534> |}
.. _link_for_vector_instructions:
Vector Instructions
===================
PNaClAsm supports several instructions that process vectors. This includes the
:ref:`integer<link_for_integer_binary_instructions>` and :ref:`floating
point<link_for_floating_point_binary_instructions>` binary instructions as well
as :ref:`compare<link_for_compare_instructions>` instructions. These
instructions work with vectors and generate resulting (new) vectors. This
section introduces the instructions to construct vectors and extract results.
.. _link_for_insert_element_instruction_section:
Insert Element Instruction
--------------------------
The *insert element* instruction inserts a scalar value into a vector at a
specified index. The *insert element* instruction takes an existing vector and
puts a scalar value in one of the elements of the vector.
The *insert element* instruction can be used to construct a vector, one element
at a time. At first glance, it may appear that one can't construct a vector,
since the *insert element* instruction needs a vector to insert elements into.
The key to understanding vector construction is understand that one can create
an :ref:`undefined<link_for_undefined_literal>` vector literal. Using that
constant as a starting point, one can built up the wanted vector by a sequence
of *insert element* instructions.
**Syntax**::
%vN = insertelement TV V, TE E, i32 I; <A>
**Record**::
AA: <7, VV, EE, II>
**Semantics**:
The *insert element* instruction inserts scalar value ``E`` into index ``I`` of
vector ``V``. ``%vN`` holds the updated vector. Type ``TV`` is the type of
vector. It is also the type of updated vector ``%vN``. Type ``TE`` is the type
of scalar value ``E`` and must be the element type of vector ``V``. ``I`` must
be an :ref:`i32 literal<link_for_integer_literal>`.
If ``I`` exceeds the length of ``V``, the result is undefined.
**Constraints**::
AA == AbbrevIndex(A) &
IsVector(TV) &
TypeOf(V) == TV &
UnderlyingType(TV) == TE &
TypeOf(I) == i32 &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = TV;
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 5> | count 5;
50:4| 3: <7, 1> | @t0 = i1;
53:0| 3: <12, 4, 0> | @t1 = <4 x i1>;
56:2| 3: <7, 32> | @t2 = i32;
59:4| 3: <2> | @t3 = void;
61:2| 3: <21, 0, 3> | @t4 = void ();
64:4| 0: <65534> | }
...
116:0| 1: <65535, 12, 2> | function void @f0() {
| | // BlockID = 12
124:0| 3: <1, 1> | blocks 1;
126:4| 1: <65535, 11, 2> | constants { // BlockID = 11
136:0| 3: <1, 0> | i1:
138:4| 3: <4, 0> | %c0 = i1 0;
141:0| 3: <4, 3> | %c1 = i1 1;
143:4| 3: <1, 1> | <4 x i1>:
146:0| 3: <3> | %c2 = <4 x i1> undef;
147:6| 3: <1, 2> | i32:
150:2| 3: <4, 0> | %c3 = i32 0;
152:6| 3: <4, 2> | %c4 = i32 1;
155:2| 3: <4, 4> | %c5 = i32 2;
157:6| 3: <4, 6> | %c6 = i32 3;
160:2| 0: <65534> | }
| | %b0:
164:0| 3: <7, 5, 7, 4> | %v0 = insertelement <4 x i1> %c2,
| | i1 %c0, i32 %c3;
168:0| 3: <7, 1, 7, 4> | %v1 = insertelement <4 x i1> %v0,
| | i1 %c1, i32 %c4;
172:0| 3: <7, 1, 9, 4> | %v2 = insertelement <4 x i1> %v1,
| | i1 %c0, i32 %c5;
176:0| 3: <7, 1, 9, 4> | %v3 = insertelement <4 x i1> %v2,
| | i1 %c1, i32 %c6;
180:0| 3: <10> | ret void;
181:6| 0: <65534> | }
Extract Element Instruction
---------------------------
The *extract element* instruction extracts a single scalar value from a vector
at a specified index.
**Syntax**::
%vN = extractelement TV V, i32 I; <A>
**Record**::
AA: <6, VV, II>
**Semantics**:
The *extract element* instruction extracts the scalar value at index ``I`` from
vector ``V``. The extracted value is assigned to ``%vN``. Type ``TV`` is the
type of vector ``V``. ``I`` must be an :ref:`i32
literal<link_for_integer_literal>`. The type of ``vN`` must be the element type
of vector ``V``.
If ``I`` exceeds the length of ``V``, the result is undefined.
**Constraints**::
AA == AbbrevIndex(A) &
IsVector(TV) &
TypeOf(V) == TV &
TypeOf(I) == i32 &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = UnderlyingType(TV);
**Examples**::
96:0| 1: <65535, 12, 2> | function void @f0(<4 x i32> %p0) {
| | // BlockID = 12
104:0| 3: <1, 1> | blocks 1;
106:4| 1: <65535, 11, 2> | constants { // BlockID = 11
116:0| 3: <1, 0> | i32:
118:4| 3: <4, 0> | %c0 = i32 0;
121:0| 0: <65534> | }
| | %b0:
124:0| 3: <6, 2, 1> | %v0 =
| | extractelement <4 x i32> %p0,
| | i32 %c0;
127:2| 3: <10> | ret void;
129:0| 0: <65534> | }
.. _link_for_other_pnaclasm_instructions:
Other Instructions
==================
This section defines miscellaneous instructions which defy better
classification.
.. _link_for_forward_type_declaration_section:
Forward Type Declaration
------------------------
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't be defined before
they are used.
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.
**Syntax**::
declare T %vN; <A>
**Record**::
AA: <43, N, TT>
**Semantics**:
The forward declare type declaration defines the type to be associated with a
(not yet defined) instruction value ``%vN``. ``T`` is the type of the value
generated by the ``Nth`` value generating instruction in the function block.
Note: It is an error to define the type of ``%vN`` with a different type than
will be generated by the ``Nth`` value generating instruction in the function
block.
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 :ref:`phi<link_for_phi_instruction_section>`
instructions in a basic block.
**Constraints**::
AA = AbbrevIndex(A) &
TT = TypeID(T)
**Updates**::
TypeOf(%vN) = T;
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 4> | count 4;
50:4| 3: <7, 32> | @t0 = i32;
53:6| 3: <2> | @t1 = void;
55:4| 3: <7, 1> | @t2 = i1;
58:0| 3: <21, 0, 1, 0> | @t3 = void (i32);
62:0| 0: <65534> | }
...
108:0| 1: <65535, 12, 2> | function void @f0(i32 %p0) {
| | // BlockID = 12
116:0| 3: <1, 7> | blocks 7;
118:4| 1: <65535, 11, 2> | constants { // BlockID = 11
128:0| 3: <1, 2> | i1:
130:4| 3: <4, 3> | %c0 = i1 1;
133:0| 0: <65534> | }
| | %b0:
136:0| 3: <11, 4> | br label %b4;
| | %b1:
138:4| 3: <43, 6, 0> | declare i32 %v3;
142:4| 3: <2, 2, 4294967293, 0> | %v0 = add i32 %p0, %v3;
151:0| 3: <11, 6> | br label %b6;
| | %b2:
153:4| 3: <43, 7, 0> | declare i32 %v4;
157:4| 3: <2, 3, 4294967293, 0> | %v1 = add i32 %p0, %v4;
166:0| 3: <11, 6> | br label %b6;
| | %b3:
168:4| 3: <2, 4, 4294967295, 0> | %v2 = add i32 %p0, %v3;
177:0| 3: <11, 6> | br label %b6;
| | %b4:
179:4| 3: <2, 5, 5, 0> | %v3 = add i32 %p0, %p0;
183:4| 3: <11, 1, 5, 5> | br i1 %c0, label %b1, label %b5;
| | %b5:
187:4| 3: <2, 1, 6, 0> | %v4 = add i32 %v3, %p0;
191:4| 3: <11, 2, 3, 6> | br i1 %c0, label %b2, label %b3;
| | %b6:
195:4| 3: <10> | ret void;
197:2| 0: <65534> | }
.. _link_for_phi_instruction_section:
Phi Instruction
---------------
The *phi* 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 *phi* instruction.
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.
**Syntax**::
%vN = phi T [V1, %bB1], ... , [VM, %bBM]; <A>
**Record**::
AA: <16, TT, VV1, B1, ..., VVM, BM>
**Semantics**:
The phi instruction is used to implement phi nodes in the SSA graph representing
the function. ``%vN`` is the resulting value of the corresponding phi
node. ``T`` is the type of the phi node. Values ``V1`` through ``VM`` are the
reaching definitions for the phi node while ``%bB1`` through ``%bBM`` are the
corresponding predecessor blocks. Each ``VI`` reaches via the incoming
predecessor edge from block ``%bBI`` (for 1 <= I <= M). Type ``T`` must be the
type associated with each ``VI``.
**Constraints**::
AA == AbbrevIndex(A) &
M > 1 &
TT == TypeID(T) &
T = TypeOf(VI) for all I, 1 <= I <= M &
BI < ExpectedBasicBlocks for all I, 1 <= I <= M &
VVI = SignRotate(RelativeIndex(VI)) for all I, 1 <= I <= M &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T;
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 4> | count 4;
50:4| 3: <7, 32> | @t0 = i32;
53:6| 3: <2> | @t1 = void;
55:4| 3: <21, 0, 1> | @t2 = void ();
58:6| 3: <7, 1> | @t3 = i1;
61:2| 0: <65534> | }
...
112:0| 1: <65535, 12, 2> | function void @f0() {
| | // BlockID = 12
120:0| 3: <1, 4> | blocks 4;
122:4| 1: <65535, 11, 2> | constants { // BlockID = 11
132:0| 3: <1, 0> | i32:
134:4| 3: <4, 2> | %c0 = i32 1;
137:0| 3: <1, 3> | i1:
139:4| 3: <4, 0> | %c1 = i1 0;
142:0| 0: <65534> | }
| | %b0:
144:0| 3: <11, 1, 2, 1> | br i1 %c1, label %b1, label %b2;
| | %b1:
148:0| 3: <2, 2, 2, 0> | %v0 = add i32 %c0, %c0;
152:0| 3: <2, 3, 3, 1> | %v1 = sub i32 %c0, %c0;
156:0| 3: <11, 3> | br label %b3;
| | %b2:
158:4| 3: <2, 4, 4, 2> | %v2 = mul i32 %c0, %c0;
162:4| 3: <2, 5, 5, 3> | %v3 = udiv i32 %c0, %c0;
166:4| 3: <11, 3> | br label %b3;
| | %b3:
169:0| 3: <16, 0, 8, 1, 4, 2> | %v4 = phi i32 [%v0, %b1],
| | [%v2, %b2];
174:4| 3: <16, 0, 8, 1, 4, 2> | %v5 = phi i32 [%v1, %b1],
| | [%v3, %b2];
180:0| 3: <10> | ret void;
181:6| 0: <65534> | }
Select Instruction
------------------
The *select* instruction is used to choose between pairs of values, based on a
condition, without PNaClAsm-level branching.
**Syntax**::
%vN = select CT C, T V1, T V2; <A>
**Record**::
AA: <29, VV1, VV2, CC>
**Semantics**:
The *select* instruction chooses pairs of values ``V1`` and ``V2``, based on
condition value ``C``. The type ``CT`` of value ``C`` must either be an i1, or
a vector of type i1. The type of values ``V1`` and ``V2`` must be of type
``T``. Type ``T`` must either be a primitive type, or a vector of a primitive
type.
Both ``CT`` and ``T`` must be primitive types, or both must be vector types of
the same size. When the contents of ``C`` is 1, the corresponding value from
``V1`` will be chosen. Otherwise the corresponding value from ``V2`` will be
chosen.
**Constraints**::
AA == AbbrevIndex(A) &
CC == RelativeIndex(C) &
VV1 == RelativeIndex(V1) &
VV2 == RelativeIndex(V2) &
T == TypeOf(V1) == TypeOf(V2) &
UnderlyingType(CT) == i1 &
IsInteger(UnderlyingType(T)) or IsFloat(UnderlyingType(T)) &
UnderlyingCount(C) == UnderlyingCount(T) &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = T;
**Examples**::
96:0| 1: <65535, 12, 2> | function i32 @f0(i32 %p0, i32 %p1) {
| | // BlockID = 12
104:0| 3: <1, 1> | blocks 1;
106:4| 1: <65535, 11, 2> | constants { // BlockID = 11
116:0| 3: <1, 2> | i1:
118:4| 3: <4, 3> | %c0 = i1 1;
121:0| 0: <65534> | }
| | %b0:
124:0| 3: <29, 3, 2, 1> | %v0 = select i1 %c0, i32 %p0,
| | i32 %p1;
128:0| 3: <10, 1> | ret i32 %v0;
130:4| 0: <65534> | }
Call Instructions
-----------------
The *call* 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.
If the *tail* flag is associated with the call instruction, then the :ref:`PNaCl
translator<link_for_pnacl_translator>` is free to perform tail call
optimization. That is, the *tail* flag is a hint that may be ignored by the
PNaCl translator.
There are two kinds of calls: *direct* and *indirect*. A *direct* call calls a
defined :ref:`function address<link_for_function_address_section>` (i.e. a
reference to a bitcode ID of the form ``%fF``). All other calls are *indirect*.
Direct Procedure Call
^^^^^^^^^^^^^^^^^^^^^
The direct procedure call calls a defined :ref:`function
address<link_for_function_address_section>` whose :ref:`type
signature<link_for_function_type>` returns type void.
**Syntax**::
TAIL call void @fF (T1 A1, ... , TN AN); <A>
**Record**::
AA: <34, CC, F, AA1, ... , AAN>
**Semantics**:
The direct procedure call calls a define function address ``%fF`` whose type
signature return type is void. The arguments ``A1`` through ``AN`` are passed in
the order specified. The type of argument ``AI`` must be type ``TI`` (for all I,
1 <=I <= N). Flag ``TAIL`` is optional. If it is included, it must be the
literal ``tail``.
The types of the arguments must match the corresponding types of the function
signature associated with ``%fF``. The return type of ``%f`` must be void.
TAIL is encoded into calling convention value ``CC`` as follows:
====== ==
TAIL CC
====== ==
"" 0
"tail" 1
====== ==
**Constraints**::
AA == AbbrevIndex(A) &
N >= 0 &
TypeOfFcn(%fF) == void (T1, ... , TN) &
TypeOf(AI) == TI for all I, 1 <= I <= N
**Updates**::
++NumValuedInsts;
**Examples**::
72:0| 3: <8, 3, 0, 1, 0> | declare external
| | void @f0(i32, i64, i32);
...
116:0| 1: <65535, 12, 2> | function void @f1(i32 %p0) {
| | // BlockID = 12
124:0| 3: <1, 1> | blocks 1;
126:4| 1: <65535, 11, 2> | constants { // BlockID = 11
136:0| 3: <1, 2> | i64:
138:4| 3: <4, 2> | %c0 = i64 1;
141:0| 0: <65534> | }
| | %b0:
144:0| 3: <34, 0, 4, 2, 1, 2> | call void
| | @f0(i32 %p0, i64 %c0, i32 %p0);
150:2| 3: <10> | ret void;
152:0| 0: <65534> | }
Direct Function Call
^^^^^^^^^^^^^^^^^^^^
The direct function call calls a defined function address whose type signature
returns a value.
**Syntax**::
%vN = TAIL call RT %fF (T1 A1, ... , TM AM); <A>
**Record**::
AA: <34, CC, F, AA1, ... , AAM>
**Semantics**:
The direct function call calls a defined function address ``%fF`` whose type
signature returned is not type void. The arguments ``A1`` through ``AM`` are
passed in the order specified. The type of argument ``AI`` must be type ``TI``
(for all I, 1 <= I <= N). Flag ``TAIL`` is optional. If it is included, it must
be the literal ``tail``.
The types of the arguments must match the corresponding types of the function
signature associated with ``%fF``. The return type must match ``RT``.
Each parameter type ``TI``, and return type ``RT``, 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.
TAIL is encoded into calling convention value ``CC`` as follows:
====== ==
TAIL CC
====== ==
"" 0
"tail" 1
====== ==
**Constraints**::
AA == AbbrevIndex(A) &
N >= 0 &
TypeOfFcn(%fF) == RT (T1, ... , TN) &
TypeOf(AI) == TI for all I, 1 <= I <= M &
IsFcnArgType(TI) for all I, 1 <= I <= M &
IsFcnArgType(RT) &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = RT;
**Examples**::
72:0| 3: <8, 2, 0, 1, 0> | declare external
| | i32 @f0(i32, i64, i32);
...
116:0| 1: <65535, 12, 2> | function i32 @f1(i32 %p0) {
| | // BlockID = 12
124:0| 3: <1, 1> | blocks 1;
126:4| 1: <65535, 11, 2> | constants { // BlockID = 11
136:0| 3: <1, 1> | i64:
138:4| 3: <4, 2> | %c0 = i64 1;
141:0| 0: <65534> | }
| | %b0:
144:0| 3: <34, 0, 4, 2, 1, 2> | %v0 = call i32
| | @f0(i32 %p0, i64 %c0, i32 %p0);
150:2| 3: <34, 1, 4, 1> | %v1 = tail call i32 @f1(i32 %v0);
155:0| 3: <10, 2> | ret i32 %v0;
157:4| 0: <65534> | }
Indirect Procedure Call
^^^^^^^^^^^^^^^^^^^^^^^
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't use the type signature of the
corresponding direct function address to type check the construct.
**Syntax**::
TAIL call void V (T1 A1, ... , TN AN); <A>
**Record**::
AA: <44, CC, TV, VV, AA1, ... , AAN>
**Semantics**:
The indirect call procedure calls a function using value ``V`` that is an
indirect function address, and whose type signature is assumed to return type
void. The arguments ``A1`` through ``AN`` are passed in the order
specified. The type of argument ``AI`` must be type ``TI`` (for all I, 1 <= I <=
N). Flag ``TAIL`` is optional. If it is included, it must be the literal
``tail``.
Each parameter type ``TI`` (1 <= I <= 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.
TAIL is encoded into calling convention value ``CC`` as follows:
====== ==
TAIL CC
====== ==
"" 0
"tail" 1
====== ==
The type signature of the called procedure is assumed to be::
void (T1, ... , TN)
It isn't necessary to define this type in the :ref:`types
block<link_for_types_block_section>`, since the type is inferred rather than
used.
**Constraints**::
AA == AbbrevIndex(A) &
N >= 0 &
TV = TypeID(void) &
AbsoluteIndex(V) >= NumFuncAddresses &
TypeOf(AI) == TI for all I, 1 <= I <= N &
IsFcnArgType(TI) for all I, 1 <= I <= N
**Updates**::
++NumValuedInsts;
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 3> | count 3;
50:4| 3: <2> | @t0 = void;
52:2| 3: <7, 32> | @t1 = i32;
55:4| 3: <21, 0, 0, 1> | @t2 = void (i32);
59:4| 0: <65534> | }
...
92:0| 1: <65535, 12, 2> | function void @f0(i32 %p0) {
| | // BlockID = 12
100:0| 3: <1, 1> | blocks 1;
102:4| 1: <65535, 11, 2> | constants { // BlockID = 11
112:0| 3: <1, 1> | i32:
114:4| 3: <4, 2> | %c0 = i32 1;
117:0| 0: <65534> | }
| | %b0:
120:0| 3: <44, 0, 2, 0, 1> | call void %p0(i32 %c0);
125:4| 3: <10> | ret void;
127:2| 0: <65534> | }
Indirect Function Call
^^^^^^^^^^^^^^^^^^^^^^
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't
use the type signature of the corresponding literal function address to type
check the construct.
**Syntax**::
%vN = TAIL call RT V (T1 A1, ... , TM AM); <A>
**Record**::
AA: <34, CC, RRT, VV, AA1, ... , AAM>
**Semantics**:
The indirect function call calls a function using a value ``V`` that is an
indirect function address, and is assumed to return type ``RT``. The arguments
``A1`` through ``AM`` are passed in the order specified. The type of argument
``AI`` must be type ``TI`` (for all I, 1 <= I <= N). Flag ``TAIL`` is
optional. If it is included, it must be the literal ``tail``.
Each parameter type ``TI`` (1 <= I <= M), and return type ``RT``, 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.
TAIL is encoded into calling convention value ``CC`` as follows:
====== ==
TAIL CC
====== ==
'' 0
'tail' 1
====== ==
The type signature of the called function is assumed to be::
RT (T1, ... , TN)
It isn't necessary to define this type in the :ref:`types
block<link_for_types_block_section>`, since the type is inferred rather than
used.
**Constraints**::
AA == AbbrevIndex(A) &
RRT = TypeID(RT) &
VV = RelativeIndex(V) &
M >= 0 &
AbsoluteIndex(V) >= NumFcnAddresses &
TypeOf(AI) == TI for all I, 1 <= I <= M &
IsFcnArgType(TI) for all I, 1 <= I <= M &
IsFcnArgType(RT) &
N == NumValuedInsts
**Updates**::
++NumValuedInsts;
TypeOf(%vN) = RT;
**Examples**::
40:0| 1: <65535, 17, 2> | types { // BlockID = 17
48:0| 3: <1, 6> | count 6;
50:4| 3: <7, 32> | @t0 = i32;
53:6| 3: <3> | @t1 = float;
55:4| 3: <4> | @t2 = double;
57:2| 3: <21, 0, 0, 0, 1, 2> | @t3 = i32 (i32, float, double);
62:6| 3: <21, 0, 0, 1, 2> | @t4 = i32 (float, double);
67:4| 3: <2> | @t5 = void;
69:2| 0: <65534> | }
...
104:0| 1: <65535, 12, 2> | function
| | i32
| | @f0(i32 %p0, float %p1,
| | double %p2) {
| | // BlockID = 12
112:0| 3: <1, 1> | blocks 1;
| | %b0:
114:4| 3: <44, 0, 3, 0, 2, 1> | %v0 = call i32
| | %p0(float %p1, double %p2);
120:6| 3: <10, 1> | ret i32 %v0;
123:2| 0: <65534> | }
.. _link_for_memory_blocks_and_alignment_section:
Memory Blocks and Alignment
===========================
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.
Alignment plays a role at two points:
* When you create a local/global variable
* When you load/store data using a pointer.
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.
On loads and stores, the alignment in the instruction is used to communicate
what assumptions the :ref:`PNaCl translator<link_for_pnacl_translator>` can
make when choosing the appropriate machine instructions. If the alignment is 1,
it can'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.
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.
In PNaClAsm, the valid load/store alignments are:
=========== ==============
Type Alignment
=========== ==============
i1 1
i8 1
i16 1
i32 1
i64 1
Float 1, 4
Double 1, 8
<4 x i1> not applicable
<8 x i1> not applicable
<16 x i1> not applicable
<16 x i8> 1
<8 x i16> 2
<4 x i32> 4
<4 x float> 4
=========== ==============
Note that only vectors do not have an alignment value of 1. Hence, they can't be
placed at an arbitrary memory address. Also, since vectors on ``i1`` can't be
loaded/stored, the alignment is not applicable for these types.
.. _link_for_intrinsic_functions_section:
Intrinsic Functions
===================
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't be implemented within PNaClAsm,
or a non-architecture specific implementation may be too slow on some
architectures. In such cases, the :ref:`PNaCl
translator<link_for_pnacl_translator>` must fill in the corresponding
implementation, since only it knows the architecture it is compiling down to.
Examples of intrinsic function calls are for concurrent operations, atomic
operations, bulk memory moves, thread pointer operations, and long jumps.
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 ``i32`` and ``i64``).
See the :doc:`PNaCl bitcode reference manual<pnacl-bitcode-abi>` 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.
.. _link_for_support_functions_section:
Support Functions
=================
Defines functions used to convert syntactic representation to values in the
corresponding record.
SignRotate
----------
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.
The definition of SignRotate(N) is:
======== ============= =========
Argument Value Condition
======== ============= =========
N abs(N)<<1 N >= 0
N abs(N)<<1 + 1 N < 0
======== ============= =========
.. _link_for_absolute_index_section:
AbsoluteIndex
-------------
Bitcode IDs of the forms ``@fN``, ``@gN``, ``%pN``, ``%cN``, and ``%vN``, 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.
Hence, within a function block, it is safe to refer to all of these
bitcode IDs using a single *absolute* index. The absolute index for
each kind of bitcode ID is computed as follows:
========== ===================================================================
Bitcode ID AbsoluteIndex
========== ===================================================================
@tN N
@fN N
@gN N + NumFcnAddresses
@pN N + NumFcnAddresses + NumGlobalAddresses
@cN N + NumFcnAddresses + NumGlobalAddresses + NumParams
@vN N + NumFcnAddresses + NumGlobalAddresses + NumParams + NumFcnConsts
========== ===================================================================
.. _link_for_relative_index:
RelativeIndex
-------------
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::
RelativeIndex(J) = AbsoluteIndex(%vN) - AbsoluteIndex(J)
where::
N = NumValuedInsts
AbbrevIndex
-----------
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).
========= ==============
N AbbrevIndex(N)
========= ==============
undefined 3
%aA A + 4
@aA A + 4
========= ==============
Log2
----
This is the 32-bit log2 value of its argument.
BitSizeOf
---------
Returns the number of bits needed to represent its argument (a type).
======= ================
T BitSizeOf
======= ================
i1 1
i8 8
i16 16
i32 32
i64 64
float 32
double 64
<N X T> N * BitSizeOf(T)
======= ================
UnderlyingType
--------------
Returns the primitive type of the type construct. For primitive types, the
*UnderlyingType* is itself. For vector types, the base type of the vector is the
underlying type.
UnderlyingCount
---------------
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).
IsInteger
---------
Returns true if the argument is in {i1, i8, i16, i32, i64}.
IsFloat
-------
Returns true if the argument is in {``float``, ``double``}.
IsVector
--------
Returns true if the argument is a vector type.
IsPrimitive
-----------
Returns true if the argument is a primitive type. That is::
IsPrimitive(T) == IsInteger(T) or IsFloat(T)
IsFcnArgType
------------
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::
IsFcnArgType(T) = (IsInteger(T) and (i32 = BitSizeOf(T)
or i64 == BitSizeOf(T)))
or IsFloat(T) or IsVector(T)
.. _link_for_abbreviations_section:
Abbreviations
=============
Abbreviations are used to convert PNaCl records to a sequence of bits. PNaCl
uses the same strategy as `LLVM's bitcode file format
<http://llvm.org/docs/BitCodeFormat.html>`_. See that document for more
details.
It should be noted that we replace LLVM's header (called the *Bitcode Wrapper
Format*) with the bytes of the :ref:`PNaCl record
header<link_for_header_record_section>`. In addition, PNaCl bitcode files do
not allow *blob* abbreviation.
.. _link_for_abbreviations_block_section:
Abbreviations Block
-------------------
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
*@aN*.
In terms of `LLVM's bitcode file format
<http://llvm.org/docs/BitCodeFormat.html>`_, the abbreviations block is called a
*BLOCKINFO* block. Records *SETBID* and *DEFINE_ABBREV* are the only records
allowed in PNaCl's abbreviation block (i.e. it doesn't allow *BLOCKNAME* and
*SETRECORDNAME* records).
TODO
----
Extend this document to describe PNaCl's bitcode bit sequencer
without requiring the reader to refer to `LLVM's bitcode file
format <http://llvm.org/docs/BitCodeFormat.html>`_.
Codebase Browser
chromium