Perform the specified operation of the LHS and RHS constants. OPCODE may
be any of the binary
or bitwise binary operations. The constraints
@@ -2166,7 +2321,7 @@ Classifications
the two digit hex code. For example: "!"test\00"".
Metadata nodes are represented with notation similar to structure constants
- (a comma separated list of elements, surrounded by braces and preceeded by an
+ (a comma separated list of elements, surrounded by braces and preceded by an
exclamation point). For example: "!{ metadata !"test\00", i32
10}".
@@ -2179,59 +2334,166 @@ Classifications
computable. Similarly, the code generator may expect a certain metadata
format to be used to express debugging information.
-
+
+
+
+
+
+
+
+
+
+
+
+
LLVM supports inline assembler expressions (as opposed
+ to Module-Level Inline Assembly) through the use of
+ a special value. This value represents the inline assembler as a string
+ (containing the instructions to emit), a list of operand constraints (stored
+ as a string), a flag that indicates whether or not the inline asm
+ expression has side effects, and a flag indicating whether the function
+ containing the asm needs to align its stack conservatively. An example
+ inline assembler expression is:
+
+
+
+i32 (i32) asm "bswap $0", "=r,r"
+
+
+
+
Inline assembler expressions may only be used as the callee operand of
+ a call instruction. Thus, typically we
+ have:
+
+
+
+%X = call i32 asm "bswap $0", "=r,r"(i32 %Y)
+
+
+
+
Inline asms with side effects not visible in the constraint list must be
+ marked as having side effects. This is done through the use of the
+ 'sideeffect' keyword, like so:
+
+
+
+call void asm sideeffect "eieio", ""()
+
+
+
+
In some cases inline asms will contain code that will not work unless the
+ stack is aligned in some way, such as calls or SSE instructions on x86,
+ yet will not contain code that does that alignment within the asm.
+ The compiler should make conservative assumptions about what the asm might
+ contain and should generate its usual stack alignment code in the prologue
+ if the 'alignstack' keyword is present:
+
+
+
+call void asm alignstack "eieio", ""()
+
+
+
+
If both keywords appear the 'sideeffect' keyword must come
+ first.
+
+
TODO: The format of the asm and constraints string still need to be
+ documented here. Constraints on what can be done (e.g. duplication, moving,
+ etc need to be documented). This is probably best done by reference to
+ another document that covers inline asm from a holistic perspective.
+
+
LLVM has a number of "magic" global variables that contain data that affect
+code generation or other IR semantics. These are documented here. All globals
+of this sort should have a section specified as "llvm.metadata". This
+section and all globals that start with "llvm." are reserved for use
+by LLVM.
+
+
+
+
+
+
+
The @llvm.used global is an array with i8* element type which has appending linkage. This array contains a list of
+pointers to global variables and functions which may optionally have a pointer
+cast formed of bitcast or getelementptr. For example, a legal use of it is:
+
+
+ @X = global i8 4
+ @Y = global i32 123
+
+ @llvm.used = appending global [2 x i8*] [
+ i8* @X,
+ i8* bitcast (i32* @Y to i8*)
+ ], section "llvm.metadata"
+
+
+
If a global variable appears in the @llvm.used list, then the
+compiler, assembler, and linker are required to treat the symbol as if there is
+a reference to the global that it cannot see. For example, if a variable has
+internal linkage and no references other than that from the @llvm.used
+list, it cannot be deleted. This is commonly used to represent references from
+inline asms and other things the compiler cannot "see", and corresponds to
+"attribute((used))" in GNU C.
-
-
-
+
On some targets, the code generator must emit a directive to the assembler or
+object file to prevent the assembler and linker from molesting the symbol.
+
+
-
LLVM supports inline assembler expressions (as opposed
- to Module-Level Inline Assembly) through the use of
- a special value. This value represents the inline assembler as a string
- (containing the instructions to emit), a list of operand constraints (stored
- as a string), and a flag that indicates whether or not the inline asm
- expression has side effects. An example inline assembler expression is:
+
The @llvm.compiler.used directive is the same as the
+@llvm.used directive, except that it only prevents the compiler from
+touching the symbol. On targets that support it, this allows an intelligent
+linker to optimize references to the symbol without being impeded as it would be
+by @llvm.used.
-
-
-i32 (i32) asm "bswap $0", "=r,r"
-
-
+
This is a rare construct that should only be used in rare circumstances, and
+should not be exposed to source languages.
-
Inline assembler expressions may only be used as the callee operand of
- a call instruction. Thus, typically we
- have:
+
-
-%X = call i32 asm "bswap $0", "=r,r"(i32 %Y)
-
+
+
-
Inline asms with side effects not visible in the constraint list must be
- marked as having side effects. This is done through the use of the
- 'sideeffect' keyword, like so:
+
+
+
TODO: Describe this.
-
-
-call void asm sideeffect "eieio", ""()
-
-
TODO: The format of the asm and constraints string still need to be
- documented here. Constraints on what can be done (e.g. duplication, moving,
- etc need to be documented). This is probably best done by reference to
- another document that covers inline asm from a holistic perspective.
+
+
+
+
+
@@ -2264,6 +2526,7 @@ Instructions
'
ret' instruction, the
'
br' instruction, the
'
switch' instruction, the
+ '
'indirectbr' Instruction, the
'
invoke' instruction, the
'
unwind' instruction, and the
'
unreachable' instruction.
@@ -2283,7 +2546,6 @@ Instruction
Overview:
-
The 'ret' instruction is used to return control flow (and optionally
a value) from a function back to the caller.
@@ -2292,7 +2554,6 @@ Instruction
occur.
Arguments:
-
The 'ret' instruction optionally accepts a single argument, the
return value. The type of the return value must be a
'first class' type.
@@ -2304,7 +2565,6 @@ Instruction
return value.
Semantics:
-
When the 'ret' instruction is executed, control flow returns back to
the calling function's context. If the caller is a
"call" instruction, execution continues at the
@@ -2315,21 +2575,12 @@ Instruction
value.
Example:
-
ret i32 5 ; Return an integer value of 5
ret void ; Return from a void function
ret { i32, i8 } { i32 4, i8 2 } ; Return a struct of values 4 and 2
-Note that the code generator does not yet fully support large
- return values. The specific sizes that are currently supported are
- dependent on the target. For integers, on 32-bit targets the limit
- is often 64 bits, and on 64-bit targets the limit is often 128 bits.
- For aggregate types, the current limits are dependent on the element
- types; for example targets are often limited to 2 total integer
- elements and 2 total floating-point elements.
-
@@ -2360,8 +2611,16 @@ Instruction
control flows to the 'iffalse' label argument.
Example:
-Test:
%cond = icmp eq i32 %a, %b
br i1 %cond, label %IfEqual, label %IfUnequal
IfEqual:
ret i32 1
IfUnequal:
ret i32 0
+
+Test:
+ %cond = icmp eq i32 %a, %b
+ br i1 %cond, label %IfEqual, label %IfUnequal
+IfEqual:
+ ret i32 1
+IfUnequal:
+ ret i32 0
+
+
@@ -2392,8 +2651,8 @@ Instruction
The switch instruction specifies a table of values and
destinations. When the 'switch' instruction is executed, this table
is searched for the given value. If the value is found, control flow is
- transfered to the corresponding destination; otherwise, control flow is
- transfered to the default destination.
+ transferred to the corresponding destination; otherwise, control flow is
+ transferred to the default destination.
Implementation:
Depending on properties of the target machine and the particular
@@ -2418,6 +2677,55 @@ Instruction
+
+
+
+
+
+
+
Syntax:
+
+ indirectbr <somety>* <address>, [ label <dest1>, label <dest2>, ... ]
+
+
+
Overview:
+
+
The 'indirectbr' instruction implements an indirect branch to a label
+ within the current function, whose address is specified by
+ "address". Address must be derived from a blockaddress constant.
+
+
Arguments:
+
+
The 'address' argument is the address of the label to jump to. The
+ rest of the arguments indicate the full set of possible destinations that the
+ address may point to. Blocks are allowed to occur multiple times in the
+ destination list, though this isn't particularly useful.
+
+
This destination list is required so that dataflow analysis has an accurate
+ understanding of the CFG.
+
+
Semantics:
+
+
Control transfers to the block specified in the address argument. All
+ possible destination blocks must be listed in the label list, otherwise this
+ instruction has undefined behavior. This implies that jumps to labels
+ defined in other functions have undefined behavior as well.
+
+
Implementation:
+
+
This is typically implemented with a jump through a register.
+
+
Example:
+
+ indirectbr i8* %Addr, [ label %bb1, label %bb2, label %bb3 ]
+
+
+
Syntax:
- <result> = add <ty> <op1>, <op2> ; yields {ty}:result
+ <result> = add <ty> <op1>, <op2> ; yields {ty}:result
+ <result> = add nuw <ty> <op1>, <op2> ; yields {ty}:result
+ <result> = add nsw <ty> <op1>, <op2> ; yields {ty}:result
+ <result> = add nuw nsw <ty> <op1>, <op2> ; yields {ty}:result
Overview:
The 'add' instruction returns the sum of its two operands.
Arguments:
-
The two arguments to the 'add' instruction must
be integer or vector of
integer values. Both arguments must have identical types.
@@ -2599,6 +2909,11 @@ Instruction
Because LLVM integers use a two's complement representation, this instruction
is appropriate for both signed and unsigned integers.
+nuw and nsw stand for "No Unsigned Wrap"
+ and "No Signed Wrap", respectively. If the nuw and/or
+ nsw keywords are present, the result value of the add
+ is undefined if unsigned and/or signed overflow, respectively, occurs.
+
Example:
<result> = add i32 4, %var ; yields {i32}:result = 4 + %var
@@ -2645,7 +2960,10 @@ Instruction
Syntax:
- <result> = sub <ty> <op1>, <op2> ; yields {ty}:result
+ <result> = sub <ty> <op1>, <op2> ; yields {ty}:result
+ <result> = sub nuw <ty> <op1>, <op2> ; yields {ty}:result
+ <result> = sub nsw <ty> <op1>, <op2> ; yields {ty}:result
+ <result> = sub nuw nsw <ty> <op1>, <op2> ; yields {ty}:result
Overview:
@@ -2671,6 +2989,11 @@ Instruction
Because LLVM integers use a two's complement representation, this instruction
is appropriate for both signed and unsigned integers.
+nuw and nsw stand for "No Unsigned Wrap"
+ and "No Signed Wrap", respectively. If the nuw and/or
+ nsw keywords are present, the result value of the sub
+ is undefined if unsigned and/or signed overflow, respectively, occurs.
+
Example:
<result> = sub i32 4, %var ; yields {i32}:result = 4 - %var
@@ -2700,7 +3023,7 @@ Instruction
representations.
Arguments:
-The two arguments to the 'fsub' instruction must be The two arguments to the 'fsub' instruction must be
floating point or vector of
floating point values. Both arguments must have identical types.
@@ -2724,7 +3047,10 @@ Instruction
Syntax:
- <result> = mul <ty> <op1>, <op2> ; yields {ty}:result
+ <result> = mul <ty> <op1>, <op2> ; yields {ty}:result
+ <result> = mul nuw <ty> <op1>, <op2> ; yields {ty}:result
+ <result> = mul nsw <ty> <op1>, <op2> ; yields {ty}:result
+ <result> = mul nuw nsw <ty> <op1>, <op2> ; yields {ty}:result
Overview:
@@ -2734,7 +3060,7 @@ Instruction
The two arguments to the 'mul' instruction must
be integer or vector of
integer values. Both arguments must have identical types.
-
+
Semantics:
The value produced is the integer product of the two operands.
@@ -2749,6 +3075,11 @@ Instruction
be sign-extended or zero-extended as appropriate to the width of the full
product.
+nuw and nsw stand for "No Unsigned Wrap"
+ and "No Signed Wrap", respectively. If the nuw and/or
+ nsw keywords are present, the result value of the mul
+ is undefined if unsigned and/or signed overflow, respectively, occurs.
+
Example:
<result> = mul i32 4, %var ; yields {i32}:result = 4 * %var
@@ -2801,7 +3132,7 @@ Instruction
The 'udiv' instruction returns the quotient of its two operands.
Arguments:
-The two arguments to the 'udiv' instruction must be
+
The two arguments to the 'udiv' instruction must be
integer or vector of integer
values. Both arguments must have identical types.
@@ -2828,14 +3159,15 @@ Instruction
Syntax:
- <result> = sdiv <ty> <op1>, <op2> ; yields {ty}:result
+ <result> = sdiv <ty> <op1>, <op2> ; yields {ty}:result
+ <result> = sdiv exact <ty> <op1>, <op2> ; yields {ty}:result
Overview:
The 'sdiv' instruction returns the quotient of its two operands.
Arguments:
-The two arguments to the 'sdiv' instruction must be
+
The two arguments to the 'sdiv' instruction must be
integer or vector of integer
values. Both arguments must have identical types.
@@ -2850,6 +3182,10 @@ Instruction
undefined behavior; this is a rare case, but can occur, for example, by doing
a 32-bit division of -2147483648 by -1.
+If the exact keyword is present, the result value of the
+ sdiv is undefined if the result would be rounded or if overflow
+ would occur.
+
Example:
<result> = sdiv i32 4, %var ; yields {i32}:result = 4 / %var
@@ -2902,7 +3238,7 @@ Instruction
division of its two arguments.
Arguments:
-The two arguments to the 'urem' instruction must be
+
The two arguments to the 'urem' instruction must be
integer or vector of integer
values. Both arguments must have identical types.
@@ -2942,7 +3278,7 @@ Instruction
elements must be integers.
Arguments:
-The two arguments to the 'srem' instruction must be
+
The two arguments to the 'srem' instruction must be
integer or vector of integer
values. Both arguments must have identical types.
@@ -3037,7 +3373,7 @@ Instruction
Both arguments to the 'shl' instruction must be the
same integer or vector of
integer type. 'op2' is treated as an unsigned value.
-
+
Semantics:
The value produced is op1 * 2op2 mod
2n, where n is the width of the result. If op2
@@ -3073,7 +3409,7 @@ Instruction
operand shifted to the right a specified number of bits with zero fill.
Arguments:
-Both arguments to the 'lshr' instruction must be the same
+
Both arguments to the 'lshr' instruction must be the same
integer or vector of integer
type. 'op2' is treated as an unsigned value.
@@ -3113,7 +3449,7 @@ Instruction
extension.
Arguments:
-Both arguments to the 'ashr' instruction must be the same
+
Both arguments to the 'ashr' instruction must be the same
integer or vector of integer
type. 'op2' is treated as an unsigned value.
@@ -3153,7 +3489,7 @@ Instruction
operands.
Arguments:
-The two arguments to the 'and' instruction must be
+
The two arguments to the 'and' instruction must be
integer or vector of integer
values. Both arguments must have identical types.
@@ -3212,7 +3548,7 @@ Instruction
two operands.
Arguments:
-The two arguments to the 'or' instruction must be
+
The two arguments to the 'or' instruction must be
integer or vector of integer
values. Both arguments must have identical types.
@@ -3275,7 +3611,7 @@ Instruction
complement" operation, which is the "~" operator in C.
Arguments:
-The two arguments to the 'xor' instruction must be
+
The two arguments to the 'xor' instruction must be
integer or vector of integer
values. Both arguments must have identical types.
@@ -3323,7 +3659,7 @@ Instruction
-
+
@@ -3369,7 +3705,7 @@ Instruction
Example:
- %result = extractelement <4 x i32> %vec, i32 0 ; yields i32
+ <result> = extractelement <4 x i32> %vec, i32 0 ; yields i32
@@ -3405,7 +3741,7 @@ Instruction
Example:
- %result = insertelement <4 x i32> %vec, i32 1, i32 0 ; yields <4 x i32>
+ <result> = insertelement <4 x i32> %vec, i32 1, i32 0 ; yields <4 x i32>
@@ -3446,20 +3782,20 @@ Instruction
Example:
- %result = shufflevector <4 x i32> %v1, <4 x i32> %v2,
+ <result> = shufflevector <4 x i32> %v1, <4 x i32> %v2,
<4 x i32> <i32 0, i32 4, i32 1, i32 5> ; yields <4 x i32>
- %result = shufflevector <4 x i32> %v1, <4 x i32> undef,
+ <result> = shufflevector <4 x i32> %v1, <4 x i32> undef,
<4 x i32> <i32 0, i32 1, i32 2, i32 3> ; yields <4 x i32> - Identity shuffle.
- %result = shufflevector <8 x i32> %v1, <8 x i32> undef,
+ <result> = shufflevector <8 x i32> %v1, <8 x i32> undef,
<4 x i32> <i32 0, i32 1, i32 2, i32 3> ; yields <4 x i32>
- %result = shufflevector <4 x i32> %v1, <4 x i32> %v2,
+ <result> = shufflevector <4 x i32> %v1, <4 x i32> %v2,
<8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7 > ; yields <8 x i32>
-
+
@@ -3498,7 +3834,7 @@ Instruction
Example:
- %result = extractvalue {i32, float} %agg, 0 ; yields i32
+ <result> = extractvalue {i32, float} %agg, 0 ; yields i32
@@ -3537,14 +3873,14 @@ Instruction
Example:
- %result = insertvalue {i32, float} %agg, i32 1, 0 ; yields {i32, float}
+ <result> = insertvalue {i32, float} %agg, i32 1, 0 ; yields {i32, float}
-
+
@@ -3552,93 +3888,11 @@ Instruction
A key design point of an SSA-based representation is how it represents
memory. In LLVM, no memory locations are in SSA form, which makes things
- very simple. This section describes how to read, write, allocate, and free
+ very simple. This section describes how to read, write, and allocate
memory in LLVM.
-
-
-
-
-
-
Syntax:
-
- <result> = malloc <type>[, i32 <NumElements>][, align <alignment>] ; yields {type*}:result
-
-
-
Overview:
-
The 'malloc' instruction allocates memory from the system heap and
- returns a pointer to it. The object is always allocated in the generic
- address space (address space zero).
-
-
Arguments:
-
The 'malloc' instruction allocates
- sizeof(<type>)*NumElements bytes of memory from the operating
- system and returns a pointer of the appropriate type to the program. If
- "NumElements" is specified, it is the number of elements allocated, otherwise
- "NumElements" is defaulted to be one. If a constant alignment is specified,
- the value result of the allocation is guaranteed to be aligned to at least
- that boundary. If not specified, or if zero, the target can choose to align
- the allocation on any convenient boundary compatible with the type.
-
-
'type' must be a sized type.
-
-
Semantics:
-
Memory is allocated using the system "malloc" function, and a
- pointer is returned. The result of a zero byte allocation is undefined. The
- result is null if there is insufficient memory available.
-
-
Example:
-
- %array = malloc [4 x i8] ; yields {[%4 x i8]*}:array
-
- %size = add i32 2, 2 ; yields {i32}:size = i32 4
- %array1 = malloc i8, i32 4 ; yields {i8*}:array1
- %array2 = malloc [12 x i8], i32 %size ; yields {[12 x i8]*}:array2
- %array3 = malloc i32, i32 4, align 1024 ; yields {i32*}:array3
- %array4 = malloc i32, align 1024 ; yields {i32*}:array4
-
-
-
Note that the code generator does not yet respect the alignment value.
-
-
-
-
Syntax:
-
- free <type> <value> ; yields {void}
-
-
-
Overview:
-
The 'free' instruction returns memory back to the unused memory heap
- to be reallocated in the future.
-
-
Arguments:
-
'value' shall be a pointer value that points to a value that was
- allocated with the 'malloc' instruction.
-
-
Semantics:
-
Access to the memory pointed to by the pointer is no longer defined after
- this instruction executes. If the pointer is null, the operation is a
- noop.
-
-
Example:
-
- %array = malloc [4 x i8] ; yields {[4 x i8]*}:array
- free [4 x i8]* %array
-
-
-
Syntax:
<result> = getelementptr <pty>* <ptrval>{, <ty> <idx>}*
+ <result> = getelementptr inbounds <pty>* <ptrval>{, <ty> <idx>}*
Overview:
@@ -3812,7 +4067,7 @@ Instruction
Arguments:
The first argument is always a pointer, and forms the basis of the
- calculation. The remaining arguments are indices, that indicate which of the
+ calculation. The remaining arguments are indices that indicate which of the
elements of the aggregate object are indexed. The interpretation of each
index is dependent on the type being indexed into. The first index always
indexes the pointer value given as the first argument, the second index
@@ -3824,9 +4079,10 @@ Instruction
calculation.
The type of each index argument depends on the type it is indexing into.
- When indexing into a (packed) structure, only i32 integer
+ When indexing into a (optionally packed) structure, only i32 integer
constants are allowed. When indexing into an array, pointer or
- vector, integers of any width are allowed (also non-constants).
+ vector, integers of any width are allowed, and they are not required to be
+ constant.
For example, let's consider a C code fragment and how it gets compiled to
LLVM:
@@ -3857,7 +4113,7 @@ int *foo(struct ST *s) {
%RT = type { i8 , [10 x [20 x i32]], i8 }
%ST = type { i32, double, %RT }
-define i32* %foo(%ST* %s) {
+define i32* @foo(%ST* %s) {
entry:
%reg = getelementptr %ST* %s, i32 1, i32 2, i32 1, i32 5, i32 13
ret i32* %reg
@@ -3881,7 +4137,7 @@ entry:
the given testcase is equivalent to:
- define i32* %foo(%ST* %s) {
+ define i32* @foo(%ST* %s) {
%t1 = getelementptr %ST* %s, i32 1 ; yields %ST*:%t1
%t2 = getelementptr %ST* %t1, i32 0, i32 2 ; yields %RT*:%t2
%t3 = getelementptr %RT* %t2, i32 0, i32 1 ; yields [10 x [20 x i32]]*:%t3
@@ -3891,12 +4147,22 @@ entry:
}
-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 when
- accessed with an instruction that dereferences the pointer (e.g. a load or
- store instruction). 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.
+If the inbounds keyword is present, the result value of the
+ getelementptr is undefined if the base pointer is not an
+ in bounds address of an allocated object, or if any of the addresses
+ that would be formed by successive addition of the offsets implied by the
+ indices to the base address with infinitely precise arithmetic are not an
+ in bounds address of that allocated object.
+ The in bounds addresses for an allocated object are all the addresses
+ that point into the object, plus the address one byte past the end.
+
+If the inbounds keyword is not present, the offsets are added to
+ the base address with silently-wrapping two's complement arithmetic, and
+ the result value of the getelementptr may be outside the object
+ pointed to by the base pointer. The result value may not necessarily be
+ used to access memory though, even if it happens to point into allocated
+ storage. See the Pointer Aliasing Rules
+ section for more information.
The getelementptr instruction is often confusing. For some more insight into
how it works, see the getelementptr FAQ.
@@ -3960,7 +4226,7 @@ entry:
%X = trunc i32 257 to i8 ; yields i8:1
%Y = trunc i32 123 to i1 ; yields i1:true
- %Y = trunc i32 122 to i1 ; yields i1:false
+ %Z = trunc i32 122 to i1 ; yields i1:false
@@ -3977,15 +4243,15 @@ entry:
Overview:
-The 'zext' instruction zero extends its operand to type
+
The 'zext' instruction zero extends its operand to type
ty2.
Arguments:
-The 'zext' instruction takes a value to cast, which must be of
+
The 'zext' instruction takes a value to cast, which must be of
integer type, and a type to cast it to, which must
also be of integer type. The bit size of the
- value must be smaller than the bit size of the destination type,
+ value must be smaller than the bit size of the destination type,
ty2.
Semantics:
@@ -4017,10 +4283,10 @@ entry:
The 'sext' sign extends value to the type ty2.
Arguments:
-The 'sext' instruction takes a value to cast, which must be of
+
The 'sext' instruction takes a value to cast, which must be of
integer type, and a type to cast it to, which must
also be of integer type. The bit size of the
- value must be smaller than the bit size of the destination type,
+ value must be smaller than the bit size of the destination type,
ty2.
Semantics:
@@ -4058,12 +4324,12 @@ entry:
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
+ ty2. This implies that fptrunc cannot be used to make a
no-op cast.
Semantics:
The 'fptrunc' instruction truncates a value from a larger
- floating point type to a smaller
+ floating point type to a smaller
floating point type. If the value cannot fit
within the destination type, ty2, then the results are
undefined.
@@ -4092,7 +4358,7 @@ entry:
floating point value.
Arguments:
-The 'fpext' instruction takes a
+
The 'fpext' instruction takes a
floating point value to cast, and
a floating point type to cast it to. The source
type must be smaller than the destination type.
@@ -4135,7 +4401,7 @@ entry:
vector integer type with the same number of elements as ty
Semantics:
-The 'fptoui' instruction converts its
+
The 'fptoui' 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.
@@ -4144,7 +4410,7 @@ entry:
%X = fptoui double 123.0 to i32 ; yields i32:123
%Y = fptoui float 1.0E+300 to i1 ; yields undefined:1
- %X = fptoui float 1.04E+17 to i8 ; yields undefined:1
+ %Z = fptoui float 1.04E+17 to i8 ; yields undefined:1
@@ -4161,7 +4427,7 @@ entry:
Overview:
-The 'fptosi' instruction converts
+
The 'fptosi' instruction converts
floating point value to
type ty2.
@@ -4173,7 +4439,7 @@ entry:
vector integer type with the same number of elements as ty
Semantics:
-The 'fptosi' instruction converts its
+
The 'fptosi' 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.
@@ -4182,7 +4448,7 @@ entry:
%X = fptosi double -123.0 to i32 ; yields i32:-123
%Y = fptosi float 1.0E-247 to i1 ; yields undefined:1
- %X = fptosi float 1.04E+17 to i8 ; yields undefined:1
+ %Z = fptosi float 1.04E+17 to i8 ; yields undefined:1
@@ -4326,8 +4592,8 @@ entry:
Example:
%X = inttoptr i32 255 to i32* ; yields zero extension on 64-bit architecture
- %X = inttoptr i32 255 to i32* ; yields no-op on 32-bit architecture
- %Y = inttoptr i64 0 to i32* ; yields truncation on 32-bit architecture
+ %Y = inttoptr i32 255 to i32* ; yields no-op on 32-bit architecture
+ %Z = inttoptr i64 0 to i32* ; yields truncation on 32-bit architecture
@@ -4370,7 +4636,7 @@ entry:
%X = bitcast i8 255 to i8 ; yields i8 :-1
%Y = bitcast i32* %x to sint* ; yields sint*:%x
- %Z = bitcast <2 x int> %V to i64; ; yields i64: %V
+ %Z = bitcast <2 x int> %V to i64; ; yields i64: %V
@@ -4426,15 +4692,15 @@ entry:
Semantics:
The 'icmp' compares op1 and op2 according to the
condition code given as cond. The comparison performed always yields
- either an i1 or vector of i1
+ either an i1 or vector of i1
result, as follows:
- - eq: yields true if the operands are equal,
+
- eq: yields true if the operands are equal,
false otherwise. No sign interpretation is necessary or
performed.
- - ne: yields true if the operands are unequal,
+
- ne: yields true if the operands are unequal,
false otherwise. No sign interpretation is necessary or
performed.
@@ -4503,7 +4769,7 @@ entry:
values based on comparison of its operands.
If the operands are floating point scalars, then the result type is a boolean
-(i1).
+(i1).
If the operands are floating point vectors, then the result type is a vector
of boolean with the same number of elements as the operands being
@@ -4545,48 +4811,48 @@ entry:
The 'fcmp' instruction compares op1 and op2
according to the condition code given as cond. If the operands are
vectors, then the vectors are compared element by element. Each comparison
- performed always yields an i1 result, as
+ performed always yields an i1 result, as
follows:
- false: always yields false, regardless of operands.
- - oeq: yields true if both operands are not a QNAN and
+
- oeq: yields true if both operands are not a QNAN and
op1 is equal to op2.
- ogt: yields true if both operands are not a QNAN and
op1 is greather than op2.
- - oge: yields true if both operands are not a QNAN and
+
- oge: yields true if both operands are not a QNAN and
op1 is greater than or equal to op2.
- - olt: yields true if both operands are not a QNAN and
+
- olt: yields true if both operands are not a QNAN and
op1 is less than op2.
- - ole: yields true if both operands are not a QNAN and
+
- ole: yields true if both operands are not a QNAN and
op1 is less than or equal to op2.
- - one: yields true if both operands are not a QNAN and
+
- one: yields true if both operands are not a QNAN and
op1 is not equal to op2.
- ord: yields true if both operands are not a QNAN.
- - ueq: yields true if either operand is a QNAN or
+
- ueq: yields true if either operand is a QNAN or
op1 is equal to op2.
- - ugt: yields true if either operand is a QNAN or
+
- ugt: yields true if either operand is a QNAN or
op1 is greater than op2.
- - uge: yields true if either operand is a QNAN or
+
- uge: yields true if either operand is a QNAN or
op1 is greater than or equal to op2.
- - ult: yields true if either operand is a QNAN or
+
- ult: yields true if either operand is a QNAN or
op1 is less than op2.
- - ule: yields true if either operand is a QNAN or
+
- ule: yields true if either operand is a QNAN or
op1 is less than or equal to op2.
- - une: yields true if either operand is a QNAN or
+
- une: yields true if either operand is a QNAN or
op1 is not equal to op2.
- uno: yields true if either operand is a QNAN.
@@ -4780,6 +5046,12 @@ Loop: ; Infinite loop that counts from 0 on up...
%ZZ = call zeroext i32 @bar() ; Return value is %zero extended
+llvm treats calls to some functions with names and arguments that match the
+standard C99 library as being the C99 library functions, and may perform
+optimizations or generate code for them under that assumption. This is
+something we'd like to change in the future to provide better support for
+freestanding environments and non-C-based langauges.
+
@@ -4872,7 +5144,7 @@ Loop: ; Infinite loop that counts from 0 on up...
suffix is required. Because the argument's type is matched against the return
type, it does not require its own name suffix.
-To learn how to add an intrinsic function, please see the
+
To learn how to add an intrinsic function, please see the
Extending LLVM Guide.
@@ -6307,11 +6579,11 @@ LLVM.
- ll: All loads before the barrier must complete before any load
after the barrier begins.
- - ls: All loads before the barrier must complete before any
+
- ls: All loads before the barrier must complete before any
store after the barrier begins.
- - ss: All stores before the barrier must complete before any
+
- ss: All stores before the barrier must complete before any
store after the barrier begins.
- - sl: All stores before the barrier must complete before any
+
- sl: All stores before the barrier must complete before any
load after the barrier begins.
@@ -6325,7 +6597,8 @@ LLVM.
Example:
-%ptr = malloc i32
+%mallocP = tail call i8* @malloc(i32 ptrtoint (i32* getelementptr (i32* null, i32 1) to i32))
+%ptr = bitcast i8* %mallocP to i32*
store i32 4, %ptr
%result1 = load i32* %ptr ; yields {i32}:result1 = 4
@@ -6376,7 +6649,8 @@ LLVM.
Examples:
-%ptr = malloc i32
+%mallocP = tail call i8* @malloc(i32 ptrtoint (i32* getelementptr (i32* null, i32 1) to i32))
+%ptr = bitcast i8* %mallocP to i32*
store i32 4, %ptr
%val1 = add i32 4, 4
@@ -6431,7 +6705,8 @@ LLVM.
Examples:
-%ptr = malloc i32
+%mallocP = tail call i8* @malloc(i32 ptrtoint (i32* getelementptr (i32* null, i32 1) to i32))
+%ptr = bitcast i8* %mallocP to i32*
store i32 4, %ptr
%val1 = add i32 4, 4
@@ -6486,8 +6761,9 @@ LLVM.
Examples:
-%ptr = malloc i32
- store i32 4, %ptr
+%mallocP = tail call i8* @malloc(i32 ptrtoint (i32* getelementptr (i32* null, i32 1) to i32))
+%ptr = bitcast i8* %mallocP to i32*
+ store i32 4, %ptr
%result1 = call i32 @llvm.atomic.load.add.i32.p0i32( i32* %ptr, i32 4 )
; yields {i32}:result1 = 4
%result2 = call i32 @llvm.atomic.load.add.i32.p0i32( i32* %ptr, i32 2 )
@@ -6520,7 +6796,7 @@ LLVM.
Overview:
-This intrinsic subtracts delta to the value stored in memory at
+
This intrinsic subtracts delta to the value stored in memory at
ptr. It yields the original value at ptr.
Arguments:
@@ -6537,8 +6813,9 @@ LLVM.
Examples:
-%ptr = malloc i32
- store i32 8, %ptr
+%mallocP = tail call i8* @malloc(i32 ptrtoint (i32* getelementptr (i32* null, i32 1) to i32))
+%ptr = bitcast i8* %mallocP to i32*
+ store i32 8, %ptr
%result1 = call i32 @llvm.atomic.load.sub.i32.p0i32( i32* %ptr, i32 4 )
; yields {i32}:result1 = 8
%result2 = call i32 @llvm.atomic.load.sub.i32.p0i32( i32* %ptr, i32 2 )
@@ -6614,8 +6891,9 @@ LLVM.
Examples:
-%ptr = malloc i32
- store i32 0x0F0F, %ptr
+%mallocP = tail call i8* @malloc(i32 ptrtoint (i32* getelementptr (i32* null, i32 1) to i32))
+%ptr = bitcast i8* %mallocP to i32*
+ store i32 0x0F0F, %ptr
%result0 = call i32 @llvm.atomic.load.nand.i32.p0i32( i32* %ptr, i32 0xFF )
; yields {i32}:result0 = 0x0F0F
%result1 = call i32 @llvm.atomic.load.and.i32.p0i32( i32* %ptr, i32 0xFF )
@@ -6674,7 +6952,7 @@ LLVM.
Overview:
-These intrinsics takes the signed or unsigned minimum or maximum of
+
These intrinsics takes the signed or unsigned minimum or maximum of
delta and the value stored in memory at ptr. It yields the
original value at ptr.
@@ -6692,8 +6970,9 @@ LLVM.
Examples:
-%ptr = malloc i32
- store i32 7, %ptr
+%mallocP = tail call i8* @malloc(i32 ptrtoint (i32* getelementptr (i32* null, i32 1) to i32))
+%ptr = bitcast i8* %mallocP to i32*
+ store i32 7, %ptr
%result0 = call i32 @llvm.atomic.load.min.i32.p0i32( i32* %ptr, i32 -2 )
; yields {i32}:result0 = 7
%result1 = call i32 @llvm.atomic.load.max.i32.p0i32( i32* %ptr, i32 8 )
@@ -6707,6 +6986,133 @@ LLVM.
+
+
+
+
+
+
+
This class of intrinsics exists to information about the lifetime of memory
+ objects and ranges where variables are immutable.
+
+
+
+
Syntax:
+
+ declare void @llvm.lifetime.start(i64 <size>, i8* nocapture <ptr>)
+
+
+
Overview:
+
The 'llvm.lifetime.start' intrinsic specifies the start of a memory
+ object's lifetime.
+
+
Arguments:
+
The first argument is a constant integer representing the size of the
+ object, or -1 if it is variable sized. The second argument is a pointer to
+ the object.
+
+
Semantics:
+
This intrinsic indicates that before this point in the code, the value of the
+ memory pointed to by ptr is dead. This means that it is known to
+ never be used and has an undefined value. A load from the pointer that
+ precedes this intrinsic can be replaced with
+ 'undef'.
+
+
+
+
Syntax:
+
+ declare void @llvm.lifetime.end(i64 <size>, i8* nocapture <ptr>)
+
+
+
Overview:
+
The 'llvm.lifetime.end' intrinsic specifies the end of a memory
+ object's lifetime.
+
+
Arguments:
+
The first argument is a constant integer representing the size of the
+ object, or -1 if it is variable sized. The second argument is a pointer to
+ the object.
+
+
Semantics:
+
This intrinsic indicates that after this point in the code, the value of the
+ memory pointed to by ptr is dead. This means that it is known to
+ never be used and has an undefined value. Any stores into the memory object
+ following this intrinsic may be removed as dead.
+
+
+
+
Syntax:
+
+ declare {}* @llvm.invariant.start(i64 <size>, i8* nocapture <ptr>) readonly
+
+
+
Overview:
+
The 'llvm.invariant.start' intrinsic specifies that the contents of
+ a memory object will not change.
+
+
Arguments:
+
The first argument is a constant integer representing the size of the
+ object, or -1 if it is variable sized. The second argument is a pointer to
+ the object.
+
+
Semantics:
+
This intrinsic indicates that until an llvm.invariant.end that uses
+ the return value, the referenced memory location is constant and
+ unchanging.
+
+
+
+
Syntax:
+
+ declare void @llvm.invariant.end({}* <start>, i64 <size>, i8* nocapture <ptr>)
+
+
+
Overview:
+
The 'llvm.invariant.end' intrinsic specifies that the contents of
+ a memory object are mutable.
+
+
Arguments:
+
The first argument is the matching llvm.invariant.start intrinsic.
+ The second argument is a constant integer representing the size of the
+ object, or -1 if it is variable sized and the third argument is a pointer
+ to the object.
+
+
Semantics:
+
This intrinsic indicates that the memory is mutable again.
+
+
+
+
Syntax:
+
+ declare i32 @llvm.objectsize.i32( i8* <ptr>, i32 <type> )
+ declare i64 @llvm.objectsize.i64( i8* <ptr>, i32 <type> )
+
+
+
Overview:
+
The llvm.objectsize intrinsic is designed to provide information
+ to the optimizers to either discover at compile time either a) when an
+ operation like memcpy will either overflow a buffer that corresponds to
+ an object, or b) to determine that a runtime check for overflow isn't
+ necessary. An object in this context means an allocation of a
+ specific type.
+
+
Arguments:
+
The llvm.objectsize intrinsic takes two arguments. The first
+ argument is a pointer to the object ptr. The second argument
+ is an integer type which ranges from 0 to 3. The first bit in
+ the type corresponds to a return value based on whole objects,
+ and the second bit whether or not we return the maximum or minimum
+ remaining bytes computed.
+
+
+ | 00 |
+ whole object, maximum number of bytes |
+
+
+ | 01 |
+ partial object, maximum number of bytes |
+
+
+ | 10 |
+ whole object, minimum number of bytes |
+
+
+ | 11 |
+ partial object, minimum number of bytes |
+
+
+
+
Semantics:
+
The llvm.objectsize intrinsic is lowered to either a constant
+ representing the size of the object concerned or i32/i64 -1 or 0
+ (depending on the type argument if the size cannot be determined
+ at compile time.
+
+