Changes in directory llvm/docs:
LangRef.html updated: 1.180 -> 1.181 --- Log message: For PR950: http://llvm.org/PR950 : Update for signless integer types: 1. Replace [us]byte with i8 2. Replace [u]short with i16 3. Replace [u]int with i32 4. Replace [u]long with i64 5. Document the "define" keyword and use it in all examples. 6. Document parameter attributes and how they affect function types. --- Diffs of the changes: (+307 -277) LangRef.html | 584 +++++++++++++++++++++++++++++++---------------------------- 1 files changed, 307 insertions(+), 277 deletions(-) Index: llvm/docs/LangRef.html diff -u llvm/docs/LangRef.html:1.180 llvm/docs/LangRef.html:1.181 --- llvm/docs/LangRef.html:1.180 Thu Dec 28 10:55:55 2006 +++ llvm/docs/LangRef.html Sun Dec 31 01:07:53 2006 @@ -24,6 +24,7 @@ <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="#paramattrs">Parameter Attributes</a></li> <li><a href="#moduleasm">Module-Level Inline Assembly</a></li> </ol> </li> @@ -248,7 +249,7 @@ following instruction is syntactically okay, but not well formed:</p> <pre> - %x = <a href="#i_add">add</a> int 1, %x + %x = <a href="#i_add">add</a> i32 1, %x </pre> <p>...because the definition of <tt>%x</tt> does not dominate all of @@ -296,7 +297,7 @@ ('<tt><a href="#i_add">add</a></tt>', '<tt><a href="#i_bitcast">bitcast</a></tt>', '<tt><a href="#i_ret">ret</a></tt>', etc...), for primitive type names ('<tt><a -href="#t_void">void</a></tt>', '<tt><a href="#t_uint">uint</a></tt>', etc...), +href="#t_void">void</a></tt>', '<tt><a href="#t_primitive">i32</a></tt>', etc...), and others. These reserved words cannot conflict with variable names, because none of them start with a '%' character.</p> @@ -306,21 +307,21 @@ <p>The easy way:</p> <pre> - %result = <a href="#i_mul">mul</a> uint %X, 8 + %result = <a href="#i_mul">mul</a> i32 %X, 8 </pre> <p>After strength reduction:</p> <pre> - %result = <a href="#i_shl">shl</a> uint %X, ubyte 3 + %result = <a href="#i_shl">shl</a> i32 %X, i8 3 </pre> <p>And the hard way:</p> <pre> - <a href="#i_add">add</a> uint %X, %X <i>; yields {uint}:%0</i> - <a href="#i_add">add</a> uint %0, %0 <i>; yields {uint}:%1</i> - %result = <a href="#i_add">add</a> uint %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> <p>This last way of multiplying <tt>%X</tt> by 8 illustrates several @@ -364,25 +365,25 @@ <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 sbyte]</a> c"hello world\0A\00" <i>; [13 x sbyte]*</i> + 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> int %puts(sbyte*) <i>; int(sbyte*)* </i> +<a href="#functionstructure">declare</a> i32 %puts(i8 *) <i>; i32(i8 *)* </i> <i>; Global variable / Function body section separator</i> implementation <i>; Definition of main function</i> -int %main() { <i>; int()* </i> - <i>; Convert [13x sbyte]* to sbyte *...</i> +define i32 %main() { <i>; i32()* </i> + <i>; Convert [13x i8 ]* to i8 *...</i> %cast210 = <a - href="#i_getelementptr">getelementptr</a> [13 x sbyte]* %.LC0, long 0, long 0 <i>; sbyte*</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> int %puts(sbyte* %cast210) <i>; int</i> + href="#i_call">call</a> i32 %puts(i8 * %cast210) <i>; i32</i> <a - href="#i_ret">ret</a> int 0<br>}<br></pre> + href="#i_ret">ret</a> i32 0<br>}<br></pre> <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>" @@ -440,7 +441,7 @@ <dd>"<tt>weak</tt>" linkage is exactly the same as <tt>linkonce</tt> linkage, except that unreferenced <tt>weak</tt> globals may not be discarded. This is - used to implement constructs in C such as "<tt>int X;</tt>" at global scope. + used to implement constructs in C such as "<tt>i32 X;</tt>" at global scope. </dd> <dt><tt><b><a name="linkage_appending">appending</a></b></tt>: </dt> @@ -646,14 +647,18 @@ <div class="doc_text"> -<p>LLVM function definitions consist of an optional <a href="#linkage">linkage -type</a>, an optional <a href="#callingconv">calling convention</a>, a return -type, a function name, a (possibly empty) argument list, an optional section, -an optional alignment, an opening curly brace, -a list of basic blocks, and a closing curly brace. LLVM function declarations -are defined with the "<tt>declare</tt>" keyword, an optional <a -href="#callingconv">calling convention</a>, a return type, a function name, -a possibly empty list of arguments, and an optional alignment.</p> +<p>LLVM function definitions consist of the "<tt>define</tt>" keyord, +an optional <a href="#linkage">linkage type</a>, an optional +<a href="#callingconv">calling convention</a>, a return type, an optional +<a href="#paramattrs">parameter attribute</a> for the return type, a function +name, a (possibly empty) argument list (each with optional +<a href="#paramattrs">parameter attributes</a>, an optional section, an optional +alignment, an opening curly brace, a list of basic blocks, and a closing curly +brace. LLVM function declarations +are consist of the "<tt>declare</tt>" keyword, an optional <a + href="#callingconv">calling convention</a>, a return type, an optional +<a href="#paramattrs">parameter attribute</a> for the return type, a function +name, a possibly empty list of arguments, and an optional alignment.</p> <p>A function definition contains a list of basic blocks, forming the CFG for the function. Each basic block may optionally start with a label (giving the @@ -684,6 +689,42 @@ </div> <!-- ======================================================================= --> +<div class="doc_subsection"><a name="paramattrs">Parameter Attributes</a></div> +<div class="doc_text"> + <p>The return type and each parameter of a function type may have a set of + <i>parameter attributes</i> associated with them. Parameter attributes are + used to communicate additional information about the result or parameters of + a function. Parameter attributes are considered to be part of the function + type so two functions types that differ only by the parameter attributes + are different function types.</p> + + <p>Parameter attributes consist of a at sign (@) followed by either a single + keyword or a comma separate list of keywords enclosed in parentheses. For + example:<pre> + %someFunc = i16 @zext (i8 @(sext) %someParam) + %someFunc = i16 @zext (i8 @zext %someParam) + </pre>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).</p> + + <p>Currently, only the following parameter attributes are defined: + <dl> + <dt><tt>@zext</tt></dt> + <dd>This indicates that the parameter should be zero extended just before + a call to this function.</dd> + <dt><tt>@sext</tt></dt> + <dd>This indicates that the parameter should be sign extended just before + a call to this function.</dd> + </dl></p> + + <p>The current motivation for parameter attributes is to enable the sign and + zero extend information necessary for the C calling convention to be passed + from the front end to LLVM. The <tt>@zext</tt> and <tt>@sext</tt> attributes + are used by the code generator to perform the required extension. However, + parameter attributes are an orthogonal feature to calling conventions and + may be used for other purposes in the future.</p> +</div> + +<!-- ======================================================================= --> <div class="doc_subsection"> <a name="moduleasm">Module-Level Inline Assembly</a> </div> @@ -742,10 +783,8 @@ <tbody> <tr><th>Type</th><th>Description</th></tr> <tr><td><tt>void</tt></td><td>No value</td></tr> - <tr><td><tt>ubyte</tt></td><td>Unsigned 8-bit value</td></tr> - <tr><td><tt>ushort</tt></td><td>Unsigned 16-bit value</td></tr> - <tr><td><tt>uint</tt></td><td>Unsigned 32-bit value</td></tr> - <tr><td><tt>ulong</tt></td><td>Unsigned 64-bit value</td></tr> + <tr><td><tt>i8</tt></td><td>Signless 8-bit value</td></tr> + <tr><td><tt>i32</tt></td><td>Signless 32-bit value</td></tr> <tr><td><tt>float</tt></td><td>32-bit floating point value</td></tr> <tr><td><tt>label</tt></td><td>Branch destination</td></tr> </tbody> @@ -756,11 +795,9 @@ <tbody> <tr><th>Type</th><th>Description</th></tr> <tr><td><tt>bool</tt></td><td>True or False value</td></tr> - <tr><td><tt>sbyte</tt></td><td>Signed 8-bit value</td></tr> - <tr><td><tt>short</tt></td><td>Signed 16-bit value</td></tr> - <tr><td><tt>int</tt></td><td>Signed 32-bit value</td></tr> - <tr><td><tt>long</tt></td><td>Signed 64-bit value</td></tr> - <tr><td><tt>double</tt></td><td>64-bit floating point value</td></tr> + <tr><td><tt>i16</tt></td><td>Signless 16-bit value</td></tr> + <tr><td><tt>i64</tt></td><td>Signless 64-bit value</td></tr> + <tr><td><tt>double</tt></td><td>64-bit floating point value</td></tr> </tbody> </table> </td> @@ -779,20 +816,12 @@ <tbody> <tr><th>Classification</th><th>Types</th></tr> <tr> - <td><a name="t_signed">signed</a></td> - <td><tt>sbyte, short, int, long, float, double</tt></td> - </tr> - <tr> - <td><a name="t_unsigned">unsigned</a></td> - <td><tt>ubyte, ushort, uint, ulong</tt></td> - </tr> - <tr> <td><a name="t_integer">integer</a></td> - <td><tt>ubyte, sbyte, ushort, short, uint, int, ulong, long</tt></td> + <td><tt>i8, i16, i32, i64</tt></td> </tr> <tr> <td><a name="t_integral">integral</a></td> - <td><tt>bool, ubyte, sbyte, ushort, short, uint, int, ulong, long</tt> + <td><tt>bool, i8, i16, i32, i64</tt> </td> </tr> <tr> @@ -801,9 +830,9 @@ </tr> <tr> <td><a name="t_firstclass">first class</a></td> - <td><tt>bool, ubyte, sbyte, ushort, short, uint, int, ulong, long,<br> - float, double, <a href="#t_pointer">pointer</a>, - <a href="#t_packed">packed</a></tt></td> + <td><tt>bool, i8, i16, i32, i64, float, double, <br/> + <a href="#t_pointer">pointer</a>,<a href="#t_packed">packed</a></tt> + </td> </tr> </tbody> </table> @@ -851,9 +880,9 @@ <table class="layout"> <tr class="layout"> <td class="left"> - <tt>[40 x int ]</tt><br/> - <tt>[41 x int ]</tt><br/> - <tt>[40 x uint]</tt><br/> + <tt>[40 x i32 ]</tt><br/> + <tt>[41 x i32 ]</tt><br/> + <tt>[40 x i32]</tt><br/> </td> <td class="left"> Array of 40 integer values.<br/> @@ -866,9 +895,9 @@ <table class="layout"> <tr class="layout"> <td class="left"> - <tt>[3 x [4 x int]]</tt><br/> + <tt>[3 x [4 x i32]]</tt><br/> <tt>[12 x [10 x float]]</tt><br/> - <tt>[2 x [3 x [4 x uint]]]</tt><br/> + <tt>[2 x [3 x [4 x i32]]]</tt><br/> </td> <td class="left"> 3x4 array of integer values.<br/> @@ -883,7 +912,7 @@ LLVM (e.g. it is illegal to access the 5th element of a 3 element array). As a special case, however, zero length arrays are recognized to be variable length. This allows implementation of 'pascal style arrays' with the LLVM -type "{ int, [0 x float]}", for example.</p> +type "{ i32, [0 x float]}", for example.</p> </div> @@ -910,17 +939,18 @@ <table class="layout"> <tr class="layout"> <td class="left"> - <tt>int (int)</tt> <br/> - <tt>float (int, int *) *</tt><br/> - <tt>int (sbyte *, ...)</tt><br/> + <tt>i32 (i32)</tt> <br/> + <tt>float (i16 @sext, i32 *) *</tt><br/> + <tt>i32 (i8*, ...)</tt><br/> </td> <td class="left"> - function taking an <tt>int</tt>, returning an <tt>int</tt><br/> + function taking an <tt>i32</tt>, returning an <tt>i32</tt><br/> <a href="#t_pointer">Pointer</a> to a function that takes an - <tt>int</tt> and a <a href="#t_pointer">pointer</a> to <tt>int</tt>, - returning <tt>float</tt>.<br/> - A vararg function that takes at least one <a href="#t_pointer">pointer</a> - to <tt>sbyte</tt> (signed char in C), which returns an integer. This is + <tt>i16</tt> that should be sign extended and a + <a href="#t_pointer">pointer</a> to <tt>i32</tt>, returning + <tt>float</tt>.<br/> + A vararg function that takes at least one <a href="#t_pointer">pointer</a> + to <tt>i8 </tt> (signed char in C), which returns an integer. This is the signature for <tt>printf</tt> in LLVM.<br/> </td> </tr> @@ -945,14 +975,14 @@ <table class="layout"> <tr class="layout"> <td class="left"> - <tt>{ int, int, int }</tt><br/> - <tt>{ float, int (int) * }</tt><br/> + <tt>{ i32, i32, i32 }</tt><br/> + <tt>{ float, i32 (i32) * }</tt><br/> </td> <td class="left"> - a triple of three <tt>int</tt> values<br/> + 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>int</tt>, returning an <tt>int</tt>.<br/> + that takes an <tt>i32</tt>, returning an <tt>i32</tt>.<br/> </td> </tr> </table> @@ -977,14 +1007,14 @@ <table class="layout"> <tr class="layout"> <td class="left"> - <tt> < { int, int, int } > </tt><br/> - <tt> < { float, int (int) * } > </tt><br/> + <tt> < { i32, i32, i32 } > </tt><br/> + <tt> < { float, i32 (i32) * } > </tt><br/> </td> <td class="left"> - a triple of three <tt>int</tt> values<br/> + 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>int</tt>, returning an <tt>int</tt>.<br/> + that takes an <tt>i32</tt>, returning an <tt>i32</tt>.<br/> </td> </tr> </table> @@ -1002,15 +1032,15 @@ <table class="layout"> <tr class="layout"> <td class="left"> - <tt>[4x int]*</tt><br/> - <tt>int (int *) *</tt><br/> + <tt>[4x i32]*</tt><br/> + <tt>i32 (i32 *) *</tt><br/> </td> <td class="left"> A <a href="#t_pointer">pointer</a> to <a href="#t_array">array</a> of - four <tt>int</tt> values<br/> + four <tt>i32</tt> values<br/> A <a href="#t_pointer">pointer</a> to a <a - href="#t_function">function</a> that takes an <tt>int*</tt>, returning an - <tt>int</tt>.<br/> + href="#t_function">function</a> that takes an <tt>i32*</tt>, returning an + <tt>i32</tt>.<br/> </td> </tr> </table> @@ -1044,9 +1074,9 @@ <table class="layout"> <tr class="layout"> <td class="left"> - <tt><4 x int></tt><br/> + <tt><4 x i32></tt><br/> <tt><8 x float></tt><br/> - <tt><2 x uint></tt><br/> + <tt><2 x i32></tt><br/> </td> <td class="left"> Packed vector of 4 integer values.<br/> @@ -1158,8 +1188,8 @@ <dd>Structure constants are represented with notation similar to structure type definitions (a comma separated list of elements, surrounded by braces - (<tt>{}</tt>)). For example: "<tt>{ int 4, float 17.0, int* %G }</tt>", - where "<tt>%G</tt>" is declared as "<tt>%G = external global int</tt>". Structure constants + (<tt>{}</tt>)). For example: "<tt>{ i32 4, float 17.0, i32* %G }</tt>", + where "<tt>%G</tt>" is declared as "<tt>%G = external global i32</tt>". Structure constants must have <a href="#t_struct">structure type</a>, and the number and types of elements must match those specified by the type. </dd> @@ -1168,7 +1198,7 @@ <dd>Array constants are represented with notation similar to array type definitions (a comma separated list of elements, surrounded by square brackets - (<tt>[]</tt>)). For example: "<tt>[ int 42, int 11, int 74 ]</tt>". Array + (<tt>[]</tt>)). For example: "<tt>[ i32 42, i32 11, i32 74 ]</tt>". Array constants must have <a href="#t_array">array type</a>, and the number and types of elements must match those specified by the type. </dd> @@ -1177,8 +1207,8 @@ <dd>Packed constants are represented with notation similar to packed type definitions (a comma separated list of elements, surrounded by - less-than/greater-than's (<tt><></tt>)). For example: "<tt>< int 42, - int 11, int 74, int 100 ></tt>". Packed constants must have <a + less-than/greater-than's (<tt><></tt>)). For example: "<tt>< i32 42, + i32 11, i32 74, i32 100 ></tt>". Packed constants must have <a href="#t_packed">packed type</a>, and the number and types of elements must match those specified by the type. </dd> @@ -1210,9 +1240,9 @@ file:</p> <pre> - %X = global int 17 - %Y = global int 42 - %Z = global [2 x int*] [ int* %X, int* %Y ] + %X = global i32 17 + %Y = global i32 42 + %Z = global [2 x i32*] [ i32* %X, i32* %Y ] </pre> </div> @@ -1368,7 +1398,7 @@ </p> <pre> - int(int) asm "bswap $0", "=r,r" + i32 (i32) asm "bswap $0", "=r,r" </pre> <p> @@ -1377,7 +1407,7 @@ </p> <pre> - %X = call int asm "<a href="#i_bswap">bswap</a> $0", "=r,r"(int %Y) + %X = call i32 asm "<a href="#i_bswap">bswap</a> $0", "=r,r"(i32 %Y) </pre> <p> @@ -1463,7 +1493,7 @@ returns a value, that value shall set the call or invoke instruction's return value.</p> <h5>Example:</h5> -<pre> ret int 5 <i>; Return an integer value of 5</i> +<pre> ret i32 5 <i>; Return an integer value of 5</i> ret void <i>; Return from a void function</i> </pre> </div> @@ -1489,8 +1519,8 @@ to the '<tt>iftrue</tt>' <tt>label</tt> argument. If "cond" is <tt>false</tt>, control flows to the '<tt>iffalse</tt>' <tt>label</tt> argument.</p> <h5>Example:</h5> -<pre>Test:<br> %cond = <a href="#i_icmp">icmp</a> eq, int %a, %b<br> br bool %cond, label %IfEqual, label %IfUnequal<br>IfEqual:<br> <a - href="#i_ret">ret</a> int 1<br>IfUnequal:<br> <a href="#i_ret">ret</a> int 0<br></pre> +<pre>Test:<br> %cond = <a href="#i_icmp">icmp</a> eq, i32 %a, %b<br> br bool %cond, label %IfEqual, label %IfUnequal<br>IfEqual:<br> <a + href="#i_ret">ret</a> i32 1<br>IfUnequal:<br> <a href="#i_ret">ret</a> i32 0<br></pre> </div> <!-- _______________________________________________________________________ --> <div class="doc_subsubsection"> @@ -1538,16 +1568,16 @@ <pre> <i>; Emulate a conditional br instruction</i> - %Val = <a href="#i_zext">zext</a> bool %value to int - switch int %Val, label %truedest [int 0, label %falsedest ] + %Val = <a href="#i_zext">zext</a> bool %value to i32 + switch i32 %Val, label %truedest [i32 0, label %falsedest ] <i>; Emulate an unconditional br instruction</i> - switch uint 0, label %dest [ ] + switch i32 0, label %dest [ ] <i>; Implement a jump table:</i> - switch uint %val, label %otherwise [ uint 0, label %onzero - uint 1, label %onone - uint 2, label %ontwo ] + switch i32 %val, label %otherwise [ i32 0, label %onzero + i32 1, label %onone + i32 2, label %ontwo ] </pre> </div> @@ -1622,10 +1652,10 @@ <h5>Example:</h5> <pre> - %retval = invoke int %Test(int 15) to label %Continue - unwind label %TestCleanup <i>; {int}:retval set</i> - %retval = invoke <a href="#callingconv">coldcc</a> int %Test(int 15) to label %Continue - unwind label %TestCleanup <i>; {int}: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> @@ -1714,7 +1744,7 @@ <p>The value produced is the integer or floating point sum of the two operands.</p> <h5>Example:</h5> -<pre> <result> = add int 4, %var <i>; yields {int}:result = 4 + %var</i> +<pre> <result> = add i32 4, %var <i>; yields {i32}:result = 4 + %var</i> </pre> </div> <!-- _______________________________________________________________________ --> @@ -1739,8 +1769,8 @@ <p>The value produced is the integer or floating point difference of the two operands.</p> <h5>Example:</h5> -<pre> <result> = sub int 4, %var <i>; yields {int}:result = 4 - %var</i> - <result> = sub int 0, %val <i>; yields {int}:result = -%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> <!-- _______________________________________________________________________ --> @@ -1765,7 +1795,7 @@ <p>There is no signed vs unsigned multiplication. The appropriate action is taken based on the type of the operand.</p> <h5>Example:</h5> -<pre> <result> = mul int 4, %var <i>; yields {int}:result = 4 * %var</i> +<pre> <result> = mul i32 4, %var <i>; yields {i32}:result = 4 * %var</i> </pre> </div> <!-- _______________________________________________________________________ --> @@ -1788,7 +1818,7 @@ instruction always performs an unsigned division operation, regardless of whether the arguments are unsigned or not.</p> <h5>Example:</h5> -<pre> <result> = udiv uint 4, %var <i>; yields {uint}:result = 4 / %var</i> +<pre> <result> = udiv i32 4, %var <i>; yields {i32}:result = 4 / %var</i> </pre> </div> <!-- _______________________________________________________________________ --> @@ -1811,7 +1841,7 @@ instruction always performs a signed division operation, regardless of whether the arguments are signed or not.</p> <h5>Example:</h5> -<pre> <result> = sdiv int 4, %var <i>; yields {int}:result = 4 / %var</i> +<pre> <result> = sdiv i32 4, %var <i>; yields {i32}:result = 4 / %var</i> </pre> </div> <!-- _______________________________________________________________________ --> @@ -1854,7 +1884,7 @@ This instruction always performs an unsigned division to get the remainder, regardless of whether the arguments are unsigned or not.</p> <h5>Example:</h5> -<pre> <result> = urem uint 4, %var <i>; yields {uint}:result = 4 % %var</i> +<pre> <result> = urem i32 4, %var <i>; yields {i32}:result = 4 % %var</i> </pre> </div> @@ -1880,7 +1910,7 @@ href="http://mathforum.org/dr.math/problems/anne.4.28.99.html">The Math Forum</a>.</p> <h5>Example:</h5> -<pre> <result> = srem int 4, %var <i>; yields {int}:result = 4 % %var</i> +<pre> <result> = srem i32 4, %var <i>; yields {i32}:result = 4 % %var</i> </pre> </div> @@ -1965,9 +1995,9 @@ </table> </div> <h5>Example:</h5> -<pre> <result> = and int 4, %var <i>; yields {int}:result = 4 & %var</i> - <result> = and int 15, 40 <i>; yields {int}:result = 8</i> - <result> = and int 4, 8 <i>; yields {int}:result = 0</i> +<pre> <result> = and i32 4, %var <i>; yields {i32}:result = 4 & %var</i> + <result> = and i32 15, 40 <i>; yields {i32}:result = 8</i> + <result> = and i32 4, 8 <i>; yields {i32}:result = 0</i> </pre> </div> <!-- _______________________________________________________________________ --> @@ -2018,9 +2048,9 @@ </table> </div> <h5>Example:</h5> -<pre> <result> = or int 4, %var <i>; yields {int}:result = 4 | %var</i> - <result> = or int 15, 40 <i>; yields {int}:result = 47</i> - <result> = or int 4, 8 <i>; yields {int}:result = 12</i> +<pre> <result> = or i32 4, %var <i>; yields {i32}:result = 4 | %var</i> + <result> = or i32 15, 40 <i>; yields {i32}:result = 47</i> + <result> = or i32 4, 8 <i>; yields {i32}:result = 12</i> </pre> </div> <!-- _______________________________________________________________________ --> @@ -2074,10 +2104,10 @@ </div> <p> </p> <h5>Example:</h5> -<pre> <result> = xor int 4, %var <i>; yields {int}:result = 4 ^ %var</i> - <result> = xor int 15, 40 <i>; yields {int}:result = 39</i> - <result> = xor int 4, 8 <i>; yields {int}:result = 12</i> - <result> = xor int %V, -1 <i>; yields {int}:result = ~%V</i> +<pre> <result> = xor i32 4, %var <i>; yields {i32}:result = 4 ^ %var</i> + <result> = xor i32 15, 40 <i>; yields {i32}:result = 39</i> + <result> = xor i32 4, 8 <i>; yields {i32}:result = 12</i> + <result> = xor i32 %V, -1 <i>; yields {i32}:result = ~%V</i> </pre> </div> <!-- _______________________________________________________________________ --> @@ -2085,21 +2115,21 @@ Instruction</a> </div> <div class="doc_text"> <h5>Syntax:</h5> -<pre> <result> = shl <ty> <var1>, ubyte <var2> <i>; yields {ty}:result</i> +<pre> <result> = shl <ty> <var1>, i8 <var2> <i>; yields {ty}:result</i> </pre> <h5>Overview:</h5> <p>The '<tt>shl</tt>' instruction returns the first operand shifted to the left a specified number of bits.</p> <h5>Arguments:</h5> <p>The first argument to the '<tt>shl</tt>' instruction must be an <a - href="#t_integer">integer</a> type. The second argument must be an '<tt>ubyte</tt>' + href="#t_integer">integer</a> type. The second argument must be an '<tt>i8</tt>' type.</p> <h5>Semantics:</h5> <p>The value produced is <tt>var1</tt> * 2<sup><tt>var2</tt></sup>.</p> <h5>Example:</h5> -<pre> <result> = shl int 4, ubyte %var <i>; yields {int}:result = 4 << %var</i> - <result> = shl int 4, ubyte 2 <i>; yields {int}:result = 16</i> - <result> = shl int 1, ubyte 10 <i>; yields {int}:result = 1024</i> +<pre> <result> = shl i32 4, i8 %var <i>; yields {i32}:result = 4 << %var</i> + <result> = shl i32 4, i8 2 <i>; yields {i32}:result = 16</i> + <result> = shl i32 1, i8 10 <i>; yields {i32}:result = 1024</i> </pre> </div> <!-- _______________________________________________________________________ --> @@ -2107,7 +2137,7 @@ Instruction</a> </div> <div class="doc_text"> <h5>Syntax:</h5> -<pre> <result> = lshr <ty> <var1>, ubyte <var2> <i>; yields {ty}:result</i> +<pre> <result> = lshr <ty> <var1>, i8 <var2> <i>; yields {ty}:result</i> </pre> <h5>Overview:</h5> @@ -2116,7 +2146,7 @@ <h5>Arguments:</h5> <p>The first argument to the '<tt>lshr</tt>' instruction must be an <a - href="#t_integer">integer</a> type. The second argument must be an '<tt>ubyte</tt>' type.</p> + href="#t_integer">integer</a> type. The second argument must be an '<tt>i8</tt>' type.</p> <h5>Semantics:</h5> <p>This instruction always performs a logical shift right operation, regardless @@ -2125,10 +2155,10 @@ <h5>Example:</h5> <pre> - <result> = lshr uint 4, ubyte 1 <i>; yields {uint}:result = 2</i> - <result> = lshr int 4, ubyte 2 <i>; yields {uint}:result = 1</i> - <result> = lshr sbyte 4, ubyte 3 <i>; yields {sbyte}:result = 0</i> - <result> = lshr sbyte -2, ubyte 1 <i>; yields {sbyte}:result = 0x7FFFFFFF </i> + <result> = lshr i32 4, i8 1 <i>; yields {i32}:result = 2</i> + <result> = lshr i32 4, i8 2 <i>; yields {i32}:result = 1</i> + <result> = lshr i8 4, i8 3 <i>; yields {i8 }:result = 0</i> + <result> = lshr i8 -2, i8 1 <i>; yields {i8 }:result = 0x7FFFFFFF </i> </pre> </div> @@ -2138,7 +2168,7 @@ <div class="doc_text"> <h5>Syntax:</h5> -<pre> <result> = ashr <ty> <var1>, ubyte <var2> <i>; yields {ty}:result</i> +<pre> <result> = ashr <ty> <var1>, i8 <var2> <i>; yields {ty}:result</i> </pre> <h5>Overview:</h5> @@ -2148,7 +2178,7 @@ <h5>Arguments:</h5> <p>The first argument to the '<tt>ashr</tt>' instruction must be an <a href="#t_integer">integer</a> type. The second argument must be an -'<tt>ubyte</tt>' type.</p> +'<tt>i8</tt>' type.</p> <h5>Semantics:</h5> <p>This instruction always performs an arithmetic shift right operation, @@ -2157,10 +2187,10 @@ <h5>Example:</h5> <pre> - <result> = ashr uint 4, ubyte 1 <i>; yields {uint}:result = 2</i> - <result> = ashr int 4, ubyte 2 <i>; yields {int}:result = 1</i> - <result> = ashr ubyte 4, ubyte 3 <i>; yields {ubyte}:result = 0</i> - <result> = ashr sbyte -2, ubyte 1 <i>; yields {sbyte}:result = -1</i> + <result> = ashr i32 4, i8 1 <i>; yields {i32}:result = 2</i> + <result> = ashr i32 4, i8 2 <i>; yields {i32}:result = 1</i> + <result> = ashr i8 4, i8 3 <i>; yields {i8}:result = 0</i> + <result> = ashr i8 -2, i8 1 <i>; yields {i8 }:result = -1</i> </pre> </div> @@ -2190,7 +2220,7 @@ <h5>Syntax:</h5> <pre> - <result> = extractelement <n x <ty>> <val>, uint <idx> <i>; yields <ty></i> + <result> = extractelement <n x <ty>> <val>, i32 <idx> <i>; yields <ty></i> </pre> <h5>Overview:</h5> @@ -2221,7 +2251,7 @@ <h5>Example:</h5> <pre> - %result = extractelement <4 x int> %vec, uint 0 <i>; yields int</i> + %result = extractelement <4 x i32> %vec, i32 0 <i>; yields i32</i> </pre> </div> @@ -2236,7 +2266,7 @@ <h5>Syntax:</h5> <pre> - <result> = insertelement <n x <ty>> <val>, <ty> <elt>, uint <idx> <i>; yields <n x <ty>></i> + <result> = insertelement <n x <ty>> <val>, <ty> <elt>, i32 <idx> <i>; yields <n x <ty>></i> </pre> <h5>Overview:</h5> @@ -2268,7 +2298,7 @@ <h5>Example:</h5> <pre> - %result = insertelement <4 x int> %vec, int 1, uint 0 <i>; yields <4 x int></i> + %result = insertelement <4 x i32> %vec, i32 1, i32 0 <i>; yields <4 x i32></i> </pre> </div> @@ -2282,7 +2312,7 @@ <h5>Syntax:</h5> <pre> - <result> = shufflevector <n x <ty>> <v1>, <n x <ty>> <v2>, <n x uint> <mask> <i>; yields <n x <ty>></i> + <result> = shufflevector <n x <ty>> <v1>, <n x <ty>> <v2>, <n x i32> <mask> <i>; yields <n x <ty>></i> </pre> <h5>Overview:</h5> @@ -2298,7 +2328,7 @@ The first two operands of a '<tt>shufflevector</tt>' instruction are vectors with types that match each other and types that match the result of the instruction. The third argument is a shuffle mask, which has the same number -of elements as the other vector type, but whose element type is always 'uint'. +of elements as the other vector type, but whose element type is always 'i32'. </p> <p> @@ -2319,10 +2349,10 @@ <h5>Example:</h5> <pre> - %result = shufflevector <4 x int> %v1, <4 x int> %v2, - <4 x uint> <uint 0, uint 4, uint 1, uint 5> <i>; yields <4 x int></i> - %result = shufflevector <4 x int> %v1, <4 x int> undef, - <4 x uint> <uint 0, uint 1, uint 2, uint 3> <i>; yields <4 x int></i> - Identity shuffle. + %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> + %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> </div> @@ -2351,7 +2381,7 @@ <h5>Syntax:</h5> <pre> - <result> = malloc <type>[, uint <NumElements>][, align <alignment>] <i>; yields {type*}:result</i> + <result> = malloc <type>[, i32 <NumElements>][, align <alignment>] <i>; yields {type*}:result</i> </pre> <h5>Overview:</h5> @@ -2380,13 +2410,13 @@ <h5>Example:</h5> <pre> - %array = malloc [4 x ubyte ] <i>; yields {[%4 x ubyte]*}:array</i> + %array = malloc [4 x i8 ] <i>; yields {[%4 x i8]*}:array</i> - %size = <a href="#i_add">add</a> uint 2, 2 <i>; yields {uint}:size = uint 4</i> - %array1 = malloc ubyte, uint 4 <i>; yields {ubyte*}:array1</i> - %array2 = malloc [12 x ubyte], uint %size <i>; yields {[12 x ubyte]*}:array2</i> - %array3 = malloc int, uint 4, align 1024 <i>; yields {int*}:array3</i> - %array4 = malloc int, align 1024 <i>; yields {int*}: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> @@ -2422,8 +2452,8 @@ <h5>Example:</h5> <pre> - %array = <a href="#i_malloc">malloc</a> [4 x ubyte] <i>; yields {[4 x ubyte]*}:array</i> - free [4 x ubyte]* %array + %array = <a href="#i_malloc">malloc</a> [4 x i8] <i>; yields {[4 x i8]*}:array</i> + free [4 x i8]* %array </pre> </div> @@ -2437,7 +2467,7 @@ <h5>Syntax:</h5> <pre> - <result> = alloca <type>[, uint <NumElements>][, align <alignment>] <i>; yields {type*}:result</i> + <result> = alloca <type>[, i32 <NumElements>][, align <alignment>] <i>; yields {type*}:result</i> </pre> <h5>Overview:</h5> @@ -2470,10 +2500,10 @@ <h5>Example:</h5> <pre> - %ptr = alloca int <i>; yields {int*}:ptr</i> - %ptr = alloca int, uint 4 <i>; yields {int*}:ptr</i> - %ptr = alloca int, uint 4, align 1024 <i>; yields {int*}:ptr</i> - %ptr = alloca int, align 1024 <i>; yields {int*}:ptr</i> + %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, align 1024 <i>; yields {i32*}:ptr</i> </pre> </div> @@ -2496,10 +2526,10 @@ <h5>Semantics:</h5> <p>The location of memory pointed to is loaded.</p> <h5>Examples:</h5> -<pre> %ptr = <a href="#i_alloca">alloca</a> int <i>; yields {int*}:ptr</i> +<pre> %ptr = <a href="#i_alloca">alloca</a> i32 <i>; yields {i32*}:ptr</i> <a - href="#i_store">store</a> int 3, int* %ptr <i>; yields {void}</i> - %val = load int* %ptr <i>; yields {int}:val = int 3</i> + href="#i_store">store</a> i32 3, i32* %ptr <i>; yields {void}</i> + %val = load i32* %ptr <i>; yields {i32}:val = i32 3</i> </pre> </div> <!-- _______________________________________________________________________ --> @@ -2524,10 +2554,10 @@ <p>The contents of memory are updated to contain '<tt><value></tt>' at the location specified by the '<tt><pointer></tt>' operand.</p> <h5>Example:</h5> -<pre> %ptr = <a href="#i_alloca">alloca</a> int <i>; yields {int*}:ptr</i> +<pre> %ptr = <a href="#i_alloca">alloca</a> i32 <i>; yields {i32*}:ptr</i> <a - href="#i_store">store</a> int 3, int* %ptr <i>; yields {void}</i> - %val = load int* %ptr <i>; yields {int}:val = int 3</i> + href="#i_store">store</a> i32 3, i32* %ptr <i>; yields {void}</i> + %val = load i32* %ptr <i>; yields {i32}:val = i32 3</i> </pre> </div> @@ -2555,7 +2585,7 @@ provided depend on the type of the first pointer argument. The '<tt>getelementptr</tt>' instruction is used to index down through the type levels of a structure or to a specific index in an array. When indexing into a -structure, only <tt>uint</tt> integer constants are allowed. When indexing +structure, only <tt>i32</tt> integer constants are allowed. When indexing into an array or pointer, only integers of 32 or 64 bits are allowed, and will be sign extended to 64-bit values.</p> @@ -2565,16 +2595,16 @@ <pre> struct RT { char A; - int B[10][20]; + i32 B[10][20]; char C; }; struct ST { - int X; + i32 X; double Y; struct RT Z; }; - int *foo(struct ST *s) { + define i32 *foo(struct ST *s) { return &s[1].Z.B[5][13]; } </pre> @@ -2582,15 +2612,15 @@ <p>The LLVM code generated by the GCC frontend is:</p> <pre> - %RT = type { sbyte, [10 x [20 x int]], sbyte } - %ST = type { int, double, %RT } + %RT = type { i8 , [10 x [20 x i32]], i8 } + %ST = type { i32, double, %RT } implementation - int* %foo(%ST* %s) { + define i32* %foo(%ST* %s) { entry: - %reg = getelementptr %ST* %s, int 1, uint 2, uint 1, int 5, int 13 - ret int* %reg + %reg = getelementptr %ST* %s, i32 1, i32 2, i32 1, i32 5, i32 13 + ret i32* %reg } </pre> @@ -2600,31 +2630,31 @@ 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>uint</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>' -type, which is a pointer, yielding a '<tt>%ST</tt>' = '<tt>{ int, double, %RT +type, which is a pointer, yielding a '<tt>%ST</tt>' = '<tt>{ i32, double, %RT }</tt>' type, a structure. The second index indexes into the third element of -the structure, yielding a '<tt>%RT</tt>' = '<tt>{ sbyte, [10 x [20 x int]], -sbyte }</tt>' type, another structure. The third index indexes into the second -element of the structure, yielding a '<tt>[10 x [20 x int]]</tt>' type, an +the structure, yielding a '<tt>%RT</tt>' = '<tt>{ i8 , [10 x [20 x i32]], +i8 }</tt>' type, another structure. The third index indexes into the second +element of the structure, yielding a '<tt>[10 x [20 x i32]]</tt>' type, an array. The two dimensions of the array are subscripted into, yielding an -'<tt>int</tt>' type. The '<tt>getelementptr</tt>' instruction returns a pointer -to this element, thus computing a value of '<tt>int*</tt>' type.</p> +'<tt>i32</tt>' type. The '<tt>getelementptr</tt>' instruction returns a pointer +to this element, thus computing a value of '<tt>i32*</tt>' type.</p> <p>Note that it is perfectly legal to index partially through a structure, returning a pointer to an inner element. Because of this, the LLVM code for the given testcase is equivalent to:</p> <pre> - int* %foo(%ST* %s) { - %t1 = getelementptr %ST* %s, int 1 <i>; yields %ST*:%t1</i> - %t2 = getelementptr %ST* %t1, int 0, uint 2 <i>; yields %RT*:%t2</i> - %t3 = getelementptr %RT* %t2, int 0, uint 1 <i>; yields [10 x [20 x int]]*:%t3</i> - %t4 = getelementptr [10 x [20 x int]]* %t3, int 0, int 5 <i>; yields [20 x int]*:%t4</i> - %t5 = getelementptr [20 x int]* %t4, int 0, int 13 <i>; yields int*:%t5</i> - ret int* %t5 + 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> + %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 } </pre> @@ -2641,8 +2671,8 @@ <h5>Example:</h5> <pre> - <i>; yields [12 x ubyte]*:aptr</i> - %aptr = getelementptr {int, [12 x ubyte]}* %sptr, long 0, uint 1 + <i>; yields [12 x i8]*:aptr</i> + %aptr = getelementptr {i32, [12 x i8]}* %sptr, i64 0, i32 1 </pre> </div> @@ -2688,8 +2718,8 @@ <h5>Example:</h5> <pre> - %X = trunc int 257 to ubyte <i>; yields ubyte:1</i> - %Y = trunc int 123 to bool <i>; yields bool:true</i> + %X = trunc i32 257 to i8 <i>; yields i8:1</i> + %Y = trunc i32 123 to bool <i>; yields bool:true</i> </pre> </div> @@ -2727,8 +2757,8 @@ <h5>Example:</h5> <pre> - %X = zext int 257 to ulong <i>; yields ulong:257</i> - %Y = zext bool true to int <i>; yields int:1</i> + %X = zext i32 257 to i64 <i>; yields i64:257</i> + %Y = zext bool true to i32 <i>; yields i32:1</i> </pre> </div> @@ -2766,8 +2796,8 @@ <h5>Example:</h5> <pre> - %X = sext sbyte -1 to ushort <i>; yields ushort:65535</i> - %Y = sext bool true to int <i>; yields int:-1</i> + %X = sext i8 -1 to i16 <i>; yields i16 :65535</i> + %Y = sext bool true to i32 <i>; yields i32:-1</i> </pre> </div> @@ -2877,9 +2907,9 @@ <h5>Example:</h5> <pre> - %X = fp2uint double 123.0 to int <i>; yields int:123</i> + %X = fp2uint double 123.0 to i32 <i>; yields i32:123</i> %Y = fp2uint float 1.0E+300 to bool <i>; yields bool:true</i> - %X = fp2uint float 1.04E+17 to ubyte <i>; yields undefined:1</i> + %X = fp2uint float 1.04E+17 to i8 <i>; yields undefined:1</i> </pre> </div> @@ -2917,9 +2947,9 @@ <h5>Example:</h5> <pre> - %X = fptosi double -123.0 to int <i>; yields int:-123</i> + %X = fptosi double -123.0 to i32 <i>; yields i32:-123</i> %Y = fptosi float 1.0E-247 to bool <i>; yields bool:true</i> - %X = fptosi float 1.04E+17 to sbyte <i>; yields undefined:1</i> + %X = fptosi float 1.04E+17 to i8 <i>; yields undefined:1</i> </pre> </div> @@ -2952,8 +2982,8 @@ <h5>Example:</h5> <pre> - %X = uitofp int 257 to float <i>; yields float:257.0</i> - %Y = uitofp sbyte -1 to double <i>; yields double:255.0</i> + %X = uitofp i32 257 to float <i>; yields float:257.0</i> + %Y = uitofp i8 -1 to double <i>; yields double:255.0</i> </pre> </div> @@ -2984,8 +3014,8 @@ <h5>Example:</h5> <pre> - %X = sitofp int 257 to float <i>; yields float:257.0</i> - %Y = sitofp sbyte -1 to double <i>; yields double:-1.0</i> + %X = sitofp i32 257 to float <i>; yields float:257.0</i> + %Y = sitofp i8 -1 to double <i>; yields double:-1.0</i> </pre> </div> @@ -3019,8 +3049,8 @@ <h5>Example:</h5> <pre> - %X = ptrtoint int* %X to sbyte <i>; yields truncation on 32-bit</i> - %Y = ptrtoint int* %x to ulong <i>; yields zero extend on 32-bit</i> + %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> </pre> </div> @@ -3054,9 +3084,9 @@ <h5>Example:</h5> <pre> - %X = inttoptr int 255 to int* <i>; yields zero extend on 64-bit</i> - %X = inttoptr int 255 to int* <i>; yields no-op on 32-bit </i> - %Y = inttoptr short 0 to int* <i>; yields zero extend on 32-bit</i> + %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> </pre> </div> @@ -3092,9 +3122,9 @@ <h5>Example:</h5> <pre> - %X = bitcast ubyte 255 to sbyte <i>; yields sbyte:-1</i> - %Y = bitcast uint* %x to sint* <i>; yields sint*:%x</i> - %Z = bitcast <2xint> %V to long; <i>; yields long: %V</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> @@ -3169,12 +3199,12 @@ elements.</p> <h5>Example:</h5> -<pre> <result> = icmp eq int 4, 5 <i>; yields: result=false</i> - <result> = icmp ne float* %X, %X <i>; yields: result=false</i> - <result> = icmp ult short 4, 5 <i>; yields: result=true</i> - <result> = icmp sgt sbyte 4, 5 <i>; yields: result=false</i> - <result> = icmp ule sbyte -4, 5 <i>; yields: result=false</i> - <result> = icmp sge sbyte 4, 5 <i>; yields: result=false</i> +<pre> <result> = icmp eq i32 4, 5 <i>; yields: result=false</i> + <result> = icmp ne float* %X, %X <i>; yields: result=false</i> + <result> = icmp ult i16 4, 5 <i>; yields: result=true</i> + <result> = icmp sgt i16 4, 5 <i>; yields: result=false</i> + <result> = icmp ule i16 -4, 5 <i>; yields: result=false</i> + <result> = icmp sge i16 4, 5 <i>; yields: result=false</i> </pre> </div> @@ -3287,7 +3317,7 @@ value specified by the parameter, depending on which basic block we came from in the last <a href="#terminators">terminator</a> instruction.</p> <h5>Example:</h5> -<pre>Loop: ; Infinite loop that counts from 0 on up...<br> %indvar = phi uint [ 0, %LoopHeader ], [ %nextindvar, %Loop ]<br> %nextindvar = add uint %indvar, 1<br> br label %Loop<br></pre> +<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> <!-- _______________________________________________________________________ --> @@ -3327,7 +3357,7 @@ <h5>Example:</h5> <pre> - %X = select bool true, ubyte 17, ubyte 42 <i>; yields ubyte:17</i> + %X = select bool true, i8 17, i8 42 <i>; yields i8:17</i> </pre> </div> @@ -3399,10 +3429,10 @@ <h5>Example:</h5> <pre> - %retval = call int %test(int %argc) - call int(sbyte*, ...) *%printf(sbyte* %msg, int 12, sbyte 42); - %X = tail call int %foo() - %Y = tail call <a href="#callingconv">fastcc</a> int %foo() + %retval = call i32 %test(i32 %argc) + 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> </div> @@ -3506,22 +3536,22 @@ used.</p> <pre> -int %test(int %X, ...) { +define i32 %test(i32 %X, ...) { ; Initialize variable argument processing - %ap = alloca sbyte* - call void %<a href="#i_va_start">llvm.va_start</a>(sbyte** %ap) + %ap = alloca i8 * + call void %<a href="#i_va_start">llvm.va_start</a>(i8 ** %ap) ; Read a single integer argument - %tmp = va_arg sbyte** %ap, int + %tmp = va_arg i8 ** %ap, i32 ; Demonstrate usage of llvm.va_copy and llvm.va_end - %aq = alloca sbyte* - call void %<a href="#i_va_copy">llvm.va_copy</a>(sbyte** %aq, sbyte** %ap) - call void %<a href="#i_va_end">llvm.va_end</a>(sbyte** %aq) + %aq = alloca i8 * + call void %<a href="#i_va_copy">llvm.va_copy</a>(i8 ** %aq, i8 ** %ap) + call void %<a href="#i_va_end">llvm.va_end</a>(i8 ** %aq) ; Stop processing of arguments. - call void %<a href="#i_va_end">llvm.va_end</a>(sbyte** %ap) - ret int %tmp + call void %<a href="#i_va_end">llvm.va_end</a>(i8 ** %ap) + ret i32 %tmp } </pre> </div> @@ -3675,7 +3705,7 @@ <h5>Syntax:</h5> <pre> - declare sbyte* %llvm.gcread(sbyte* %ObjPtr, sbyte** %Ptr) + declare i8 * %llvm.gcread(i8 * %ObjPtr, i8 ** %Ptr) </pre> <h5>Overview:</h5> @@ -3710,7 +3740,7 @@ <h5>Syntax:</h5> <pre> - declare void %llvm.gcwrite(sbyte* %P1, sbyte* %Obj, sbyte** %P2) + declare void %llvm.gcwrite(i8 * %P1, i8 * %Obj, i8 ** %P2) </pre> <h5>Overview:</h5> @@ -3758,7 +3788,7 @@ <h5>Syntax:</h5> <pre> - declare sbyte *%llvm.returnaddress(uint <level>) + declare i8 *%llvm.returnaddress(i32 <level>) </pre> <h5>Overview:</h5> @@ -3803,7 +3833,7 @@ <h5>Syntax:</h5> <pre> - declare sbyte *%llvm.frameaddress(uint <level>) + declare i8 *%llvm.frameaddress(i32 <level>) </pre> <h5>Overview:</h5> @@ -3846,7 +3876,7 @@ <h5>Syntax:</h5> <pre> - declare sbyte *%llvm.stacksave() + declare i8 *%llvm.stacksave() </pre> <h5>Overview:</h5> @@ -3881,7 +3911,7 @@ <h5>Syntax:</h5> <pre> - declare void %llvm.stackrestore(sbyte* %ptr) + declare void %llvm.stackrestore(i8 * %ptr) </pre> <h5>Overview:</h5> @@ -3912,8 +3942,8 @@ <h5>Syntax:</h5> <pre> - declare void %llvm.prefetch(sbyte * <address>, - uint <rw>, uint <locality>) + declare void %llvm.prefetch(i8 * <address>, + i32 <rw>, i32 <locality>) </pre> <h5>Overview:</h5> @@ -3957,7 +3987,7 @@ <h5>Syntax:</h5> <pre> - declare void %llvm.pcmarker( uint <id> ) + declare void %llvm.pcmarker( i32 <id> ) </pre> <h5>Overview:</h5> @@ -3998,7 +4028,7 @@ <h5>Syntax:</h5> <pre> - declare ulong %llvm.readcyclecounter( ) + declare i64 %llvm.readcyclecounter( ) </pre> <h5>Overview:</h5> @@ -4046,10 +4076,10 @@ <h5>Syntax:</h5> <pre> - declare void %llvm.memcpy.i32(sbyte* <dest>, sbyte* <src>, - uint <len>, uint <align>) - declare void %llvm.memcpy.i64(sbyte* <dest>, sbyte* <src>, - ulong <len>, uint <align>) + declare void %llvm.memcpy.i32(i8 * <dest>, i8 * <src>, + i32 <len>, i32 <align>) + declare void %llvm.memcpy.i64(i8 * <dest>, i8 * <src>, + i64 <len>, i32 <align>) </pre> <h5>Overview:</h5> @@ -4100,10 +4130,10 @@ <h5>Syntax:</h5> <pre> - declare void %llvm.memmove.i32(sbyte* <dest>, sbyte* <src>, - uint <len>, uint <align>) - declare void %llvm.memmove.i64(sbyte* <dest>, sbyte* <src>, - ulong <len>, uint <align>) + declare void %llvm.memmove.i32(i8 * <dest>, i8 * <src>, + i32 <len>, i32 <align>) + declare void %llvm.memmove.i64(i8 * <dest>, i8 * <src>, + i64 <len>, i32 <align>) </pre> <h5>Overview:</h5> @@ -4155,10 +4185,10 @@ <h5>Syntax:</h5> <pre> - declare void %llvm.memset.i32(sbyte* <dest>, ubyte <val>, - uint <len>, uint <align>) - declare void %llvm.memset.i64(sbyte* <dest>, ubyte <val>, - ulong <len>, uint <align>) + declare void %llvm.memset.i32(i8 * <dest>, i8 <val>, + i32 <len>, i32 <align>) + declare void %llvm.memset.i64(i8 * <dest>, i8 <val>, + i64 <len>, i32 <align>) </pre> <h5>Overview:</h5> @@ -4279,8 +4309,8 @@ <h5>Syntax:</h5> <pre> - declare float %llvm.powi.f32(float %Val, int %power) - declare double %llvm.powi.f64(double %Val, int %power) + declare float %llvm.powi.f32(float %Val, i32 %power) + declare double %llvm.powi.f64(double %Val, i32 %power) </pre> <h5>Overview:</h5> @@ -4328,9 +4358,9 @@ <h5>Syntax:</h5> <pre> - declare ushort %llvm.bswap.i16(ushort <id>) - declare uint %llvm.bswap.i32(uint <id>) - declare ulong %llvm.bswap.i64(ulong <id>) + declare i16 %llvm.bswap.i16(i16 <id>) + declare i32 %llvm.bswap.i32(i32 <id>) + declare i64 %llvm.bswap.i64(i64 <id>) </pre> <h5>Overview:</h5> @@ -4344,12 +4374,12 @@ <h5>Semantics:</h5> <p> -The <tt>llvm.bswap.16</tt> intrinsic returns a ushort value that has the high and low -byte of the input ushort swapped. Similarly, the <tt>llvm.bswap.i32</tt> intrinsic -returns a uint value that has the four bytes of the input uint swapped, so that -if the input bytes are numbered 0, 1, 2, 3 then the returned uint will have its -bytes in 3, 2, 1, 0 order. The <tt>llvm.bswap.i64</tt> intrinsic extends this concept -to 64 bits. +The <tt>llvm.bswap.16</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. </p> </div> @@ -4363,10 +4393,10 @@ <h5>Syntax:</h5> <pre> - declare ubyte %llvm.ctpop.i8 (ubyte <src>) - declare ushort %llvm.ctpop.i16(ushort <src>) - declare uint %llvm.ctpop.i32(uint <src>) - declare ulong %llvm.ctpop.i64(ulong <src>) + declare i8 %llvm.ctpop.i8 (i8 <src>) + declare i16 %llvm.ctpop.i16(i16 <src>) + declare i32 %llvm.ctpop.i32(i32 <src>) + declare i64 %llvm.ctpop.i64(i64 <src>) </pre> <h5>Overview:</h5> @@ -4399,10 +4429,10 @@ <h5>Syntax:</h5> <pre> - declare ubyte %llvm.ctlz.i8 (ubyte <src>) - declare ushort %llvm.ctlz.i16(ushort <src>) - declare uint %llvm.ctlz.i32(uint <src>) - declare ulong %llvm.ctlz.i64(ulong <src>) + declare i8 %llvm.ctlz.i8 (i8 <src>) + declare i16 %llvm.ctlz.i16(i16 <src>) + declare i32 %llvm.ctlz.i32(i32 <src>) + declare i64 %llvm.ctlz.i64(i64 <src>) </pre> <h5>Overview:</h5> @@ -4424,7 +4454,7 @@ <p> The '<tt>llvm.ctlz</tt>' intrinsic counts the leading (most significant) zeros in a variable. If the src == 0 then the result is the size in bits of the type -of src. For example, <tt>llvm.ctlz(int 2) = 30</tt>. +of src. For example, <tt>llvm.ctlz(i32 2) = 30</tt>. </p> </div> @@ -4439,10 +4469,10 @@ <h5>Syntax:</h5> <pre> - declare ubyte %llvm.cttz.i8 (ubyte <src>) - declare ushort %llvm.cttz.i16(ushort <src>) - declare uint %llvm.cttz.i32(uint <src>) - declare ulong %llvm.cttz.i64(ulong <src>) + declare i8 %llvm.cttz.i8 (i8 <src>) + declare i16 %llvm.cttz.i16(i16 <src>) + declare i32 %llvm.cttz.i32(i32 <src>) + declare i64 %llvm.cttz.i64(i64 <src>) </pre> <h5>Overview:</h5> @@ -4493,7 +4523,7 @@ <a href="mailto:[EMAIL PROTECTED]">Chris Lattner</a><br> <a href="http://llvm.org">The LLVM Compiler Infrastructure</a><br> - Last modified: $Date: 2006/12/28 16:55:55 $ + Last modified: $Date: 2006/12/31 07:07:53 $ </address> </body> </html> _______________________________________________ llvm-commits mailing list llvm-commits@cs.uiuc.edu http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits