; Emulate a conditional br instruction

; Emulate a conditional br instruction
- %Val = cast bool %value to int
+ %Val = zext bool %value to int
  switch int %Val, label %truedest [int 0, label %falsedest ]
 
  ; Emulate an unconditional br instruction
@@ -2740,60 +2797,375 @@
 
 
 
-   'cast .. to' Instruction
+   'trunc .. to' Instruction
 
-
 
 
 Syntax:
-
 -  <result> = cast <ty> <value> to <ty2>             ; yields ty2
+  <result> = trunc <ty> <value> to <ty2>             ; yields ty2
 
 
 Overview:
-
 
-The 'cast' instruction is used as the primitive means to convert
-integers to floating point, change data type sizes, and break type safety (by
-casting pointers).
+The 'trunc' instruction truncates its operand to the type ty2.
 
 
-
 Arguments:
+
+The 'trunc' instruction takes a value to trunc, which must 
+be an integer type, and a type that specifies the size 
+and type of the result, which must be an integral 
+type.
 
+Semantics:
 
-The 'cast' instruction takes a value to cast, which must be a first
-class value, and a type to cast it to, which must also be a first class type.
-
+The 'trunc' instruction truncates the high order bits in value
+and converts the reamining bits to ty2. The bit size of value
+must be larger than the bit size of ty2. Equal sized types are not 
+allowed.  This implies that a trunc cannot be a no-op cast. It 
+will always truncate bits.
+
+When truncating to bool, the truncation is done as a comparison against 
+zero. If the value was zero, the bool result will be false. 
+If the value was non-zero, the bool result will be true.
+
+Example:
++  %X = trunc int 257 to ubyte              ; yields ubyte:1
+  %Y = trunc int 123 to bool               ; yields bool:true
+
+
+
+
+
+   'zext .. to' Instruction
+
+
+
+Syntax:
++  <result> = zext <ty> <value> to <ty2>             ; yields ty2
+
+
+Overview:
+The 'zext' instruction zero extends its operand to type 
+ty2.
+
+
+Arguments:
+The 'zext' instruction takes a value to cast, which must be of 
+integral type, and a type to cast it to, which must
+also be of integral type. The bit size of the
+value must be smaller than or equal to the bit size of the 
+destination type, ty2.
 
 Semantics:
+The zext fills the high order bits of the value with zero
+bits until it reaches the size of the destination type, ty2. When the
+the operand and the type are the same size, no bit filling is done and the 
+cast is considered a no-op cast because no bits change (only the type 
+changes).
+
+When zero extending to bool, the extension is done as a comparison against 
+zero. If the value was zero, the bool result will be false. 
+If the value was non-zero, the bool result will be true.
 
+Example:
++  %X = zext int 257 to ulong              ; yields ulong:257
+  %Y = zext bool true to int              ; yields int:1
+
+
+
+
+
+   'sext .. to' Instruction
+
+
+
+Syntax:
++  <result> = sext <ty> <value> to <ty2>             ; yields ty2
+
+
+Overview:
+The 'sext' sign extends value to the type ty2.
+
+Arguments:
 
-This instruction follows the C rules for explicit casts when determining how the
-data being cast must change to fit in its new container.
-
+The 'sext' instruction takes a value to cast, which must be of 
+integral type, and a type to cast it to, which must
+also be of integral type.
 
+Semantics:
 
-When casting to bool, any value that would be considered true in the context of
-a C 'if' condition is converted to the boolean 'true' values,
-all else are 'false'.
+The 'sext' instruction performs a sign extension by copying the sign
+bit (highest order bit) of the value until it reaches the bit size of
+the type ty2.  When the the operand and the type are the same size, 
+no bit filling is done and the cast is considered a no-op cast because 
+no bits change (only the type changes).
+
+When sign extending to bool, the extension is done as a comparison against 
+zero. If the value was zero, the bool result will be false. 
+If the value was non-zero, the bool result will be true.
+
+Example:
+
++  %X = sext sbyte -1 to ushort           ; yields ushort:65535
+  %Y = sext bool true to int             ; yields int:-1
+
+
+
+
+
+   'fpext .. to' Instruction
+
+
+
+Syntax:
++  <result> = fpext <ty> <value> to <ty2>             ; yields ty2
+
+
+Overview:
+The 'fpext' extends a floating point value to a larger
+floating point value.
+
+Arguments:
+The 'fpext' instruction takes a 
+floating point value to cast, 
+and a floating point type to cast it to.
+
+Semantics:
+The 'fpext' instruction extends the value from one floating
+point type to another. If the type of the value and ty2 are
+the same, the instruction is considered a no-op cast because no bits
+change.
+
+Example:
++  %X = fpext float 3.1415 to double        ; yields double:3.1415
+  %Y = fpext float 1.0 to float            ; yields float:1.0 (no-op)
+
+
+
+
+
+   'fptrunc .. to' Instruction
+
+
+
+
+Syntax:
+
++  <result> = fptrunc <ty> <value> to <ty2>             ; yields ty2
+
+
+Overview:
+The 'fptrunc' instruction truncates value to type
+ty2.
+
+
+Arguments:
+The 'fptrunc' instruction takes a floating
+  point value to cast and a floating point type to
+cast it to. The size of value must be larger than the size of
+ty2. This implies that fptrunc cannot be used to make a 
+no-op cast.

+
+Semantics:
+ The 'fptrunc' instruction converts a 
+floating point value from a larger type to a smaller 
+type. If the value cannot fit within the destination type, ty2, then 
+the results are undefined.
+
+Example:
++  %X = fptrunc double 123.0 to float         ; yields float:123.0
+  %Y = fptrunc double 1.0E+300 to float      ; yields undefined
+
+

+
+
+
+   'fp2uint .. to' Instruction
+
+
+
+Syntax:
++  <result> = fp2uint <ty> <value> to <ty2>             ; yields ty2
+
+
+Overview:
+The 'fp2uint' converts a floating point value to its
+unsigned integer equivalent of type ty2.
 
 
-
-When extending an integral value from a type of one signness to another (for
-example 'sbyte' to 'ulong'), the value is sign-extended if the
-source value is signed, and zero-extended if the source value is
-unsigned. bool values are always zero extended into either zero or
-one.
+
Arguments:
+The 'fp2uint' instruction takes a value to cast, which must be a 
+floating point value, and a type to cast it to, which
+must be an integral type.
+
+Semantics:
+ The 'fp2uint' instruction converts its 
+floating point operand into the nearest (rounding
+towards zero) unsigned integer value. If the value cannot fit in ty2,
+the results are undefined.
+
+When converting to bool, the conversion is done as a comparison against 
+zero. If the value was zero, the bool result will be false. 
+If the value was non-zero, the bool result will be true.
+
+Example:
++  %X = fp2uint double 123.0 to int         ; yields int:123
+  %Y = fp2uint float 1.0E+300 to bool      ; yields bool:true
+  %X = fp2uint float 1.04E+17 to ubyte     ; yields undefined:1
+
+
+
+
+
+   'fp2sint .. to' Instruction
+
+
+
+Syntax:
++  <result> = fp2sint <ty> <value> to <ty2>             ; yields ty2
+
+
+Overview:
+The 'fp2sint' instruction converts 
+floating point value to type ty2.
 
 
+
+Arguments:
+ The 'fp2sint' instruction takes a value to cast, which must be a 
+floating point value, and a type to cast it to, which 
+must also be an integral type.
+
+Semantics:
+The 'fp2sint' instruction converts its 
+floating point operand into the nearest (rounding
+towards zero) signed integer value. If the value cannot fit in ty2,
+the results are undefined.
+
+When converting to bool, the conversion is done as a comparison against 
+zero. If the value was zero, the bool result will be false. 
+If the value was non-zero, the bool result will be true.
+
+Example:
++  %X = fp2sint double -123.0 to int        ; yields int:-123
+  %Y = fp2sint float 1.0E-247 to bool      ; yields bool:true
+  %X = fp2sint float 1.04E+17 to sbyte     ; yields undefined:1
+
+
+
+
+
+   'uint2fp .. to' Instruction
+
+
+
+Syntax:
++  <result> = uint2fp <ty> <value> to <ty2>             ; yields ty2
+
+
+Overview:
+The 'uint2fp' instruction regards value as an unsigned
+integer and converts that value to the ty2 type.
+
+
+Arguments:
+The 'uint2fp' instruction takes a value to cast, which must be an
+integral value, and a type to cast it to, which must 
+be a floating point type.
+
+Semantics:
+The 'uint2fp' instruction interprets its operand as an unsigned
+integer quantity and converts it to the corresponding floating point value. If
+the value cannot fit in the floating point value, the results are undefined.
+
+
+Example:
++  %X = uint2fp int 257 to float         ; yields float:257.0
+  %Y = uint2fp sbyte -1 to double       ; yields double:255.0
+
+
+
+
+
+   'sint2fp .. to' Instruction
+
+
+
+Syntax:
++  <result> = sint2fp <ty> <value> to <ty2>             ; yields ty2
+
+
+Overview:
+The 'sint2fp' instruction regards value as a signed
+integer and converts that value to the ty2 type.
+
+Arguments:
+The 'sint2fp' instruction takes a value to cast, which must be an
+integral value, and a type to cast it to, which must be
+a floating point type.
+
+Semantics:
+The 'sint2fp' instruction interprets its operand as a signed
+integer quantity and converts it to the corresponding floating point value. If
+the value cannot fit in the floating point value, the results are undefined.
+
 Example:
++  %X = sint2fp int 257 to float         ; yields float:257.0
+  %Y = sint2fp sbyte -1 to double       ; yields double:-1.0
+
+
 
+
+
+   'bitconvert .. to' Instruction
+
+
+
+Syntax:
++  <result> = bitconvert <ty> <value> to <ty2>             ; yields ty2
+
+
+Overview:
+The 'bitconvert' instruction converts value to type
+ty2 without changing any bits.
+
+Arguments:
+The 'bitconvert' instruction takes a value to cast, which must be 
+a first class value, and a type to cast it to, which must also be a first class type. The bit sizes of value
+and the destination type, ty2, must be identical.
+
+Semantics:
+The 'bitconvert' instruction converts value to type
+ty2 as if the value had been stored to memory and read back as type
+ty2. That is, no bits are changed during the conversion. The
+bitconvert instruction may be used to construct no-op casts that
+the zext, sext, and fpext instructions do not permit.
+
+Example:
 -  %X = cast int 257 to ubyte              ; yields ubyte:1
-  %Y = cast int 123 to bool               ; yields bool:true
+  %X = bitconvert ubyte 255 to sbyte         ; yields sbyte:-1
+  %Y = bitconvert uint* %x to uint           ; yields uint:%x
 
 
 
@@ -4000,7 +4372,7 @@
 
   Chris Lattner

   The LLVM Compiler Infrastructure

-  Last modified: $Date: 2006/11/02 01:53:58 $
+  Last modified: $Date: 2006/11/08 01:11:31 $
 
 
 





From reid at x10sys.com  Tue Nov  7 19:19:06 2006
From: reid at x10sys.com (Reid Spencer)
Date: Tue, 7 Nov 2006 19:19:06 -0600
Subject: [llvm-commits] CVS: llvm/docs/LangRef.html
Message-ID: <200611080119.kA81J6Eq019964@zion.cs.uiuc.edu>



Changes in directory llvm/docs:

LangRef.html updated: 1.161 -> 1.162
---
Log message:

Fix the section headings.


---
Diffs of the changes:  (+39 -30)

 LangRef.html |   69 +++++++++++++++++++++++++++++++++--------------------------
 1 files changed, 39 insertions(+), 30 deletions(-)


Index: llvm/docs/LangRef.html
diff -u llvm/docs/LangRef.html:1.161 llvm/docs/LangRef.html:1.162

--- llvm/docs/LangRef.html:1.161	Tue Nov  7 19:11:31 2006
+++ llvm/docs/LangRef.html	Tue Nov  7 19:18:52 2006
@@ -115,7 +115,7 @@
          'getelementptr' Instruction
         

Operation	Result is true iff	Comparison is
`eq`	var1 == var2	--
`ne`	var1 != var2	--
`slt`	var1 < var2	signed
`sgt`	var1 > var2	signed
`sle`	var1 <= var2	signed
`sge`	var1 >= var2	signed
`ult`	var1 < var2	unsigned
`ugt`	var1 > var2	unsigned
`ule`	var1 <= var2	unsigned
`uge`	var1 >= var2	unsigned
`true`	always	--
`false`	never	--

Operation	If unordered	Otherwise true iff
`eq`	undefined	var1 == var2
`ne`	undefined	var1 != var2
`lt`	undefined	var1 < var2
`gt`	undefined	var1 > var2
`le`	undefined	var1 <= var2
`ge`	undefined	var1 >= var2
`oeq`	false	var1 == var2
`one`	false	var1 != var2
`olt`	false	var1 < var2
`ogt`	false	var1 > var2
`ole`	false	var1 <= var2
`oge`	false	var1 >= var2
`ueq`	true	var1 == var2
`une`	true	var1 != var2
`ult`	true	var1 < var2
`ugt`	true	var1 > var2
`ule`	true	var1 <= var2
`uge`	true	var1 >= var2
`o`	false	always
`u`	true	never
`true`	true	always
`false`	false	never