diff --git a/docs/LangRef.html b/docs/LangRef.html
index 3af8b68..f87af54 100644
--- a/docs/LangRef.html
+++ b/docs/LangRef.html
@@ -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> &lt; { int, int, int } &gt; </tt><br/>
-      <tt> &lt; { float, int (int) * } &gt; </tt><br/>
+      <tt> &lt; { i32, i32, i32 } &gt; </tt><br/>
+      <tt> &lt; { float, i32 (i32) * } &gt; </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>&lt;4 x int&gt;</tt><br/>
+      <tt>&lt;4 x i32&gt;</tt><br/>
       <tt>&lt;8 x float&gt;</tt><br/>
-      <tt>&lt;2 x uint&gt;</tt><br/>
+      <tt>&lt;2 x i32&gt;</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>&lt;&gt;</tt>)).  For example: "<tt>&lt; int 42,
-  int 11, int 74, int 100 &gt;</tt>".  Packed constants must have <a
+  less-than/greater-than's (<tt>&lt;&gt;</tt>)).  For example: "<tt>&lt; i32 42,
+  i32 11, i32 74, i32 100 &gt;</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>  &lt;result&gt; = add int 4, %var          <i>; yields {int}:result = 4 + %var</i>
+<pre>  &lt;result&gt; = 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>  &lt;result&gt; = sub int 4, %var          <i>; yields {int}:result = 4 - %var</i>
-  &lt;result&gt; = sub int 0, %val          <i>; yields {int}:result = -%var</i>
+<pre>  &lt;result&gt; = sub i32 4, %var          <i>; yields {i32}:result = 4 - %var</i>
+  &lt;result&gt; = 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>  &lt;result&gt; = mul int 4, %var          <i>; yields {int}:result = 4 * %var</i>
+<pre>  &lt;result&gt; = 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>  &lt;result&gt; = udiv uint 4, %var          <i>; yields {uint}:result = 4 / %var</i>
+<pre>  &lt;result&gt; = 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>  &lt;result&gt; = sdiv int 4, %var          <i>; yields {int}:result = 4 / %var</i>
+<pre>  &lt;result&gt; = 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>  &lt;result&gt; = urem uint 4, %var          <i>; yields {uint}:result = 4 % %var</i>
+<pre>  &lt;result&gt; = 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>  &lt;result&gt; = srem int 4, %var          <i>; yields {int}:result = 4 % %var</i>
+<pre>  &lt;result&gt; = srem i32 4, %var          <i>; yields {i32}:result = 4 % %var</i>
 </pre>
 
 </div>
@@ -1965,9 +1995,9 @@
 </table>
 </div>
 <h5>Example:</h5>
-<pre>  &lt;result&gt; = and int 4, %var         <i>; yields {int}:result = 4 &amp; %var</i>
-  &lt;result&gt; = and int 15, 40          <i>; yields {int}:result = 8</i>
-  &lt;result&gt; = and int 4, 8            <i>; yields {int}:result = 0</i>
+<pre>  &lt;result&gt; = and i32 4, %var         <i>; yields {i32}:result = 4 &amp; %var</i>
+  &lt;result&gt; = and i32 15, 40          <i>; yields {i32}:result = 8</i>
+  &lt;result&gt; = and i32 4, 8            <i>; yields {i32}:result = 0</i>
 </pre>
 </div>
 <!-- _______________________________________________________________________ -->
@@ -2018,9 +2048,9 @@
 </table>
 </div>
 <h5>Example:</h5>
-<pre>  &lt;result&gt; = or int 4, %var         <i>; yields {int}:result = 4 | %var</i>
-  &lt;result&gt; = or int 15, 40          <i>; yields {int}:result = 47</i>
-  &lt;result&gt; = or int 4, 8            <i>; yields {int}:result = 12</i>
+<pre>  &lt;result&gt; = or i32 4, %var         <i>; yields {i32}:result = 4 | %var</i>
+  &lt;result&gt; = or i32 15, 40          <i>; yields {i32}:result = 47</i>
+  &lt;result&gt; = or i32 4, 8            <i>; yields {i32}:result = 12</i>
 </pre>
 </div>
 <!-- _______________________________________________________________________ -->
@@ -2074,10 +2104,10 @@
 </div>
 <p> </p>
 <h5>Example:</h5>
-<pre>  &lt;result&gt; = xor int 4, %var         <i>; yields {int}:result = 4 ^ %var</i>
-  &lt;result&gt; = xor int 15, 40          <i>; yields {int}:result = 39</i>
-  &lt;result&gt; = xor int 4, 8            <i>; yields {int}:result = 12</i>
-  &lt;result&gt; = xor int %V, -1          <i>; yields {int}:result = ~%V</i>
+<pre>  &lt;result&gt; = xor i32 4, %var         <i>; yields {i32}:result = 4 ^ %var</i>
+  &lt;result&gt; = xor i32 15, 40          <i>; yields {i32}:result = 39</i>
+  &lt;result&gt; = xor i32 4, 8            <i>; yields {i32}:result = 12</i>
+  &lt;result&gt; = 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>  &lt;result&gt; = shl &lt;ty&gt; &lt;var1&gt;, ubyte &lt;var2&gt;   <i>; yields {ty}:result</i>
+<pre>  &lt;result&gt; = shl &lt;ty&gt; &lt;var1&gt;, i8 &lt;var2&gt;   <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>  &lt;result&gt; = shl int 4, ubyte %var   <i>; yields {int}:result = 4 &lt;&lt; %var</i>
-  &lt;result&gt; = shl int 4, ubyte 2      <i>; yields {int}:result = 16</i>
-  &lt;result&gt; = shl int 1, ubyte 10     <i>; yields {int}:result = 1024</i>
+<pre>  &lt;result&gt; = shl i32 4, i8 %var   <i>; yields {i32}:result = 4 &lt;&lt; %var</i>
+  &lt;result&gt; = shl i32 4, i8 2      <i>; yields {i32}:result = 16</i>
+  &lt;result&gt; = 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>  &lt;result&gt; = lshr &lt;ty&gt; &lt;var1&gt;, ubyte &lt;var2&gt;   <i>; yields {ty}:result</i>
+<pre>  &lt;result&gt; = lshr &lt;ty&gt; &lt;var1&gt;, i8 &lt;var2&gt;   <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>
-  &lt;result&gt; = lshr uint 4, ubyte 1   <i>; yields {uint}:result = 2</i>
-  &lt;result&gt; = lshr int 4, ubyte 2    <i>; yields {uint}:result = 1</i>
-  &lt;result&gt; = lshr sbyte 4, ubyte 3  <i>; yields {sbyte}:result = 0</i>
-  &lt;result&gt; = lshr sbyte -2, ubyte 1 <i>; yields {sbyte}:result = 0x7FFFFFFF </i>
+  &lt;result&gt; = lshr i32 4, i8 1   <i>; yields {i32}:result = 2</i>
+  &lt;result&gt; = lshr i32 4, i8 2    <i>; yields {i32}:result = 1</i>
+  &lt;result&gt; = lshr i8  4, i8 3  <i>; yields {i8 }:result = 0</i>
+  &lt;result&gt; = 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>  &lt;result&gt; = ashr &lt;ty&gt; &lt;var1&gt;, ubyte &lt;var2&gt;   <i>; yields {ty}:result</i>
+<pre>  &lt;result&gt; = ashr &lt;ty&gt; &lt;var1&gt;, i8 &lt;var2&gt;   <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>
-  &lt;result&gt; = ashr uint 4, ubyte 1    <i>; yields {uint}:result = 2</i>
-  &lt;result&gt; = ashr int 4, ubyte 2      <i>; yields {int}:result = 1</i>
-  &lt;result&gt; = ashr ubyte 4, ubyte 3    <i>; yields {ubyte}:result = 0</i>
-  &lt;result&gt; = ashr sbyte -2, ubyte 1   <i>; yields {sbyte}:result = -1</i>
+  &lt;result&gt; = ashr i32 4, i8 1    <i>; yields {i32}:result = 2</i>
+  &lt;result&gt; = ashr i32 4, i8 2      <i>; yields {i32}:result = 1</i>
+  &lt;result&gt; = ashr i8 4, i8 3    <i>; yields {i8}:result = 0</i>
+  &lt;result&gt; = ashr i8  -2, i8 1   <i>; yields {i8 }:result = -1</i>
 </pre>
 </div>
 
