The first class types are perhaps the most important. Values of these types are the only ones which can be produced by instructions, passed as arguments, or used as operands to -instructions. This means that all structures and arrays must be -manipulated either by pointer or by component.
+instructions. @@ -1680,6 +1699,12 @@ following is the syntax for constant expressions:There are several different binary operators:
- + + <result> = add <ty> <var1>, <var2> ; yields {ty}:result
+
+
+ <result> = add <ty> <var1>, <var2> ; yields {ty}:result
+
Overview:
+
The 'add' instruction returns the sum of its two operands.
+
Arguments:
-The two arguments to the 'add' instruction must be either integer or floating point values.
- This instruction can also take vector versions of the values.
-Both arguments must have identical types.
+
+The two arguments to the 'add' instruction must be integer, floating point, or
+ vector values. Both arguments must have identical
+ types.
+
Semantics:
+
The value produced is the integer or floating point sum of the two
operands.
+
If an integer sum has unsigned overflow, the result returned is the
mathematical result modulo 2n, where n is the bit width of
the result.
+
Because LLVM integers use a two's complement representation, this
instruction is appropriate for both signed and unsigned integers.
+
Example:
- <result> = add i32 4, %var ; yields {i32}:result = 4 + %var
+
+
+ <result> = add i32 4, %var ; yields {i32}:result = 4 + %var
<result> = sub <ty> <var1>, <var2> ; yields {ty}:result
+
+
+ <result> = sub <ty> <var1>, <var2> ; yields {ty}:result
+
Overview:
+
The 'sub' instruction returns the difference of its two
operands.
-Note that the 'sub' instruction is used to represent the 'neg'
-instruction present in most other intermediate representations.
+
+Note that the 'sub' instruction is used to represent the
+'neg' instruction present in most other intermediate
+representations.
+
Arguments:
-The two arguments to the 'sub' instruction must be either integer or floating point
-values.
-This instruction can also take vector versions of the values.
-Both arguments must have identical types.
+
+The two arguments to the 'sub' instruction must be integer, floating point,
+ or vector values. Both arguments must have identical
+ types.
+
Semantics:
+
The value produced is the integer or floating point difference of
the two operands.
+
If an integer difference has unsigned overflow, the result returned is the
mathematical result modulo 2n, where n is the bit width of
the result.
+
Because LLVM integers use a two's complement representation, this
instruction is appropriate for both signed and unsigned integers.
+
Example:
<result> = sub i32 4, %var ; yields {i32}:result = 4 - %var
<result> = sub i32 0, %val ; yields {i32}:result = -%var
<result> = mul <ty> <var1>, <var2> ; yields {ty}:result
The 'mul' instruction returns the product of its two operands.
+The two arguments to the 'mul' instruction must be either integer or floating point -values. -This instruction can also take vector versions of the values. -Both arguments must have identical types.
+ +The two arguments to the 'mul' instruction must be integer, floating point, +or vector values. Both arguments must have identical +types.
+The value produced is the integer or floating point product of the two operands.
+If the result of an integer multiplication has unsigned overflow, the result returned is the mathematical result modulo 2n, where n is the bit width of the result.
@@ -2166,6 +2230,7 @@ width of the full product. <result> = mul i32 4, %var ; yields {i32}:result = 4 * %var
The 'udiv' instruction returns the quotient of its two operands.
+The two arguments to the 'udiv' instruction must be -integer values. Both arguments must have identical -types. This instruction can also take vector versions -of the values in which case the elements must be integers.
+integer or vector of integer +values. Both arguments must have identical types. +The value produced is the unsigned integer quotient of the two operands.
Note that unsigned integer division and signed integer division are distinct operations; for signed integer division, use 'sdiv'.
@@ -2195,16 +2263,21 @@ operations; for signed integer division, use 'sdiv'. <result> = sdiv <ty> <var1>, <var2> ; yields {ty}:result
+
+ <result> = sdiv <ty> <var1>, <var2> ; yields {ty}:result
+
Overview:
+
The 'sdiv' instruction returns the quotient of its two
operands.
+
Arguments:
-The two arguments to the 'sdiv' instruction must be
-integer values. Both arguments must have identical
-types. This instruction can also take vector versions
-of the values in which case the elements must be integers.
+
+The two arguments to the 'sdiv' instruction must be
+integer or vector of integer
+values. Both arguments must have identical types.
+
Semantics:
The value produced is the signed integer quotient of the two operands rounded towards zero.
Note that signed integer division and unsigned integer division are distinct
@@ -2221,22 +2294,31 @@ by doing a 32-bit division of -2147483648 by -1.
Instruction <result> = fdiv <ty> <var1>, <var2> ; yields {ty}:result
+
+ <result> = fdiv <ty> <var1>, <var2> ; yields {ty}:result
Overview:
+
The 'fdiv' instruction returns the quotient of its two
operands.
+
Arguments:
+
The two arguments to the 'fdiv' instruction must be
-floating point values. Both arguments must have
-identical types. This instruction can also take vector
-versions of floating point values.
+floating point or vector
+of floating point values. Both arguments must have identical types.
+
Semantics:
+
The value produced is the floating point quotient of the two operands.
+
Example:
- <result> = fdiv float 4.0, %var ; yields {float}:result = 4.0 / %var
+
+
+ <result> = fdiv float 4.0, %var ; yields {float}:result = 4.0 / %var
The 'urem' instruction returns the remainder from the unsigned division of its two arguments.
The two arguments to the 'urem' instruction must be -integer values. Both arguments must have identical -types. This instruction can also take vector versions -of the values in which case the elements must be integers.
+The two arguments to the 'urem' instruction must be +integer or vector of integer +values. Both arguments must have identical types.
This instruction returns the unsigned integer remainder of a division. This instruction always performs an unsigned division to get the remainder.
@@ -2264,23 +2345,33 @@ distinct operations; for signed integer remainder, use 'srem'. - + + <result> = srem <ty> <var1>, <var2> ; yields {ty}:result
+
+
+ <result> = srem <ty> <var1>, <var2> ; yields {ty}:result
+
Overview:
+
The 'srem' instruction returns the remainder from the
signed division of its two operands. This instruction can also take
vector versions of the values in which case
the elements must be integers.
Arguments:
+
The two arguments to the 'srem' instruction must be
-integer values. Both arguments must have identical
-types.
+integer or vector of integer
+values. Both arguments must have identical types.
+
Semantics:
+
This instruction returns the remainder of a division (where the result
has the same sign as the dividend, var1), not the modulo
operator (where the result has the same sign as the divisor, var2) of
@@ -2303,9 +2394,11 @@ and the remainder.)
<result> = frem <ty> <var1>, <var2> ; yields {ty}:result
@@ -2314,14 +2407,18 @@ Instruction The two arguments to the 'frem' instruction must be -floating point values. Both arguments must have -identical types. This instruction can also take vector -versions of floating point values.
+floating point or vector +of floating point values. Both arguments must have identical types. +This instruction returns the remainder of a division. The remainder has the same sign as the dividend.
+ <result> = frem float 4.0, %var ; yields {float}:result = 4.0 % %var
+
+
+ <result> = frem float 4.0, %var ; yields {float}:result = 4.0 % %var
@@ -2353,7 +2450,8 @@ the left a specified number of bits.
Both arguments to the 'shl' instruction must be the same integer type. 'var2' is treated as an
-unsigned value.
+unsigned value. This instruction does not support
+vector operands.
Semantics:
@@ -2383,7 +2481,8 @@ operand shifted to the right a specified number of bits with zero fill.
Arguments:
Both arguments to the 'lshr' instruction must be the same
integer type. 'var2' is treated as an
-unsigned value.
+unsigned value. This instruction does not support
+vector operands.
Semantics:
@@ -2418,7 +2517,8 @@ operand shifted to the right a specified number of bits with sign extension.
Arguments:
Both arguments to the 'ashr' instruction must be the same
integer type. 'var2' is treated as an
-unsigned value.
+unsigned value. This instruction does not support
+vector operands.
Semantics:
This instruction always performs an arithmetic shift right operation,
@@ -2440,17 +2540,26 @@ larger than the number of bits in var1, the result is undefined.
+
+
Syntax:
- <result> = and <ty> <var1>, <var2> ; yields {ty}:result
+
+
+ <result> = and <ty> <var1>, <var2> ; yields {ty}:result
+
Overview:
+
The 'and' instruction returns the bitwise logical and of
its two operands.
+
Arguments:
-The two arguments to the 'and' instruction must be integer values. Both arguments must have
-identical types.
+
+The two arguments to the 'and' instruction must be
+integer or vector of integer
+values. Both arguments must have identical types.
+
Semantics:
The truth table used for the 'and' instruction is:
@@ -2486,7 +2595,8 @@ identical types.
Example:
- <result> = and i32 4, %var ; yields {i32}:result = 4 & %var
+
+ <result> = and i32 4, %var ; yields {i32}:result = 4 & %var
<result> = and i32 15, 40 ; yields {i32}:result = 8
<result> = and i32 4, 8 ; yields {i32}:result = 0
@@ -2501,9 +2611,10 @@ identical types.
The 'or' instruction returns the bitwise logical inclusive
or of its two operands.
Arguments:
-The two arguments to the 'or' instruction must be integer values. Both arguments must have
-identical types.
+
+The two arguments to the 'or' instruction must be
+integer or vector of integer
+values. Both arguments must have identical types.
Semantics:
The truth table used for the 'or' instruction is:
@@ -2556,10 +2667,12 @@ Instruction
or of its two operands. The xor is used to implement the
"one's complement" operation, which is the "~" operator in C.
Arguments:
-The two arguments to the 'xor' instruction must be integer values. Both arguments must have
-identical types.
+The two arguments to the 'xor' instruction must be
+integer or vector of integer
+values. Both arguments must have identical types.
+
Semantics:
+
The truth table used for the 'xor' instruction is:
@@ -2674,7 +2787,7 @@ results are undefined.
Syntax:
- <result> = insertelement <n x <ty>> <val>, <ty> <elt>, i32 <idx> ; yields <n x <ty>>
+ <result> = insertelement <n x <ty>> <val>, <ty> <elt>, i32 <idx> ; yields <n x <ty>>
Overview:
@@ -2765,6 +2878,114 @@ operand may be undef if performing a shuffle from only one vector.
+
+
+
+
+
+LLVM supports several instructions for working with aggregate values.
+
+
+
+
+
+
+
+
+
+Syntax:
+
+
+ <result> = extractvalue <aggregate type> <val>, <idx>{, <idx>}*
+
+
+Overview:
+
+
+The 'extractvalue' instruction extracts the value of a struct field
+or array element from an aggregate value.
+
+
+
+Arguments:
+
+
+The first operand of an 'extractvalue' instruction is a
+value of struct or array
+type. The operands are constant indices to specify which value to extract
+in a similar manner as indices in a
+'getelementptr' instruction.
+
+
+Semantics:
+
+
+The result is the value at the position in the aggregate specified by
+the index operands.
+
+
+Example:
+
+
+ %result = extractvalue {i32, float} %agg, 0 ; yields i32
+
+
+
+
+
+
+
+
+
+Syntax:
+
+
+ <result> = insertvalue <aggregate type> <val>, <ty> <val>, <idx> ; yields <n x <ty>>
+
+
+Overview:
+
+
+The 'insertvalue' instruction inserts a value
+into a struct field or array element in an aggregate.
+
+
+
+Arguments:
+
+
+The first operand of an 'insertvalue' instruction is a
+value of struct or array type.
+The second operand is a first-class value to insert.
+The following operands are constant indices
+indicating the position at which to insert the value in a similar manner as
+indices in a
+'getelementptr' instruction.
+The value to insert must have the same type as the value identified
+by the indices.
+
+
Semantics:
+
+
+The result is an aggregate of the same type as val. Its
+value is that of val except that the value at the position
+specified by the indices is that of elt.
+
+
+Example:
+
+
+ %result = insertvalue {i32, float} %agg, 1, 0 ; yields {i32, float}
+
+
+
+
Memory Access and Addressing Operations
@@ -3020,8 +3241,8 @@ provided depend on the type of the first pointer argument. The
'getelementptr' 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 i32 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.
+into an array or pointer, only integers of 32 or 64 bits are allowed; 32-bit
+values will be sign extended to 64-bits if required.
For example, let's consider a C code fragment and how it gets
compiled to LLVM:
@@ -3096,7 +3317,7 @@ the LLVM code for the given testcase is equivalent to:
Note that it is undefined to access an array out of bounds: array and
pointer indexes must always be within the defined bounds of the array type.
-The one exception for this rules is zero length arrays. These arrays are
+The one exception for this rule is zero length arrays. These arrays are
defined to be accessible as variable length arrays, which requires access
beyond the zero'th element.
@@ -3532,15 +3753,19 @@ nothing is done (no-op cast).
Overview:
+
The 'bitcast' instruction converts value to type
ty2 without changing any bits.
Arguments:
+
The 'bitcast' 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. If the source
-type is a pointer, the destination type must also be a pointer.
+type is a pointer, the destination type must also be a pointer. This
+instruction supports bitwise conversion of vectors to integers and to vectors
+of other types (as long as they have the same size).
Semantics:
The 'bitcast' instruction converts value to type
@@ -3672,9 +3897,9 @@ a value, just a keyword. The possible condition code are:
floating point typed. They must have identical
types.
Semantics:
-The 'fcmp' compares var1 and var2 according to
-the condition code given as cond. The comparison performed always
-yields a i1 result, as follows:
+
The 'fcmp' instruction compares var1 and var2
+according to the condition code given as cond. The comparison performed
+always yields a i1 result, as follows:
- false: always yields false, regardless of operands.
- oeq: yields true if both operands are not a QNAN and
@@ -3715,30 +3940,144 @@ yields a i1 result, as follows:
-
+
+
+Syntax:
+ <result> = vicmp <cond> <ty> <var1>, <var2> ; yields {ty}:result
+
+Overview:
+The 'vicmp' instruction returns an integer vector value based on
+element-wise comparison of its two integer vector operands.
+Arguments:
+The 'vicmp' instruction takes three operands. The first operand is
+the condition code indicating the kind of comparison to perform. It is not
+a value, just a keyword. The possible condition code are:
+
+ - eq: equal
+ - ne: not equal
+ - ugt: unsigned greater than
+ - uge: unsigned greater or equal
+ - ult: unsigned less than
+ - ule: unsigned less or equal
+ - sgt: signed greater than
+ - sge: signed greater or equal
+ - slt: signed less than
+ - sle: signed less or equal
+
+The remaining two arguments must be vector of
+integer typed. They must also be identical types.
+Semantics:
+The 'vicmp' instruction compares var1 and var2
+according to the condition code given as cond. The comparison yields a
+vector of integer result, of
+identical type as the values being compared. The most significant bit in each
+element is 1 if the element-wise comparison evaluates to true, and is 0
+otherwise. All other bits of the result are undefined. The condition codes
+are evaluated identically to the 'icmp'
+instruction.
+
+
Example:
+
+ <result> = vicmp eq <2 x i32> < i32 4, i32 0>, < i32 5, i32 0> ; yields: result=<2 x i32> < i32 0, i32 -1 >
+ <result> = vicmp ult <2 x i8 > < i8 1, i8 2>, < i8 2, i8 2 > ; yields: result=<2 x i8> < i8 -1, i8 0 >
+
+
+
+
+
+
+Syntax:
+ <result> = vfcmp <cond> <ty> <var1>, <var2>
+Overview:
+The 'vfcmp' instruction returns an integer vector value based on
+element-wise comparison of its two floating point vector operands. The output
+elements have the same width as the input elements.
+Arguments:
+The 'vfcmp' instruction takes three operands. The first operand is
+the condition code indicating the kind of comparison to perform. It is not
+a value, just a keyword. The possible condition code are:
+
+ - false: no comparison, always returns false
+ - oeq: ordered and equal
+ - ogt: ordered and greater than
+ - oge: ordered and greater than or equal
+ - olt: ordered and less than
+ - ole: ordered and less than or equal
+ - one: ordered and not equal
+ - ord: ordered (no nans)
+ - ueq: unordered or equal
+ - ugt: unordered or greater than
+ - uge: unordered or greater than or equal
+ - ult: unordered or less than
+ - ule: unordered or less than or equal
+ - une: unordered or not equal
+ - uno: unordered (either nans)
+ - true: no comparison, always returns true
+
+The remaining two arguments must be vector of
+floating point typed. They must also be identical
+types.
+Semantics:
+The 'vfcmp' instruction compares var1 and var2
+according to the condition code given as cond. The comparison yields a
+vector of integer result, with
+an identical number of elements as the values being compared, and each element
+having identical with to the width of the floating point elements. The most
+significant bit in each element is 1 if the element-wise comparison evaluates to
+true, and is 0 otherwise. All other bits of the result are undefined. The
+condition codes are evaluated identically to the
+'fcmp' instruction.
+
+
Example:
+
+ <result> = vfcmp oeq <2 x float> < float 4, float 0 >, < float 5, float 0 > ; yields: result=<2 x i32> < i32 0, i32 -1 >
+ <result> = vfcmp ult <2 x double> < double 1, double 2 >, < double 2, double 2> ; yields: result=<2 x i64> < i64 -1, i64 0 >
+
+
+
+
+
+
+
Syntax:
+
<result> = phi <ty> [ <val0>, <label0>], ...
Overview:
The 'phi' instruction is used to implement the φ node in
the SSA graph representing the function.
Arguments:
+
The type of the incoming values is specified with the first type
field. After this, the 'phi' instruction takes a list of pairs
as arguments, with one pair for each predecessor basic block of the
current block. Only values of first class
type may be used as the value arguments to the PHI node. Only labels
may be used as the label arguments.
+
There must be no non-phi instructions between the start of a basic
block and the PHI instructions: i.e. PHI instructions must be first in
a basic block.
+
Semantics:
+
At runtime, the 'phi' instruction logically takes on the value
specified by the pair corresponding to the predecessor basic block that executed
just prior to the current block.
+
Example:
-Loop: ; Infinite loop that counts from 0 on up...
%indvar = phi i32 [ 0, %LoopHeader ], [ %nextindvar, %Loop ]
%nextindvar = add i32 %indvar, 1
br label %Loop
+
+Loop: ; Infinite loop that counts from 0 on up...
+ %indvar = phi i32 [ 0, %LoopHeader ], [ %nextindvar, %Loop ]
+ %nextindvar = add i32 %indvar, 1
+ br label %Loop
+
@@ -3765,13 +4104,16 @@ condition, without branching.
Arguments:
-The 'select' instruction requires a boolean value indicating the condition, and two values of the same first class type.
+The 'select' instruction requires an 'i1' value indicating the
+condition, and two values of the same first class
+type. If the val1/val2 are vectors, the entire vectors are selected, not
+individual elements.
Semantics:
-If the boolean condition evaluates to true, the instruction returns the first
+If the i1 condition evaluates is 1, the instruction returns the first
value argument; otherwise, it returns the second value argument.
@@ -4207,7 +4549,7 @@ value address) contains the meta-data to be associated with the root.
Semantics:
-At runtime, a call to this intrinsics stores a null pointer into the "ptrloc"
+
At runtime, a call to this intrinsic stores a null pointer into the "ptrloc"
location. At compile-time, the code generator generates information to allow
the runtime to find the pointer at GC safe points. The 'llvm.gcroot'
intrinsic may only be used in a function which specifies a GC