<li><a href="#callingconv">Calling Conventions</a></li>
<li><a href="#globalvars">Global Variables</a></li>
<li><a href="#functionstructure">Functions</a></li>
+ <li><a href="#aliasstructure">Aliases</a>
<li><a href="#paramattrs">Parameter Attributes</a></li>
<li><a href="#moduleasm">Module-Level Inline Assembly</a></li>
<li><a href="#datalayout">Data Layout</a></li>
<ol>
<li><a href="#int_varargs">Variable Argument Handling Intrinsics</a>
<ol>
- <li><a href="#i_va_start">'<tt>llvm.va_start</tt>' Intrinsic</a></li>
- <li><a href="#i_va_end">'<tt>llvm.va_end</tt>' Intrinsic</a></li>
- <li><a href="#i_va_copy">'<tt>llvm.va_copy</tt>' Intrinsic</a></li>
+ <li><a href="#int_va_start">'<tt>llvm.va_start</tt>' Intrinsic</a></li>
+ <li><a href="#int_va_end">'<tt>llvm.va_end</tt>' Intrinsic</a></li>
+ <li><a href="#int_va_copy">'<tt>llvm.va_copy</tt>' Intrinsic</a></li>
</ol>
</li>
<li><a href="#int_gc">Accurate Garbage Collection Intrinsics</a>
<ol>
- <li><a href="#i_gcroot">'<tt>llvm.gcroot</tt>' Intrinsic</a></li>
- <li><a href="#i_gcread">'<tt>llvm.gcread</tt>' Intrinsic</a></li>
- <li><a href="#i_gcwrite">'<tt>llvm.gcwrite</tt>' Intrinsic</a></li>
+ <li><a href="#int_gcroot">'<tt>llvm.gcroot</tt>' Intrinsic</a></li>
+ <li><a href="#int_gcread">'<tt>llvm.gcread</tt>' Intrinsic</a></li>
+ <li><a href="#int_gcwrite">'<tt>llvm.gcwrite</tt>' Intrinsic</a></li>
</ol>
</li>
<li><a href="#int_codegen">Code Generator Intrinsics</a>
<ol>
- <li><a href="#i_returnaddress">'<tt>llvm.returnaddress</tt>' Intrinsic</a></li>
- <li><a href="#i_frameaddress">'<tt>llvm.frameaddress</tt>' Intrinsic</a></li>
- <li><a href="#i_stacksave">'<tt>llvm.stacksave</tt>' Intrinsic</a></li>
- <li><a href="#i_stackrestore">'<tt>llvm.stackrestore</tt>' Intrinsic</a></li>
- <li><a href="#i_prefetch">'<tt>llvm.prefetch</tt>' Intrinsic</a></li>
- <li><a href="#i_pcmarker">'<tt>llvm.pcmarker</tt>' Intrinsic</a></li>
- <li><a href="#i_readcyclecounter"><tt>llvm.readcyclecounter</tt>' Intrinsic</a></li>
+ <li><a href="#int_returnaddress">'<tt>llvm.returnaddress</tt>' Intrinsic</a></li>
+ <li><a href="#int_frameaddress">'<tt>llvm.frameaddress</tt>' Intrinsic</a></li>
+ <li><a href="#int_stacksave">'<tt>llvm.stacksave</tt>' Intrinsic</a></li>
+ <li><a href="#int_stackrestore">'<tt>llvm.stackrestore</tt>' Intrinsic</a></li>
+ <li><a href="#int_prefetch">'<tt>llvm.prefetch</tt>' Intrinsic</a></li>
+ <li><a href="#int_pcmarker">'<tt>llvm.pcmarker</tt>' Intrinsic</a></li>
+ <li><a href="#int_readcyclecounter"><tt>llvm.readcyclecounter</tt>' Intrinsic</a></li>
</ol>
</li>
<li><a href="#int_libc">Standard C Library Intrinsics</a>
<ol>
- <li><a href="#i_memcpy">'<tt>llvm.memcpy.*</tt>' Intrinsic</a></li>
- <li><a href="#i_memmove">'<tt>llvm.memmove.*</tt>' Intrinsic</a></li>
- <li><a href="#i_memset">'<tt>llvm.memset.*</tt>' Intrinsic</a></li>
- <li><a href="#i_sqrt">'<tt>llvm.sqrt.*</tt>' Intrinsic</a></li>
- <li><a href="#i_powi">'<tt>llvm.powi.*</tt>' Intrinsic</a></li>
+ <li><a href="#int_memcpy">'<tt>llvm.memcpy.*</tt>' Intrinsic</a></li>
+ <li><a href="#int_memmove">'<tt>llvm.memmove.*</tt>' Intrinsic</a></li>
+ <li><a href="#int_memset">'<tt>llvm.memset.*</tt>' Intrinsic</a></li>
+ <li><a href="#int_sqrt">'<tt>llvm.sqrt.*</tt>' Intrinsic</a></li>
+ <li><a href="#int_powi">'<tt>llvm.powi.*</tt>' Intrinsic</a></li>
</ol>
</li>
<li><a href="#int_manip">Bit Manipulation Intrinsics</a>
<ol>
- <li><a href="#i_bswap">'<tt>llvm.bswap.*</tt>' Intrinsics</a></li>
+ <li><a href="#int_bswap">'<tt>llvm.bswap.*</tt>' Intrinsics</a></li>
<li><a href="#int_ctpop">'<tt>llvm.ctpop.*</tt>' Intrinsic </a></li>
<li><a href="#int_ctlz">'<tt>llvm.ctlz.*</tt>' Intrinsic </a></li>
<li><a href="#int_cttz">'<tt>llvm.cttz.*</tt>' Intrinsic </a></li>
+ <li><a href="#int_part_select">'<tt>llvm.part.select.*</tt>' Intrinsic </a></li>
+ <li><a href="#int_part_set">'<tt>llvm.part.set.*</tt>' Intrinsic </a></li>
</ol>
</li>
<li><a href="#int_debugger">Debugger intrinsics</a></li>
<li><a href="#int_eh">Exception Handling intrinsics</a></li>
+ <li><a href="#int_general">General intrinsics</a></li>
+ <ol>
+ <li><a href="#int_var_annotation">'<tt>llvm.var.annotation</tt>'
+ Intrinsic</a></li>
+ </ol>
+ </li>
</ol>
</li>
</ol>
accepts and what is considered 'well formed'. For example, the
following instruction is syntactically okay, but not well formed:</p>
+<div class="doc_code">
<pre>
-
%x = <a href="#i_add">add</a> i32 1, %x
+%x = <a href="#i_add">add</a> i32 1, %x
</pre>
+</div>
<p>...because the definition of <tt>%x</tt> does not dominate all of
its uses. The LLVM infrastructure provides a verification pass that may
the optimizer before it outputs bytecode. The violations pointed out
by the verifier pass indicate bugs in transformation passes or input to
the parser.</p>
+</div>
<!-- Describe the typesetting conventions here. --> </div>
<p>The easy way:</p>
+<div class="doc_code">
<pre>
-
%result = <a href="#i_mul">mul</a> i32 %X, 8
+%result = <a href="#i_mul">mul</a> i32 %X, 8
</pre>
+</div>
<p>After strength reduction:</p>
+<div class="doc_code">
<pre>
-
%result = <a href="#i_shl">shl</a> i32 %X, i8 3
+%result = <a href="#i_shl">shl</a> i32 %X, i8 3
</pre>
+</div>
<p>And the hard way:</p>
+<div class="doc_code">
<pre>
-
<a href="#i_add">add</a> i32 %X, %X <i>; yields {i32}:%0</i>
-
<a href="#i_add">add</a> i32 %0, %0 <i>; yields {i32}:%1</i>
-
%result = <a href="#i_add">add</a> i32 %1, %1
+<a href="#i_add">add</a> i32 %X, %X <i>; yields {i32}:%0</i>
+<a href="#i_add">add</a> i32 %0, %0 <i>; yields {i32}:%1</i>
+%result = <a href="#i_add">add</a> i32 %1, %1
</pre>
+</div>
<p>This last way of multiplying <tt>%X</tt> by 8 illustrates several
important lexical features of LLVM:</p>
global variable) definitions, resolves forward declarations, and merges
symbol table entries. Here is an example of the "hello world" module:</p>
+<div class="doc_code">
<pre><i>; Declare the string constant as a global constant...</i>
-<a href="#identifiers">
%.LC0</a> = <a href="#linkage_internal">internal</a> <a
- href="#globalvars">constant</a> <a href="#t_array">[13 x i8 ]</a> c"hello world\0A\00" <i>; [13 x i8 ]*</i>
+<a href="#identifiers">
@.LC0</a> = <a href="#linkage_internal">internal</a> <a
+ href="#globalvars">constant</a> <a href="#t_array">[13 x i8]</a> c"hello world\0A\00" <i>; [13 x i8]*</i>
<i>; External declaration of the puts function</i>
-<a href="#functionstructure">declare</a> i32 %puts(i8 *) <i>; i32(i8 *)* </i>
-
-<i>; Global variable / Function body section separator</i>
-implementation
+<a href="#functionstructure">declare</a> i32 @puts(i8 *) <i>; i32(i8 *)* </i>
<i>; Definition of main function</i>
-define i32 %main() { <i>; i32()* </i>
+define i32 @main() { <i>; i32()* </i>
<i>; Convert [13x i8 ]* to i8 *...</i>
%cast210 = <a
- href="#i_getelementptr">getelementptr</a> [13 x i8 ]* %.LC0, i64 0, i64 0 <i>; i8 *</i>
+ href="#i_getelementptr">getelementptr</a> [13 x i8 ]* @.LC0, i64 0, i64 0 <i>; i8 *</i>
<i>; Call puts function to write out the string to stdout...</i>
<a
- href="#i_call">call</a> i32 %puts(i8 * %cast210) <i>; i32</i>
+ href="#i_call">call</a> i32 @puts(i8 * %cast210) <i>; i32</i>
<a
- href="#i_ret">ret</a> i32 0<br>}<br></pre>
+ href="#i_ret">ret</a> i32 0<br>}<br>
+</pre>
+</div>
<p>This example is made up of a <a href="#globalvars">global variable</a>
named "<tt>.LC0</tt>", an external declaration of the "<tt>puts</tt>"
array of char, and a pointer to a function), and have one of the following <a
href="#linkage">linkage types</a>.</p>
-<p>Due to a limitation in the current LLVM assembly parser (it is limited by
-one-token lookahead), modules are split into two pieces by the "implementation"
-keyword. Global variable prototypes and definitions must occur before the
-keyword, and function definitions must occur after it. Function prototypes may
-occur either before or after it. In the future, the implementation keyword may
-become a noop, if the parser gets smarter.</p>
-
</div>
<!-- ======================================================================= -->
until linked, if not linked, the symbol becomes null instead of being an
undefined reference.
</dd>
-</dl>
<dt><tt><b><a name="linkage_external">externally visible</a></b></tt>:</dt>
visible, meaning that it participates in linkage and can be used to resolve
external symbol references.
</dd>
+</dl>
<p>
The next two types of linkage are targeted for Microsoft Windows platform
<p>It is illegal for a function <i>declaration</i>
to have any linkage type other than "externally visible", <tt>dllimport</tt>,
or <tt>extern_weak</tt>.</p>
-
+<p>Aliases can have only <tt>external</tt>, <tt>internal</tt> and <tt>weak</tt>
+linkages.
</div>
<!-- ======================================================================= -->
directly.
</dd>
+ <dt><b>"<tt>protected</tt>" - Protected style</b>:</dt>
+
+ <dd>On ELF, protected visibility indicates that the symbol will be placed in
+ the dynamic symbol table, but that references within the defining module will
+ bind to the local symbol. That is, the symbol cannot be overridden by another
+ module.
+ </dd>
</dl>
</div>
<p>Global variables define regions of memory allocated at compilation time
instead of run-time. Global variables may optionally be initialized, may have
-an explicit section to be placed in, and may
-have an optional explicit alignment specified. A
-variable may be defined as a global "constant," which indicates that the
-contents of the variable will <b>never</b> be modified (enabling better
+an explicit section to be placed in, and may have an optional explicit alignment
+specified. A variable may be defined as "thread_local", which means that it
+will not be shared by threads (each thread will have a separated copy of the
+variable). A variable may be defined as a global "constant," which indicates
+that the contents of the variable will <b>never</b> be modified (enabling better
optimization, allowing the global data to be placed in the read-only section of
an executable, etc). Note that variables that need runtime initialization
cannot be marked "constant" as there is a store to the variable.</p>
<p>For example, the following defines a global with an initializer, section,
and alignment:</p>
+<div class="doc_code">
<pre>
- %G = constant float 1.0, section "foo", align 4
+%G = constant float 1.0, section "foo", align 4
</pre>
+</div>
</div>
with a <a href="#terminators">terminator</a> instruction (such as a branch or
function return).</p>
-<p>The first basic block in a program is special in two ways: it is immediately
+<p>The first basic block in a function is special in two ways: it is immediately
executed on entrance to the function, and it is not allowed to have predecessor
basic blocks (i.e. there can not be any branches to the entry block of a
function). Because the block can have no predecessors, it also cannot have any
</div>
+
+<!-- ======================================================================= -->
+<div class="doc_subsection">
+ <a name="aliasstructure">Aliases</a>
+</div>
+<div class="doc_text">
+ <p>Aliases act as "second name" for the aliasee value (which can be either
+ function or global variable or bitcast of global value). Aliases may have an
+ optional <a href="#linkage">linkage type</a>, and an
+ optional <a href="#visibility">visibility style</a>.</p>
+
+ <h5>Syntax:</h5>
+
+<div class="doc_code">
+<pre>
+@<Name> = [Linkage] [Visibility] alias <AliaseeTy> @<Aliasee>
+</pre>
+</div>
+
+</div>
+
+
+
<!-- ======================================================================= -->
<div class="doc_subsection"><a name="paramattrs">Parameter Attributes</a></div>
<div class="doc_text">
<p>Parameter attributes are simple keywords that follow the type specified. If
multiple parameter attributes are needed, they are space separated. For
- example:</p><pre>
- %someFunc = i16 (i8 sext %someParam) zext
- %someFunc = i16 (i8 zext %someParam) zext</pre>
+ example:</p>
+
+<div class="doc_code">
+<pre>
+%someFunc = i16 (i8 sext %someParam) zext
+%someFunc = i16 (i8 zext %someParam) zext
+</pre>
+</div>
+
<p>Note that the two function types above are unique because the parameter has
a different attribute (sext in the first one, zext in the second). Also note
that the attribute for the function result (zext) comes immediately after the
<dt><tt>sret</tt></dt>
<dd>This indicates that the parameter specifies the address of a structure
that is the return value of the function in the source program.</dd>
+ <dt><tt>noalias</tt></dt>
+ <dd>This indicates that the parameter not alias any other object or any
+ other "noalias" objects during the function call.
<dt><tt>noreturn</tt></dt>
<dd>This function attribute indicates that the function never returns. This
indicates to LLVM that every call to this function should be treated as if
desired. The syntax is very simple:
</p>
-<div class="doc_code"><pre>
- module asm "inline asm code goes here"
- module asm "more can go here"
-</pre></div>
+<div class="doc_code">
+<pre>
+module asm "inline asm code goes here"
+module asm "more can go here"
+</pre>
+</div>
<p>The strings can contain any character by escaping non-printable characters.
The escape sequence used is simply "\xx" where "xx" is the two digit hex code
<div class="doc_text">
<p>A module may specify a target specific data layout string that specifies how
-data is to be laid out in memory. The syntax for the data layout is simply:<br/>
-<pre> target datalayout = "<i>layout specification</i>"
-</pre>
-The <i>layout specification</i> consists of a list of specifications separated
-by the minus sign character ('-'). Each specification starts with a letter
-and may include other information after the letter to define some aspect of the
-data layout. The specifications accepted are as follows: </p>
+data is to be laid out in memory. The syntax for the data layout is simply:</p>
+<pre> target datalayout = "<i>layout specification</i>"</pre>
+<p>The <i>layout specification</i> consists of a list of specifications
+separated by the minus sign character ('-'). Each specification starts with a
+letter and may include other information after the letter to define some
+aspect of the data layout. The specifications accepted are as follows: </p>
<dl>
<dt><tt>E</tt></dt>
<dd>Specifies that the target lays out data in big-endian form. That is, the
<table>
<tbody>
<tr><th>Type</th><th>Description</th></tr>
- <tr><td><tt>void</tt></td><td>No value</td></tr>
- <tr><td><tt>i8</tt></td><td>8-bit value</td></tr>
- <tr><td><tt>i32</tt></td><td>32-bit value</td></tr>
- <tr><td><tt>float</tt></td><td>32-bit floating point value</td></tr>
+ <tr><td><tt><a name="t_void">void</a></tt></td><td>No value</td></tr>
<tr><td><tt>label</tt></td><td>Branch destination</td></tr>
</tbody>
</table>
<table>
<tbody>
<tr><th>Type</th><th>Description</th></tr>
- <tr><td><tt>i1</tt></td><td>True or False value</td></tr>
- <tr><td><tt>i16</tt></td><td>16-bit value</td></tr>
- <tr><td><tt>i64</tt></td><td>64-bit value</td></tr>
+ <tr><td><tt>float</tt></td><td>32-bit floating point value</td></tr>
<tr><td><tt>double</tt></td><td>64-bit floating point value</td></tr>
</tbody>
</table>
<tr><th>Classification</th><th>Types</th></tr>
<tr>
<td><a name="t_integer">integer</a></td>
- <td><tt>i1, i8, i16, i32, i64</tt></td>
+ <td><tt>i1, i2, i3, ... i8, ... i16, ... i32, ... i64, ... </tt></td>
</tr>
<tr>
<td><a name="t_floating">floating point</a></td>
</tr>
<tr>
<td><a name="t_firstclass">first class</a></td>
- <td><tt>i1, i8, i16, i32, i64, float, double, <br/>
+ <td><tt>i1, ..., float, double, <br/>
<a href="#t_pointer">pointer</a>,<a href="#t_vector">vector</a></tt>
</td>
</tr>
</div>
+<!-- _______________________________________________________________________ -->
+<div class="doc_subsubsection"> <a name="t_integer">Integer Type</a> </div>
+
+<div class="doc_text">
+
+<h5>Overview:</h5>
+<p>The integer type is a very simple derived type that simply specifies an
+arbitrary bit width for the integer type desired. Any bit width from 1 bit to
+2^23-1 (about 8 million) can be specified.</p>
+
+<h5>Syntax:</h5>
+
+<pre>
+ iN
+</pre>
+
+<p>The number of bits the integer will occupy is specified by the <tt>N</tt>
+value.</p>
+
+<h5>Examples:</h5>
+<table class="layout">
+ <tr class="layout">
+ <td class="left">
+ <tt>i1</tt><br/>
+ <tt>i4</tt><br/>
+ <tt>i8</tt><br/>
+ <tt>i16</tt><br/>
+ <tt>i32</tt><br/>
+ <tt>i42</tt><br/>
+ <tt>i64</tt><br/>
+ <tt>i1942652</tt><br/>
+ </td>
+ <td class="left">
+ A boolean integer of 1 bit<br/>
+ A nibble sized integer of 4 bits.<br/>
+ A byte sized integer of 8 bits.<br/>
+ A half word sized integer of 16 bits.<br/>
+ A word sized integer of 32 bits.<br/>
+ An integer whose bit width is the answer. <br/>
+ A double word sized integer of 64 bits.<br/>
+ A really big integer of over 1 million bits.<br/>
+ </td>
+ </tr>
+</table>
+</div>
+
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection"> <a name="t_array">Array Type</a> </div>
<h5>Examples:</h5>
<table class="layout">
<tr class="layout">
- <td class="left">
- <tt>{ i32, i32, i32 }</tt><br/>
- <tt>{ float, i32 (i32) * }</tt><br/>
- </td>
- <td class="left">
- a triple of three <tt>i32</tt> values<br/>
- A pair, where the first element is a <tt>float</tt> and the second element
- is a <a href="#t_pointer">pointer</a> to a <a href="#t_function">function</a>
- that takes an <tt>i32</tt>, returning an <tt>i32</tt>.<br/>
- </td>
+ <td class="left"><tt>{ i32, i32, i32 }</tt></td>
+ <td class="left">A triple of three <tt>i32</tt> values</td>
+ </tr><tr class="layout">
+ <td class="left"><tt>{ float, i32 (i32) * }</tt></td>
+ <td class="left">A pair, where the first element is a <tt>float</tt> and the
+ second element is a <a href="#t_pointer">pointer</a> to a
+ <a href="#t_function">function</a> that takes an <tt>i32</tt>, returning
+ an <tt>i32</tt>.</td>
</tr>
</table>
</div>
<h5>Examples:</h5>
<table class="layout">
<tr class="layout">
- <td class="left">
- <tt> < { i32, i32, i32 } > </tt><br/>
- <tt> < { float, i32 (i32) * } > </tt><br/>
- </td>
- <td class="left">
- a triple of three <tt>i32</tt> values<br/>
- A pair, where the first element is a <tt>float</tt> and the second element
- is a <a href="#t_pointer">pointer</a> to a <a href="#t_function">function</a>
- that takes an <tt>i32</tt>, returning an <tt>i32</tt>.<br/>
- </td>
+ <td class="left"><tt>< { i32, i32, i32 } ></tt></td>
+ <td class="left">A triple of three <tt>i32</tt> values</td>
+ </tr><tr class="layout">
+ <td class="left"><tt>< { float, i32 (i32) * } ></tt></td>
+ <td class="left">A pair, where the first element is a <tt>float</tt> and the
+ second element is a <a href="#t_pointer">pointer</a> to a
+ <a href="#t_function">function</a> that takes an <tt>i32</tt>, returning
+ an <tt>i32</tt>.</td>
</tr>
</table>
</div>
<dd>Vector constants are represented with notation similar to vector type
definitions (a comma separated list of elements, surrounded by
less-than/greater-than's (<tt><></tt>)). For example: "<tt>< i32 42,
- i32 11, i32 74, i32 100 ></tt>". V
Ector constants must have <a
+ i32 11, i32 74, i32 100 ></tt>". V
ector constants must have <a
href="#t_vector">vector type</a>, and the number and types of elements must
match those specified by the type.
</dd>
href="#t_pointer">pointer</a> type. For example, the following is a legal LLVM
file:</p>
+<div class="doc_code">
<pre>
- %X = global i32 17
- %Y = global i32 42
- %Z = global [2 x i32*] [ i32* %X, i32* %Y ]
+@X = global i32 17
+@Y = global i32 42
+@Z = global [2 x i32*] [ i32* @X, i32* @Y ]
</pre>
+</div>
</div>
inline assembler expression is:
</p>
+<div class="doc_code">
<pre>
- i32 (i32) asm "bswap $0", "=r,r"
+i32 (i32) asm "bswap $0", "=r,r"
</pre>
+</div>
<p>
Inline assembler expressions may <b>only</b> be used as the callee operand of
a <a href="#i_call"><tt>call</tt> instruction</a>. Thus, typically we have:
</p>
+<div class="doc_code">
<pre>
- %X = call i32 asm "<a href="#i_bswap">bswap</a> $0", "=r,r"(i32 %Y)
+%X = call i32 asm "<a href="#int_bswap">bswap</a> $0", "=r,r"(i32 %Y)
</pre>
+</div>
<p>
Inline asms with side effects not visible in the constraint list must be marked
'<tt>sideeffect</tt>' keyword, like so:
</p>
+<div class="doc_code">
<pre>
- call void asm sideeffect "eieio", ""()
+call void asm sideeffect "eieio", ""()
</pre>
+</div>
<p>TODO: The format of the asm and constraints string still need to be
documented here. Constraints on what can be done (e.g. duplication, moving, etc
<ol>
<li>
- The optional "cconv" marker indicates which <a href="callingconv">calling
+ The optional "cconv" marker indicates which <a href="#callingconv">calling
convention</a> the call should use. If none is specified, the call defaults
to using C calling conventions.
</li>
<h5>Example:</h5>
<pre>
- %retval = invoke i32 %Test(i32 15) to label %Continue
- unwind label %TestCleanup <i>; {i32}:retval set</i>
- %retval = invoke <a href="#callingconv">coldcc</a> i32 %Test(i32 15) to label %Continue
- unwind label %TestCleanup <i>; {i32}:retval set</i>
+ %retval = invoke i32 %Test(i32 15) to label %Continue
+ unwind label %TestCleanup <i>; {i32}:retval set</i>
+ %retval = invoke <a href="#callingconv">coldcc</a> i32 %Test(i32 15) to label %Continue
+ unwind label %TestCleanup <i>; {i32}:retval set</i>
</pre>
</div>
<p>The value produced is the integer or floating point difference of
the two operands.</p>
<h5>Example:</h5>
-<pre> <result> = sub i32 4, %var <i>; yields {i32}:result = 4 - %var</i>
+<pre>
+ <result> = sub i32 4, %var <i>; yields {i32}:result = 4 - %var</i>
<result> = sub i32 0, %val <i>; yields {i32}:result = -%var</i>
</pre>
</div>
<p>The '<tt>fdiv</tt>' instruction returns the quotient of its two
operands.</p>
<h5>Arguments:</h5>
-<p>The two arguments to the '<tt>div</tt>' instruction must be
+<p>The two arguments to the '<tt>fdiv</tt>' instruction must be
<a href="#t_floating">floating point</a> values. Both arguments must have
identical types. This instruction can also take <a href="#t_vector">vector</a>
-versions of the values in which case the elements must be floating point.</p>
+versions of floating point values.</p>
<h5>Semantics:</h5>
<p>The value produced is the floating point quotient of the two operands.</p>
<h5>Example:</h5>
a value. For more information about the difference, see <a
href="http://mathforum.org/dr.math/problems/anne.4.28.99.html">The
Math Forum</a>. For a table of how this is implemented in various languages,
-please see <a href="http://mathforum.org/dr.math/problems/anne.4.28.99.html">
+please see <a href="http://en.wikipedia.org/wiki/Modulo_operation">
Wikipedia: modulo operation</a>.</p>
<h5>Example:</h5>
<pre> <result> = srem i32 4, %var <i>; yields {i32}:result = 4 % %var</i>
<h5>Overview:</h5>
<p>The '<tt>lshr</tt>' instruction (logical shift right) returns the first
-operand shifted to the right a specified number of bits.</p>
+operand shifted to the right a specified number of bits with zero fill.</p>
<h5>Arguments:</h5>
<p>Both arguments to the '<tt>lshr</tt>' instruction must be the same
<h5>Overview:</h5>
<p>The '<tt>ashr</tt>' instruction (arithmetic shift right) returns the first
-operand shifted to the right a specified number of bits.</p>
+operand shifted to the right a specified number of bits with sign extension.</p>
<h5>Arguments:</h5>
<p>Both arguments to the '<tt>ashr</tt>' instruction must be the same
<div class="doc_text">
<p>LLVM supports several instructions to represent vector operations in a
-target-independent manner. This instructions cover the element-access and
+target-independent manner. These instructions cover the element-access and
vector-specific operations needed to process vectors effectively. While LLVM
does directly support these vector operations, many sophisticated algorithms
will want to use target-specific intrinsics to take full advantage of a specific
<pre>
%result = shufflevector <4 x i32> %v1, <4 x i32> %v2,
- <4 x i32> <i32 0, i32 4, i32 1, i32 5> <i>; yields <4 x i32></i>
+ <4 x i32> <i32 0, i32 4, i32 1, i32 5> <i>; yields <4 x i32></i>
%result = shufflevector <4 x i32> %v1, <4 x i32> undef,
<4 x i32> <i32 0, i32 1, i32 2, i32 3> <i>; yields <4 x i32></i> - Identity shuffle.
</pre>
<pre>
%array = malloc [4 x i8 ] <i>; yields {[%4 x i8]*}:array</i>
- %size = <a href="#i_add">add</a> i32 2, 2 <i>; yields {i32}:size = i32 4</i>
- %array1 = malloc i8, i32 4 <i>; yields {i8*}:array1</i>
- %array2 = malloc [12 x i8], i32 %size <i>; yields {[12 x i8]*}:array2</i>
- %array3 = malloc i32, i32 4, align 1024 <i>; yields {i32*}:array3</i>
- %array4 = malloc i32, align 1024 <i>; yields {i32*}:array4</i>
+ %size = <a href="#i_add">add</a> i32 2, 2 <i>; yields {i32}:size = i32 4</i>
+ %array1 = malloc i8, i32 4 <i>; yields {i8*}:array1</i>
+ %array2 = malloc [12 x i8], i32 %size <i>; yields {[12 x i8]*}:array2</i>
+ %array3 = malloc i32, i32 4, align 1024 <i>; yields {i32*}:array3</i>
+ %array4 = malloc i32, align 1024 <i>; yields {i32*}:array4</i>
</pre>
</div>
<h5>Overview:</h5>
-<p>The '<tt>alloca</tt>' instruction allocates memory on the current
-stack frame of the procedure that is live until the current function
+<p>The '<tt>alloca</tt>' instruction allocates memory on the stack frame of the
+currently executing function, to be automatically released when this function
returns to its caller.</p>
<h5>Arguments:</h5>
<pre>
%ptr = alloca i32 <i>; yields {i32*}:ptr</i>
- %ptr = alloca i32, i32 4 <i>; yields {i32*}:ptr</i>
- %ptr = alloca i32, i32 4, align 1024 <i>; yields {i32*}:ptr</i>
+ %ptr = alloca i32, i32 4 <i>; yields {i32*}:ptr</i>
+ %ptr = alloca i32, i32 4, align 1024 <i>; yields {i32*}:ptr</i>
%ptr = alloca i32, align 1024 <i>; yields {i32*}:ptr</i>
</pre>
</div>
Instruction</a> </div>
<div class="doc_text">
<h5>Syntax:</h5>
-<pre> <result> = load <ty>* <pointer><br> <result> = volatile load <ty>* <pointer><br></pre>
+<pre> <result> = load <ty>* <pointer>[, align <alignment>]<br> <result> = volatile load <ty>* <pointer>[, align <alignment>]<br></pre>
<h5>Overview:</h5>
<p>The '<tt>load</tt>' instruction is used to read from memory.</p>
<h5>Arguments:</h5>
Instruction</a> </div>
<div class="doc_text">
<h5>Syntax:</h5>
-<pre> store <ty> <value>, <ty>* <pointer> <i>; yields {void}</i>
- volatile store <ty> <value>, <ty>* <pointer> <i>; yields {void}</i>
+<pre> store <ty> <value>, <ty>* <pointer>[, align <alignment>] <i>; yields {void}</i>
+ volatile store <ty> <value>, <ty>* <pointer>[, align <alignment>] <i>; yields {void}</i>
</pre>
<h5>Overview:</h5>
<p>The '<tt>store</tt>' instruction is used to write to memory.</p>
<h5>Arguments:</h5>
<p>There are two arguments to the '<tt>store</tt>' instruction: a value
-to store and an address in which to store it. The type of the '<tt><pointer></tt>'
+to store and an address at which to store it. The type of the '<tt><pointer></tt>'
operand must be a pointer to the type of the '<tt><value></tt>'
operand. If the <tt>store</tt> is marked as <tt>volatile</tt>, then the
optimizer is not allowed to modify the number or order of execution of
<p>For example, let's consider a C code fragment and how it gets
compiled to LLVM:</p>
+<div class="doc_code">
<pre>
- struct RT {
- char A;
- i32 B[10][20];
- char C;
- };
- struct ST {
- i32 X;
- double Y;
- struct RT Z;
- };
-
- define i32 *foo(struct ST *s) {
- return &s[1].Z.B[5][13];
- }
+struct RT {
+ char A;
+ int B[10][20];
+ char C;
+};
+struct ST {
+ int X;
+ double Y;
+ struct RT Z;
+};
+
+int *foo(struct ST *s) {
+ return &s[1].Z.B[5][13];
+}
</pre>
+</div>
<p>The LLVM code generated by the GCC frontend is:</p>
+<div class="doc_code">
<pre>
- %RT = type { i8 , [10 x [20 x i32]], i8 }
- %ST = type { i32, double, %RT }
-
- implementation
+%RT = type { i8 , [10 x [20 x i32]], i8 }
+%ST = type { i32, double, %RT }
- define i32* %foo(%ST* %s) {
- entry:
- %reg = getelementptr %ST* %s, i32 1, i32 2, i32 1, i32 5, i32 13
- ret i32* %reg
- }
+define i32* %foo(%ST* %s) {
+entry:
+ %reg = getelementptr %ST* %s, i32 1, i32 2, i32 1, i32 5, i32 13
+ ret i32* %reg
+}
</pre>
+</div>
<h5>Semantics:</h5>
on the pointer type that is being indexed into. <a href="#t_pointer">Pointer</a>
and <a href="#t_array">array</a> types can use a 32-bit or 64-bit
<a href="#t_integer">integer</a> type but the value will always be sign extended
-to 64-bits. <a href="#t_struct">Structure</a> types, require <tt>i32</tt>
+to 64-bits. <a href="#t_struct">Structure</a> types require <tt>i32</tt>
<b>constants</b>.</p>
<p>In the example above, the first index is indexing into the '<tt>%ST*</tt>'
<pre>
define i32* %foo(%ST* %s) {
%t1 = getelementptr %ST* %s, i32 1 <i>; yields %ST*:%t1</i>
- %t2 = getelementptr %ST* %t1, i32 0, i32 2 <i>; yields %RT*:%t2</i>
- %t3 = getelementptr %RT* %t2, i32 0, i32 1 <i>; yields [10 x [20 x i32]]*:%t3</i>
+ %t2 = getelementptr %ST* %t1, i32 0, i32 2 <i>; yields %RT*:%t2</i>
+ %t3 = getelementptr %RT* %t2, i32 0, i32 1 <i>; yields [10 x [20 x i32]]*:%t3</i>
%t4 = getelementptr [10 x [20 x i32]]* %t3, i32 0, i32 5 <i>; yields [20 x i32]*:%t4</i>
%t5 = getelementptr [20 x i32]* %t4, i32 0, i32 13 <i>; yields i32*:%t5</i>
ret i32* %t5
<h5>Semantics:</h5>
<p>The <tt>zext</tt> fills the high order bits of the <tt>value</tt> with zero
-bits until it reaches the size of the destination type, <tt>ty2</tt>. When the
-the operand and the type are the same size, no bit filling is done and the
-cast is considered a <i>no-op cast</i> because no bits change (only the type
-changes).</p>
+bits until it reaches the size of the destination type, <tt>ty2</tt>.</p>
<p>When zero extending from i1, the result will always be either 0 or 1.</p>
<p>
The '<tt>sext</tt>' instruction performs a sign extension by copying the sign
bit (highest order bit) of the <tt>value</tt> until it reaches the bit size of
-the type <tt>ty2</tt>. When the the operand and the type are the same size,
-no bit filling is done and the cast is considered a <i>no-op cast</i> because
-no bits change (only the type changes).</p>
+the type <tt>ty2</tt>.</p>
<p>When sign extending from i1, the extension always results in -1 or 0.</p>
<h5>Semantics:</h5>
<p>The '<tt>fpext</tt>' instruction extends the <tt>value</tt> from a smaller
-<a href="t_floating">floating point</a> type to a larger
-<a href="t_floating">floating point</a> type. The <tt>fpext</tt> cannot be
+<a href="#t_floating">floating point</a> type to a larger
+<a href="#t_floating">floating point</a> type. The <tt>fpext</tt> cannot be
used to make a <i>no-op cast</i> because it always changes bits. Use
<tt>bitcast</tt> to make a <i>no-op cast</i> for a floating point cast.</p>
<h5>Example:</h5>
<pre>
%X = uitofp i32 257 to float <i>; yields float:257.0</i>
- %Y = uitofp i8 -1 to double <i>; yields double:255.0</i>
+ %Y = uitofp i8 -1 to double <i>; yields double:255.0</i>
</pre>
</div>
<h5>Example:</h5>
<pre>
%X = sitofp i32 257 to float <i>; yields float:257.0</i>
- %Y = sitofp i8 -1 to double <i>; yields double:-1.0</i>
+ %Y = sitofp i8 -1 to double <i>; yields double:-1.0</i>
</pre>
</div>
<h5>Arguments:</h5>
<p>The '<tt>ptrtoint</tt>' instruction takes a <tt>value</tt> to cast, which
-must be a <a href="t_pointer">pointer</a> value, and a type to cast it to
+must be a <a href="#t_pointer">pointer</a> value, and a type to cast it to
<tt>ty2</tt>, which must be an <a href="#t_integer">integer</a> type.
<h5>Semantics:</h5>
truncating or zero extending that value to the size of the integer type. If
<tt>value</tt> is smaller than <tt>ty2</tt> then a zero extension is done. If
<tt>value</tt> is larger than <tt>ty2</tt> then a truncation is done. If they
-are the same size, then nothing is done (<i>no-op cast</i>).</p>
+are the same size, then nothing is done (<i>no-op cast</i>) other than a type
+change.</p>
<h5>Example:</h5>
<pre>
- %X = ptrtoint i32* %X to i8 <i>; yields truncation on 32-bit</i>
- %Y = ptrtoint i32* %x to i64 <i>; yields zero extend on 32-bit</i>
+ %X = ptrtoint i32* %X to i8 <i>; yields truncation on 32-bit architecture</i>
+ %Y = ptrtoint i32* %x to i64 <i>; yields zero extension on 32-bit architecture</i>
</pre>
</div>
a pointer type, <tt>ty2</tt>.</p>
<h5>Arguments:</h5>
-<p>The '<tt>inttoptr</tt>' instruction takes an <a href="i_integer">integer</a>
+<p>The '<tt>inttoptr</tt>' instruction takes an <a href="#t_integer">integer</a>
value to cast, and a type to cast it to, which must be a
<a href="#t_pointer">pointer</a> type.
<h5>Example:</h5>
<pre>
- %X = inttoptr i32 255 to i32* <i>; yields zero extend on 64-bit</i>
- %X = inttoptr i32 255 to i32* <i>; yields no-op on 32-bit </i>
- %Y = inttoptr i16 0 to i32* <i>; yields zero extend on 32-bit</i>
+ %X = inttoptr i32 255 to i32* <i>; yields zero extension on 64-bit architecture</i>
+ %X = inttoptr i32 255 to i32* <i>; yields no-op on 32-bit architecture</i>
+ %Y = inttoptr i64 0 to i32* <i>; yields truncation on 32-bit architecture</i>
</pre>
</div>
<h5>Example:</h5>
<pre>
- %X = bitcast i8 255 to i8 <i>; yields i8 :-1</i>
+ %X = bitcast i8 255 to i8 <i>; yields i8 :-1</i>
%Y = bitcast i32* %x to sint* <i>; yields sint*:%x</i>
%Z = bitcast <2xint> %V to i64; <i>; yields i64: %V</i>
</pre>
</div>
<div class="doc_text">
<h5>Syntax:</h5>
-<pre> <result> = icmp <cond> <ty> <var1>, <var2>
-<i>; yields {i1}:result</i>
+<pre> <result> = icmp <cond> <ty> <var1>, <var2> <i>; yields {i1}:result</i>
</pre>
<h5>Overview:</h5>
<p>The '<tt>icmp</tt>' instruction returns a boolean value based on comparison
of its two integer operands.</p>
<h5>Arguments:</h5>
<p>The '<tt>icmp</tt>' instruction takes three operands. The first operand is
-the condition code which indicates the kind of comparison to perform. It is not
-a value, just a keyword. The possibilities for the condition code are:
+the condition code indicating the kind of comparison to perform. It is not
+a value, just a keyword. The possible condition code are:
<ol>
<li><tt>eq</tt>: equal</li>
<li><tt>ne</tt>: not equal </li>
<tt>true</tt> if <tt>var1</tt> is less than or equal to <tt>var2</tt>.</li>
</ol>
<p>If the operands are <a href="#t_pointer">pointer</a> typed, the pointer
-values are treated as integers and then compared.</p>
+values are compared as if they were integers.</p>
<h5>Example:</h5>
<pre> <result> = icmp eq i32 4, 5 <i>; yields: result=false</i>
</div>
<div class="doc_text">
<h5>Syntax:</h5>
-<pre> <result> = fcmp <cond> <ty> <var1>, <var2>
-<i>; yields {i1}:result</i>
+<pre> <result> = fcmp <cond> <ty> <var1>, <var2> <i>; yields {i1}:result</i>
</pre>
<h5>Overview:</h5>
<p>The '<tt>fcmp</tt>' instruction returns a boolean value based on comparison
of its floating point operands.</p>
<h5>Arguments:</h5>
<p>The '<tt>fcmp</tt>' instruction takes three operands. The first operand is
-the condition code which indicates the kind of comparison to perform. It is not
-a value, just a keyword. The possibilities for the condition code are:
+the condition code indicating the kind of comparison to perform. It is not
+a value, just a keyword. The possible condition code are:
<ol>
<li><tt>false</tt>: no comparison, always returns false</li>
<li><tt>oeq</tt>: ordered and equal</li>
<li><tt>uno</tt>: unordered (either nans)</li>
<li><tt>true</tt>: no comparison, always returns true</li>
</ol>
-<p>In the preceding, <i>ordered</i> means that neither operand is a QNAN while
+<p><i>Ordered</i> means that neither operand is a QNAN while
<i>unordered</i> means that either operand may be a QNAN.</p>
<p>The <tt>val1</tt> and <tt>val2</tt> arguments must be
<a href="#t_floating">floating point</a> typed. They must have identical
types.</p>
-<p>In the foregoing, <i>ordered</i> means that neither operand is a QNAN and
-<i>unordered</i> means that either operand is a QNAN.</p>
<h5>Semantics:</h5>
<p>The '<tt>fcmp</tt>' compares <tt>var1</tt> and <tt>var2</tt> according to
the condition code given as <tt>cond</tt>. The comparison performed always
<p>The '<tt>phi</tt>' instruction is used to implement the φ node in
the SSA graph representing the function.</p>
<h5>Arguments:</h5>
-<p>The type of the incoming values are specified with the first type
+<p>The type of the incoming values is specified with the first type
field. After this, the '<tt>phi</tt>' instruction takes a list of pairs
as arguments, with one pair for each predecessor basic block of the
current block. Only values of <a href="#t_firstclass">first class</a>
block and the PHI instructions: i.e. PHI instructions must be first in
a basic block.</p>
<h5>Semantics:</h5>
-<p>At runtime, the '<tt>phi</tt>' instruction logically takes on the
-value specified by the parameter, depending on which basic block we
-came from in the last <a href="#terminators">terminator</a> instruction.</p>
+<p>At runtime, the '<tt>phi</tt>' instruction logically takes on the value
+specified by the pair corresponding to the predecessor basic block that executed
+just prior to the current block.</p>
<h5>Example:</h5>
<pre>Loop: ; Infinite loop that counts from 0 on up...<br> %indvar = phi i32 [ 0, %LoopHeader ], [ %nextindvar, %Loop ]<br> %nextindvar = add i32 %indvar, 1<br> br label %Loop<br></pre>
</div>
href="#i_ret"><tt>ret</tt></a> instruction.
</li>
<li>
- <p>The optional "cconv" marker indicates which <a href="callingconv">calling
+ <p>The optional "cconv" marker indicates which <a href="#callingconv">calling
convention</a> the call should use. If none is specified, the call defaults
to using C calling conventions.
</li>
<pre>
%retval = call i32 %test(i32 %argc)
- call i32(i8 *, ...) *%printf(i8 * %msg, i32 12, i8 42);
+ call i32(i8 *, ...) *%printf(i8 * %msg, i32 12, i8 42);
%X = tail call i32 %foo()
%Y = tail call <a href="#callingconv">fastcc</a> i32 %foo()
</pre>
<p>This instruction takes a <tt>va_list*</tt> value and the type of
the argument. It returns a value of the specified argument type and
-increments the <tt>va_list</tt> to point to the next argument. Again, the
+increments the <tt>va_list</tt> to point to the next argument. The
actual type of <tt>va_list</tt> is target specific.</p>
<h5>Semantics:</h5>
<div class="doc_text">
<p>LLVM supports the notion of an "intrinsic function". These functions have
-well known names and semantics and are required to follow certain
-restrictions. Overall, these instructions represent an extension mechanism for
-the LLVM language that does not require changing all of the transformations in
-LLVM to add to the language (or the bytecode reader/writer, the parser,
-etc...).</p>
+well known names and semantics and are required to follow certain restrictions.
+Overall, these intrinsics represent an extension mechanism for the LLVM
+language that does not require changing all of the transformations in LLVM when
+adding to the language (or the bytecode reader/writer, the parser, etc...).</p>
<p>Intrinsic function names must all start with an "<tt>llvm.</tt>" prefix. This
-prefix is reserved in LLVM for intrinsic names; thus, functions may not be named
-this. Intrinsic functions must always be external functions: you cannot define
-the body of intrinsic functions. Intrinsic functions may only be used in call
-or invoke instructions: it is illegal to take the address of an intrinsic
-function. Additionally, because intrinsic functions are part of the LLVM
-language, it is required that they all be documented here if any are added.</p>
+prefix is reserved in LLVM for intrinsic names; thus, function names may not
+begin with this prefix. Intrinsic functions must always be external functions:
+you cannot define the body of intrinsic functions. Intrinsic functions may
+only be used in call or invoke instructions: it is illegal to take the address
+of an intrinsic function. Additionally, because intrinsic functions are part
+of the LLVM language, it is required if any are added that they be documented
+here.</p>
+
+<p>Some intrinsic functions can be overloaded, i.e., the intrinsic represents
+a family of functions that perform the same operation but on different data
+types. This is most frequent with the integer types. Since LLVM can represent
+over 8 million different integer types, there is a way to declare an intrinsic
+that can be overloaded based on its arguments. Such an intrinsic will have the
+names of its argument types encoded into its function name, each
+preceded by a period. For example, the <tt>llvm.ctpop</tt> function can take an
+integer of any width. This leads to a family of functions such as
+<tt>i32 @llvm.ctpop.i8(i8 %val)</tt> and <tt>i32 @llvm.ctpop.i29(i29 %val)</tt>.
+</p>
-<p>To learn how to add an intrinsic function, please see the <a
-href="ExtendingLLVM.html">Extending LLVM Guide</a>.
+<p>To learn how to add an intrinsic function, please see the
+<a href="ExtendingLLVM.html">Extending LLVM Guide</a>.
</p>
</div>
<p>All of these functions operate on arguments that use a
target-specific value type "<tt>va_list</tt>". The LLVM assembly
language reference manual does not define what this type is, so all
-transformations should be prepared to handle intrinsics with any type
-used.</p>
+transformations should be prepared to handle these functions regardless of
+the type used.</p>
<p>This example shows how the <a href="#i_va_arg"><tt>va_arg</tt></a>
instruction and the variable argument handling intrinsic functions are
used.</p>
+<div class="doc_code">
<pre>
define i32 @test(i32 %X, ...) {
; Initialize variable argument processing
- %ap = alloca i8 *
+ %ap = alloca i8*
%ap2 = bitcast i8** %ap to i8*
call void @llvm.va_start(i8* %ap2)
; Read a single integer argument
- %tmp = va_arg i8 ** %ap, i32
+ %tmp = va_arg i8** %ap, i32
; Demonstrate usage of llvm.va_copy and llvm.va_end
- %aq = alloca i8 *
+ %aq = alloca i8*
%aq2 = bitcast i8** %aq to i8*
- call void @llvm.va_copy(i8 *%aq2, i8* %ap2)
+ call void @llvm.va_copy(i8* %aq2, i8* %ap2)
call void @llvm.va_end(i8* %aq2)
; Stop processing of arguments.
</pre>
</div>
+</div>
+
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection">
- <a name="i_va_start">'<tt>llvm.va_start</tt>' Intrinsic</a>
+ <a name="int_va_start">'<tt>llvm.va_start</tt>' Intrinsic</a>
</div>
<P>The '<tt>llvm.va_start</tt>' intrinsic works just like the <tt>va_start</tt>
macro available in C. In a target-dependent way, it initializes the
-<tt>va_list</tt> element the argument points to, so that the next call to
+<tt>va_list</tt> element to which the argument points, so that the next call to
<tt>va_arg</tt> will produce the first variable argument passed to the function.
Unlike the C <tt>va_start</tt> macro, this intrinsic does not need to know the
-last argument of the function, the compiler can figure that out.</p>
+last argument of the function as the compiler can figure that out.</p>
</div>
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection">
- <a name="i_va_end">'<tt>llvm.va_end</tt>' Intrinsic</a>
+ <a name="int_va_end">'<tt>llvm.va_end</tt>' Intrinsic</a>
</div>
<div class="doc_text">
<pre> declare void @llvm.va_end(i8* <arglist>)<br></pre>
<h5>Overview:</h5>
-<p>The '<tt>llvm.va_end</tt>' intrinsic destroys <tt><arglist></tt>
-which has been initialized previously with <tt><a href="#i_va_start">llvm.va_start</a></tt>
+<p>The '<tt>llvm.va_end</tt>' intrinsic destroys <tt>*<arglist></tt>,
+which has been initialized previously with <tt><a href="#int_va_start">llvm.va_start</a></tt>
or <tt><a href="#i_va_copy">llvm.va_copy</a></tt>.</p>
<h5>Arguments:</h5>
-<p>The argument is a <tt>va_list</tt> to destroy.</p>
+<p>The argument is a pointer to a <tt>va_list</tt> to destroy.</p>
<h5>Semantics:</h5>
<p>The '<tt>llvm.va_end</tt>' intrinsic works just like the <tt>va_end</tt>
-macro available in C. In a target-dependent way, it destroys the <tt>va_list</tt>.
-Calls to <a href="#i_va_start"><tt>llvm.va_start</tt></a> and <a
- href="#i_va_copy"><tt>llvm.va_copy</tt></a> must be matched exactly
-with calls to <tt>llvm.va_end</tt>.</p>
+macro available in C. In a target-dependent way, it destroys the
+<tt>va_list</tt> element to which the argument points. Calls to <a
+href="#int_va_start"><tt>llvm.va_start</tt></a> and <a href="#int_va_copy">
+<tt>llvm.va_copy</tt></a> must be matched exactly with calls to
+<tt>llvm.va_end</tt>.</p>
</div>
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection">
- <a name="i_va_copy">'<tt>llvm.va_copy</tt>' Intrinsic</a>
+ <a name="int_va_copy">'<tt>llvm.va_copy</tt>' Intrinsic</a>
</div>
<div class="doc_text">
<h5>Overview:</h5>
-<p>The '<tt>llvm.va_copy</tt>' intrinsic copies the current argument position from
-the source argument list to the destination argument list.</p>
+<p>The '<tt>llvm.va_copy</tt>' intrinsic copies the current argument position
+from the source argument list to the destination argument list.</p>
<h5>Arguments:</h5>
<h5>Semantics:</h5>
-<p>The '<tt>llvm.va_copy</tt>' intrinsic works just like the <tt>va_copy</tt> macro
-available in C. In a target-dependent way, it copies the source
-<tt>va_list</tt> element into the destination list. This intrinsic is necessary
-because the <tt><a href="i_va_begin">llvm.va_begin</a></tt> intrinsic may be
-arbitrarily complex and require memory allocation, for example.</p>
+<p>The '<tt>llvm.va_copy</tt>' intrinsic works just like the <tt>va_copy</tt>
+macro available in C. In a target-dependent way, it copies the source
+<tt>va_list</tt> element into the destination <tt>va_list</tt> element. This
+intrinsic is necessary because the <tt><a href="#int_va_start">
+llvm.va_start</a></tt> intrinsic may be arbitrarily complex and require, for
+example, memory allocation.</p>
</div>
<p>
LLVM support for <a href="GarbageCollection.html">Accurate Garbage
Collection</a> requires the implementation and generation of these intrinsics.
-These intrinsics allow identification of <a href="#i_gcroot">GC roots on the
+These intrinsics allow identification of <a href="#int_gcroot">GC roots on the
stack</a>, as well as garbage collector implementations that require <a
-href="#i_gcread">read</a> and <a href="#i_gcwrite">write</a> barriers.
+href="#int_gcread">read</a> and <a href="#int_gcwrite">write</a> barriers.
Front-ends for type-safe garbage collected languages should generate these
intrinsics to make use of the LLVM garbage collectors. For more details, see <a
href="GarbageCollection.html">Accurate Garbage Collection with LLVM</a>.
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection">
- <a name="i_gcroot">'<tt>llvm.gcroot</tt>' Intrinsic</a>
+ <a name="int_gcroot">'<tt>llvm.gcroot</tt>' Intrinsic</a>
</div>
<div class="doc_text">
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection">
- <a name="i_gcread">'<tt>llvm.gcread</tt>' Intrinsic</a>
+ <a name="int_gcread">'<tt>llvm.gcread</tt>' Intrinsic</a>
</div>
<div class="doc_text">
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection">
- <a name="i_gcwrite">'<tt>llvm.gcwrite</tt>' Intrinsic</a>
+ <a name="int_gcwrite">'<tt>llvm.gcwrite</tt>' Intrinsic</a>
</div>
<div class="doc_text">
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection">
- <a name="i_returnaddress">'<tt>llvm.returnaddress</tt>' Intrinsic</a>
+ <a name="int_returnaddress">'<tt>llvm.returnaddress</tt>' Intrinsic</a>
</div>
<div class="doc_text">
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection">
- <a name="i_frameaddress">'<tt>llvm.frameaddress</tt>' Intrinsic</a>
+ <a name="int_frameaddress">'<tt>llvm.frameaddress</tt>' Intrinsic</a>
</div>
<div class="doc_text">
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection">
- <a name="i_stacksave">'<tt>llvm.stacksave</tt>' Intrinsic</a>
+ <a name="int_stacksave">'<tt>llvm.stacksave</tt>' Intrinsic</a>
</div>
<div class="doc_text">
<p>
The '<tt>llvm.stacksave</tt>' intrinsic is used to remember the current state of
-the function stack, for use with <a href="#i_stackrestore">
+the function stack, for use with <a href="#int_stackrestore">
<tt>llvm.stackrestore</tt></a>. This is useful for implementing language
features like scoped automatic variable sized arrays in C99.
</p>
<p>
This intrinsic returns a opaque pointer value that can be passed to <a
-href="#i_stackrestore"><tt>llvm.stackrestore</tt></a>. When an
+href="#int_stackrestore"><tt>llvm.stackrestore</tt></a>. When an
<tt>llvm.stackrestore</tt> intrinsic is executed with a value saved from
<tt>llvm.stacksave</tt>, it effectively restores the state of the stack to the
state it was in when the <tt>llvm.stacksave</tt> intrinsic executed. In
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection">
- <a name="i_stackrestore">'<tt>llvm.stackrestore</tt>' Intrinsic</a>
+ <a name="int_stackrestore">'<tt>llvm.stackrestore</tt>' Intrinsic</a>
</div>
<div class="doc_text">
<p>
The '<tt>llvm.stackrestore</tt>' intrinsic is used to restore the state of
the function stack to the state it was in when the corresponding <a
-href="#llvm.stacksave"><tt>llvm.stacksave</tt></a> intrinsic executed. This is
+href="#int_stacksave"><tt>llvm.stacksave</tt></a> intrinsic executed. This is
useful for implementing language features like scoped automatic variable sized
arrays in C99.
</p>
<h5>Semantics:</h5>
<p>
-See the description for <a href="#i_stacksave"><tt>llvm.stacksave</tt></a>.
+See the description for <a href="#int_stacksave"><tt>llvm.stacksave</tt></a>.
</p>
</div>
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection">
- <a name="i_prefetch">'<tt>llvm.prefetch</tt>' Intrinsic</a>
+ <a name="int_prefetch">'<tt>llvm.prefetch</tt>' Intrinsic</a>
</div>
<div class="doc_text">
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection">
- <a name="i_pcmarker">'<tt>llvm.pcmarker</tt>' Intrinsic</a>
+ <a name="int_pcmarker">'<tt>llvm.pcmarker</tt>' Intrinsic</a>
</div>
<div class="doc_text">
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection">
- <a name="i_readcyclecounter">'<tt>llvm.readcyclecounter</tt>' Intrinsic</a>
+ <a name="int_readcyclecounter">'<tt>llvm.readcyclecounter</tt>' Intrinsic</a>
</div>
<div class="doc_text">
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection">
- <a name="i_memcpy">'<tt>llvm.memcpy</tt>' Intrinsic</a>
+ <a name="int_memcpy">'<tt>llvm.memcpy</tt>' Intrinsic</a>
</div>
<div class="doc_text">
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection">
- <a name="i_memmove">'<tt>llvm.memmove</tt>' Intrinsic</a>
+ <a name="int_memmove">'<tt>llvm.memmove</tt>' Intrinsic</a>
</div>
<div class="doc_text">
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection">
- <a name="i_memset">'<tt>llvm.memset.*</tt>' Intrinsics</a>
+ <a name="int_memset">'<tt>llvm.memset.*</tt>' Intrinsics</a>
</div>
<div class="doc_text">
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection">
- <a name="i_sqrt">'<tt>llvm.sqrt.*</tt>' Intrinsic</a>
+ <a name="int_sqrt">'<tt>llvm.sqrt.*</tt>' Intrinsic</a>
</div>
<div class="doc_text">
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection">
- <a name="i_powi">'<tt>llvm.powi.*</tt>' Intrinsic</a>
+ <a name="int_powi">'<tt>llvm.powi.*</tt>' Intrinsic</a>
</div>
<div class="doc_text">
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection">
- <a name="i_bswap">'<tt>llvm.bswap.*</tt>' Intrinsics</a>
+ <a name="int_bswap">'<tt>llvm.bswap.*</tt>' Intrinsics</a>
</div>
<div class="doc_text">
<h5>Syntax:</h5>
+<p>This is an overloaded intrinsic function. You can use bswap on any integer
+type that is an even number of bytes (i.e. BitWidth % 16 == 0). Note the suffix
+that includes the type for the result and the operand.
<pre>
- declare i16 @llvm.bswap.i16(i16 <id>)
- declare i32 @llvm.bswap.i32(i32 <id>)
- declare i64 @llvm.bswap.i64(i64 <id>)
+ declare i16 @llvm.bswap.i16.i16(i16 <id>)
+ declare i32 @llvm.bswap.i32.i32(i32 <id>)
+ declare i64 @llvm.bswap.i64.i64(i64 <id>)
</pre>
<h5>Overview:</h5>
<p>
-The '<tt>llvm.bwsap</tt>' family of intrinsics is used to byteswap a 16, 32 or
-64 bit quantity. These are useful for performing operations on data that is not
-in the target's native byte order.
+The '<tt>llvm.bswap</tt>' family of intrinsics is used to byte swap integer
+values with an even number of bytes (positive multiple of 16 bits). These are
+useful for performing operations on data that is not in the target's native
+byte order.
</p>
<h5>Semantics:</h5>
<p>
-The <tt>llvm.bswap.16</tt> intrinsic returns an i16 value that has the high
+The <tt>llvm.bswap.16.i16</tt> intrinsic returns an i16 value that has the high
and low byte of the input i16 swapped. Similarly, the <tt>llvm.bswap.i32</tt>
intrinsic returns an i32 value that has the four bytes of the input i32
swapped, so that if the input bytes are numbered 0, 1, 2, 3 then the returned
-i32 will have its bytes in 3, 2, 1, 0 order. The <tt>llvm.bswap.i64</tt>
-intrinsic extends this concept to 64 bits.
+i32 will have its bytes in 3, 2, 1, 0 order. The <tt>llvm.bswap.i48.i48</tt>,
+<tt>llvm.bswap.i64.i64</tt> and other intrinsics extend this concept to
+additional even-byte lengths (6 bytes, 8 bytes and more, respectively).
</p>
</div>
<div class="doc_text">
<h5>Syntax:</h5>
+<p>This is an overloaded intrinsic. You can use llvm.ctpop on any integer bit
+width. Not all targets support all bit widths however.
<pre>
- declare i8 @llvm.ctpop.i8 (i8 <src>)
- declare i16 @llvm.ctpop.i16(i16 <src>)
+ declare i32 @llvm.ctpop.i8 (i8 <src>)
+ declare i32 @llvm.ctpop.i16(i16 <src>)
declare i32 @llvm.ctpop.i32(i32 <src>)
- declare i64 @llvm.ctpop.i64(i64 <src>)
+ declare i32 @llvm.ctpop.i64(i64 <src>)
+ declare i32 @llvm.ctpop.i256(i256 <src>)
</pre>
<h5>Overview:</h5>
<div class="doc_text">
<h5>Syntax:</h5>
+<p>This is an overloaded intrinsic. You can use <tt>llvm.ctlz</tt> on any
+integer bit width. Not all targets support all bit widths however.
<pre>
- declare i8 @llvm.ctlz.i8 (i8 <src>)
- declare i16 @llvm.ctlz.i16(i16 <src>)
+ declare i32 @llvm.ctlz.i8 (i8 <src>)
+ declare i32 @llvm.ctlz.i16(i16 <src>)
declare i32 @llvm.ctlz.i32(i32 <src>)
- declare i64 @llvm.ctlz.i64(i64 <src>)
+ declare i32 @llvm.ctlz.i64(i64 <src>)
+ declare i32 @llvm.ctlz.i256(i256 <src>)
</pre>
<h5>Overview:</h5>
<div class="doc_text">
<h5>Syntax:</h5>
+<p>This is an overloaded intrinsic. You can use <tt>llvm.cttz</tt> on any
+integer bit width. Not all targets support all bit widths however.
<pre>
- declare i8 @llvm.cttz.i8 (i8 <src>)
- declare i16 @llvm.cttz.i16(i16 <src>)
+ declare i32 @llvm.cttz.i8 (i8 <src>)
+ declare i32 @llvm.cttz.i16(i16 <src>)
declare i32 @llvm.cttz.i32(i32 <src>)
- declare i64 @llvm.cttz.i64(i64 <src>)
+ declare i32 @llvm.cttz.i64(i64 <src>)
+ declare i32 @llvm.cttz.i256(i256 <src>)
</pre>
<h5>Overview:</h5>
</p>
</div>
+<!-- _______________________________________________________________________ -->
+<div class="doc_subsubsection">
+ <a name="int_part_select">'<tt>llvm.part.select.*</tt>' Intrinsic</a>
+</div>
+
+<div class="doc_text">
+
+<h5>Syntax:</h5>
+<p>This is an overloaded intrinsic. You can use <tt>llvm.part.select</tt>
+on any integer bit width.
+<pre>
+ declare i17 @llvm.part.select.i17.i17 (i17 %val, i32 %loBit, i32 %hiBit)
+ declare i29 @llvm.part.select.i29.i29 (i29 %val, i32 %loBit, i32 %hiBit)
+</pre>
+
+<h5>Overview:</h5>
+<p>The '<tt>llvm.part.select</tt>' family of intrinsic functions selects a
+range of bits from an integer value and returns them in the same bit width as
+the original value.</p>
+
+<h5>Arguments:</h5>
+<p>The first argument, <tt>%val</tt> and the result may be integer types of
+any bit width but they must have the same bit width. The second and third
+arguments must be <tt>i32</tt> type since they specify only a bit index.</p>
+
+<h5>Semantics:</h5>
+<p>The operation of the '<tt>llvm.part.select</tt>' intrinsic has two modes
+of operation: forwards and reverse. If <tt>%loBit</tt> is greater than
+<tt>%hiBits</tt> then the intrinsic operates in reverse mode. Otherwise it
+operates in forward mode.</p>
+<p>In forward mode, this intrinsic is the equivalent of shifting <tt>%val</tt>
+right by <tt>%loBit</tt> bits and then ANDing it with a mask with
+only the <tt>%hiBit - %loBit</tt> bits set, as follows:</p>
+<ol>
+ <li>The <tt>%val</tt> is shifted right (LSHR) by the number of bits specified
+ by <tt>%loBits</tt>. This normalizes the value to the low order bits.</li>
+ <li>The <tt>%loBits</tt> value is subtracted from the <tt>%hiBits</tt> value
+ to determine the number of bits to retain.</li>
+ <li>A mask of the retained bits is created by shifting a -1 value.</li>
+ <li>The mask is ANDed with <tt>%val</tt> to produce the result.
+</ol>
+<p>In reverse mode, a similar computation is made except that the bits are
+returned in the reverse order. So, for example, if <tt>X</tt> has the value
+<tt>i16 0x0ACF (101011001111)</tt> and we apply
+<tt>part.select(i16 X, 8, 3)</tt> to it, we get back the value
+<tt>i16 0x0026 (000000100110)</tt>.</p>
+</div>
+
+<div class="doc_subsubsection">
+ <a name="int_part_set">'<tt>llvm.part.set.*</tt>' Intrinsic</a>
+</div>
+
+<div class="doc_text">
+
+<h5>Syntax:</h5>
+<p>This is an overloaded intrinsic. You can use <tt>llvm.part.set</tt>
+on any integer bit width.
+<pre>
+ declare i17 @llvm.part.set.i17.i17.i9 (i17 %val, i9 %repl, i32 %lo, i32 %hi)
+ declare i29 @llvm.part.set.i29.i29.i9 (i29 %val, i9 %repl, i32 %lo, i32 %hi)
+</pre>
+
+<h5>Overview:</h5>
+<p>The '<tt>llvm.part.set</tt>' family of intrinsic functions replaces a range
+of bits in an integer value with another integer value. It returns the integer
+with the replaced bits.</p>
+
+<h5>Arguments:</h5>
+<p>The first argument, <tt>%val</tt> and the result may be integer types of
+any bit width but they must have the same bit width. <tt>%val</tt> is the value
+whose bits will be replaced. The second argument, <tt>%repl</tt> may be an
+integer of any bit width. The third and fourth arguments must be <tt>i32</tt>
+type since they specify only a bit index.</p>
+
+<h5>Semantics:</h5>
+<p>The operation of the '<tt>llvm.part.set</tt>' intrinsic has two modes
+of operation: forwards and reverse. If <tt>%lo</tt> is greater than
+<tt>%hi</tt> then the intrinsic operates in reverse mode. Otherwise it
+operates in forward mode.</p>
+<p>For both modes, the <tt>%repl</tt> value is prepared for use by either
+truncating it down to the size of the replacement area or zero extending it
+up to that size.</p>
+<p>In forward mode, the bits between <tt>%lo</tt> and <tt>%hi</tt> (inclusive)
+are replaced with corresponding bits from <tt>%repl</tt>. That is the 0th bit
+in <tt>%repl</tt> replaces the <tt>%lo</tt>th bit in <tt>%val</tt> and etc. up
+to the <tt>%hi</tt>th bit.
+<p>In reverse mode, a similar computation is made except that the bits are
+reversed. That is, the <tt>0</tt>th bit in <tt>%repl</tt> replaces the
+<tt>%hi</tt> bit in <tt>%val</tt> and etc. down to the <tt>%lo</tt>th bit.
+<h5>Examples:</h5>
+<pre>
+ llvm.part.set(0xFFFF, 0, 4, 7) -> 0xFF0F
+ llvm.part.set(0xFFFF, 0, 7, 4) -> 0xFF0F
+ llvm.part.set(0xFFFF, 1, 7, 4) -> 0xFF8F
+ llvm.part.set(0xFFFF, F, 8, 3) -> 0xFFE7
+ llvm.part.set(0xFFFF, 0, 3, 8) -> 0xFE07
+</pre>
+</div>
+
<!-- ======================================================================= -->
<div class="doc_subsection">
<a name="int_debugger">Debugger Intrinsics</a>
Handling</a> document. </p>
</div>
+<!-- ======================================================================= -->
+<div class="doc_subsection">
+ <a name="int_general">General Intrinsics</a>
+</div>
+
+<div class="doc_text">
+<p> This class of intrinsics is designed to be generic and has
+no specific purpose. </p>
+</div>
+
+<!-- _______________________________________________________________________ -->
+<div class="doc_subsubsection">
+ <a name="int_var_annotation">'<tt>llvm.var.annotation</tt>' Intrinsic</a>
+</div>
+
+<div class="doc_text">
+
+<h5>Syntax:</h5>
+<pre>
+ declare void @llvm.var.annotation(i8* <val>, i8* <str>, i8* <str>, i32 <int> )
+</pre>
+
+<h5>Overview:</h5>
+
+<p>
+The '<tt>llvm.var.annotation</tt>' intrinsic
+</p>
+
+<h5>Arguments:</h5>
+
+<p>
+The first argument is a pointer to a value, the second is a pointer to a
+global string, the third is a pointer to a global string which is the source
+file name, and the last argument is the line number.
+</p>
+
+<h5>Semantics:</h5>
+
+<p>
+This intrinsic allows annotation of local variables with arbitrary strings.
+This can be useful for special purpose optimizations that want to look for these
+ annotations. These have no other defined use, they are ignored by code
+ generation and optimization.
+</div>
+
<!-- *********************************************************************** -->
<hr>
projects / oota-llvm.git / blobdiff