@@ -2190,7 +2220,7 @@
 <h5>Syntax:</h5>
 
 <pre>
-  &lt;result&gt; = extractelement &lt;n x &lt;ty&gt;&gt; &lt;val&gt;, uint &lt;idx&gt;    <i>; yields &lt;ty&gt;</i>
+  &lt;result&gt; = extractelement &lt;n x &lt;ty&gt;&gt; &lt;val&gt;, i32 &lt;idx&gt;    <i>; yields &lt;ty&gt;</i>
 </pre>
 
 <h5>Overview:</h5>
@@ -2221,7 +2251,7 @@
 <h5>Example:</h5>
 
 <pre>
-  %result = extractelement &lt;4 x int&gt; %vec, uint 0    <i>; yields int</i>
+  %result = extractelement &lt;4 x i32&gt; %vec, i32 0    <i>; yields i32</i>
 </pre>
 </div>
 
@@ -2236,7 +2266,7 @@
 <h5>Syntax:</h5>
 
 <pre>
-  &lt;result&gt; = insertelement &lt;n x &lt;ty&gt;&gt; &lt;val&gt;, &lt;ty&gt; &lt;elt&gt, uint &lt;idx&gt;    <i>; yields &lt;n x &lt;ty&gt;&gt;</i>
+  &lt;result&gt; = insertelement &lt;n x &lt;ty&gt;&gt; &lt;val&gt;, &lt;ty&gt; &lt;elt&gt, i32 &lt;idx&gt;    <i>; yields &lt;n x &lt;ty&gt;&gt;</i>
 </pre>
 
 <h5>Overview:</h5>
@@ -2268,7 +2298,7 @@
 <h5>Example:</h5>
 
 <pre>
-  %result = insertelement &lt;4 x int&gt; %vec, int 1, uint 0    <i>; yields &lt;4 x int&gt;</i>
+  %result = insertelement &lt;4 x i32&gt; %vec, i32 1, i32 0    <i>; yields &lt;4 x i32&gt;</i>
 </pre>
 </div>
 
@@ -2282,7 +2312,7 @@
 <h5>Syntax:</h5>
 
 <pre>
-  &lt;result&gt; = shufflevector &lt;n x &lt;ty&gt;&gt; &lt;v1&gt;, &lt;n x &lt;ty&gt;&gt; &lt;v2&gt;, &lt;n x uint&gt; &lt;mask&gt;    <i>; yields &lt;n x &lt;ty&gt;&gt;</i>
+  &lt;result&gt; = shufflevector &lt;n x &lt;ty&gt;&gt; &lt;v1&gt;, &lt;n x &lt;ty&gt;&gt; &lt;v2&gt;, &lt;n x i32&gt; &lt;mask&gt;    <i>; yields &lt;n x &lt;ty&gt;&gt;</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 &lt;4 x int&gt; %v1, &lt;4 x int&gt; %v2, 
-                          &lt;4 x uint&gt; &lt;uint 0, uint 4, uint 1, uint 5&gt;    <i>; yields &lt;4 x int&gt;</i>
-  %result = shufflevector &lt;4 x int&gt; %v1, &lt;4 x int&gt; undef, 
-                          &lt;4 x uint&gt; &lt;uint 0, uint 1, uint 2, uint 3&gt;  <i>; yields &lt;4 x int&gt;</i> - Identity shuffle.
+  %result = shufflevector &lt;4 x i32&gt; %v1, &lt;4 x i32&gt; %v2, 
+                          &lt;4 x i32&gt; &lt;i32 0, i32 4, i32 1, i32 5&gt;    <i>; yields &lt;4 x i32&gt;</i>
+  %result = shufflevector &lt;4 x i32&gt; %v1, &lt;4 x i32&gt; undef, 
+                          &lt;4 x i32&gt; &lt;i32 0, i32 1, i32 2, i32 3&gt;  <i>; yields &lt;4 x i32&gt;</i> - Identity shuffle.
 </pre>
 </div>
 
@@ -2351,7 +2381,7 @@
 <h5>Syntax:</h5>
 
 <pre>
-  &lt;result&gt; = malloc &lt;type&gt;[, uint &lt;NumElements&gt;][, align &lt;alignment&gt;]     <i>; yields {type*}:result</i>
+  &lt;result&gt; = malloc &lt;type&gt;[, i32 &lt;NumElements&gt;][, align &lt;alignment&gt;]     <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>
-  &lt;result&gt; = alloca &lt;type&gt;[, uint &lt;NumElements&gt;][, align &lt;alignment&gt;]     <i>; yields {type*}:result</i>
+  &lt;result&gt; = alloca &lt;type&gt;[, i32 &lt;NumElements&gt;][, align &lt;alignment&gt;]     <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>&lt;value&gt;</tt>'
 at the location specified by the '<tt>&lt;pointer&gt;</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 &amp;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>  &lt;result&gt; = icmp eq int 4, 5           <i>; yields: result=false</i>
-  &lt;result&gt; = icmp ne float* %X, %X      <i>; yields: result=false</i>
-  &lt;result&gt; = icmp ult short 4, 5        <i>; yields: result=true</i>
-  &lt;result&gt; = icmp sgt sbyte 4, 5        <i>; yields: result=false</i>
-  &lt;result&gt; = icmp ule sbyte -4, 5       <i>; yields: result=false</i>
-  &lt;result&gt; = icmp sge sbyte 4, 5        <i>; yields: result=false</i>
+<pre>  &lt;result&gt; = icmp eq i32 4, 5          <i>; yields: result=false</i>
+  &lt;result&gt; = icmp ne float* %X, %X     <i>; yields: result=false</i>
+  &lt;result&gt; = icmp ult i16  4, 5        <i>; yields: result=true</i>
+  &lt;result&gt; = icmp sgt i16  4, 5        <i>; yields: result=false</i>
+  &lt;result&gt; = icmp ule i16 -4, 5        <i>; yields: result=false</i>
+  &lt;result&gt; = 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 &lt;level&gt;)
+  declare i8  *%llvm.returnaddress(i32 &lt;level&gt;)
 </pre>
 
 <h5>Overview:</h5>
@@ -3803,7 +3833,7 @@
 
 <h5>Syntax:</h5>
 <pre>
-  declare sbyte *%llvm.frameaddress(uint &lt;level&gt;)
+  declare i8  *%llvm.frameaddress(i32 &lt;level&gt;)
 </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 * &lt;address&gt;,
-                                uint &lt;rw&gt;, uint &lt;locality&gt;)
+  declare void %llvm.prefetch(i8  * &lt;address&gt;,
+                                i32 &lt;rw&gt;, i32 &lt;locality&gt;)
 </pre>
 
 <h5>Overview:</h5>
@@ -3957,7 +3987,7 @@
 
 <h5>Syntax:</h5>
 <pre>
-  declare void %llvm.pcmarker( uint &lt;id&gt; )
+  declare void %llvm.pcmarker( i32 &lt;id&gt; )
 </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* &lt;dest&gt;, sbyte* &lt;src&gt;,
-                                uint &lt;len&gt;, uint &lt;align&gt;)
-  declare void %llvm.memcpy.i64(sbyte* &lt;dest&gt;, sbyte* &lt;src&gt;,
-                                ulong &lt;len&gt;, uint &lt;align&gt;)
+  declare void %llvm.memcpy.i32(i8 * &lt;dest&gt;, i8 * &lt;src&gt;,
+                                i32 &lt;len&gt;, i32 &lt;align&gt;)
+  declare void %llvm.memcpy.i64(i8 * &lt;dest&gt;, i8 * &lt;src&gt;,
+                                i64 &lt;len&gt;, i32 &lt;align&gt;)
 </pre>
 
 <h5>Overview:</h5>
@@ -4100,10 +4130,10 @@
 
 <h5>Syntax:</h5>
 <pre>
-  declare void %llvm.memmove.i32(sbyte* &lt;dest&gt;, sbyte* &lt;src&gt;,
-                                 uint &lt;len&gt;, uint &lt;align&gt;)
-  declare void %llvm.memmove.i64(sbyte* &lt;dest&gt;, sbyte* &lt;src&gt;,
-                                 ulong &lt;len&gt;, uint &lt;align&gt;)
+  declare void %llvm.memmove.i32(i8 * &lt;dest&gt;, i8 * &lt;src&gt;,
+                                 i32 &lt;len&gt;, i32 &lt;align&gt;)
+  declare void %llvm.memmove.i64(i8 * &lt;dest&gt;, i8 * &lt;src&gt;,
+                                 i64 &lt;len&gt;, i32 &lt;align&gt;)
 </pre>
 
 <h5>Overview:</h5>
@@ -4155,10 +4185,10 @@
 
 <h5>Syntax:</h5>
 <pre>
-  declare void %llvm.memset.i32(sbyte* &lt;dest&gt;, ubyte &lt;val&gt;,
-                                uint &lt;len&gt;, uint &lt;align&gt;)
-  declare void %llvm.memset.i64(sbyte* &lt;dest&gt;, ubyte &lt;val&gt;,
-                                ulong &lt;len&gt;, uint &lt;align&gt;)
+  declare void %llvm.memset.i32(i8 * &lt;dest&gt;, i8 &lt;val&gt;,
+                                i32 &lt;len&gt;, i32 &lt;align&gt;)
+  declare void %llvm.memset.i64(i8 * &lt;dest&gt;, i8 &lt;val&gt;,
+                                i64 &lt;len&gt;, i32 &lt;align&gt;)
 </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 &lt;id&gt;)
-  declare uint   %llvm.bswap.i32(uint &lt;id&gt;)
-  declare ulong  %llvm.bswap.i64(ulong &lt;id&gt;)
+  declare i16 %llvm.bswap.i16(i16 &lt;id&gt;)
+  declare i32 %llvm.bswap.i32(i32 &lt;id&gt;)
+  declare i64 %llvm.bswap.i64(i64 &lt;id&gt;)
 </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 &lt;src&gt;)
-  declare ushort %llvm.ctpop.i16(ushort &lt;src&gt;)
-  declare uint   %llvm.ctpop.i32(uint &lt;src&gt;)
-  declare ulong  %llvm.ctpop.i64(ulong &lt;src&gt;)
+  declare i8  %llvm.ctpop.i8 (i8  &lt;src&gt;)
+  declare i16 %llvm.ctpop.i16(i16 &lt;src&gt;)
+  declare i32 %llvm.ctpop.i32(i32 &lt;src&gt;)
+  declare i64 %llvm.ctpop.i64(i64 &lt;src&gt;)
 </pre>
 
 <h5>Overview:</h5>
@@ -4399,10 +4429,10 @@
 
 <h5>Syntax:</h5>
 <pre>
-  declare ubyte  %llvm.ctlz.i8 (ubyte &lt;src&gt;)
-  declare ushort %llvm.ctlz.i16(ushort &lt;src&gt;)
-  declare uint   %llvm.ctlz.i32(uint &lt;src&gt;)
-  declare ulong  %llvm.ctlz.i64(ulong &lt;src&gt;)
+  declare i8  %llvm.ctlz.i8 (i8  &lt;src&gt;)
+  declare i16 %llvm.ctlz.i16(i16 &lt;src&gt;)
+  declare i32 %llvm.ctlz.i32(i32 &lt;src&gt;)
+  declare i64 %llvm.ctlz.i64(i64 &lt;src&gt;)
 </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 &lt;src&gt;)
-  declare ushort %llvm.cttz.i16(ushort &lt;src&gt;)
-  declare uint   %llvm.cttz.i32(uint &lt;src&gt;)
-  declare ulong  %llvm.cttz.i64(ulong &lt;src&gt;)
+  declare i8  %llvm.cttz.i8 (i8  &lt;src&gt;)
+  declare i16 %llvm.cttz.i16(i16 &lt;src&gt;)
+  declare i32 %llvm.cttz.i32(i32 &lt;src&gt;)
+  declare i64 %llvm.cttz.i64(i64 &lt;src&gt;)
 </pre>
 
 <h5>Overview:</h5>