+
Overview:
An "up reference" allows you to refer to a lexically enclosing type without
@@ -2002,21 +2071,23 @@ Classifications
+
+
-
+
LLVM has several different basic types of constants. This section describes
them all and their syntax.
-
-
-
+
-
+
- Boolean constants
@@ -2065,15 +2136,16 @@ Classifications
they match the long double format on your target. All hexadecimal formats
are big-endian (sign bit at the left).
+
There are no constants of type x86mmx.
-
+
-
+
Complex constants are a (potentially recursive) combination of simple
constants and smaller complex constants.
@@ -2088,14 +2160,6 @@ Classifications
the number and types of elements must match those specified by the
type.
-
Union constants
-
Union constants are represented with notation similar to a structure with
- a single element - that is, a single typed element surrounded
- by braces ({})). For example: "{ i32 4 }". The
- union type can be initialized with a single-element
- struct as long as the type of the struct element matches the type of
- one of the union members.
-
Array constants
Array constants are represented with notation similar to array type
definitions (a comma separated list of elements, surrounded by square
@@ -2131,11 +2195,11 @@ Classifications
-
+
have
pointer type. For example, the following is a
legal LLVM file:
-
-
+
@X = global i32 17
@Y = global i32 42
@Z = global [2 x i32*] [ i32* @X, i32* @Y ]
-
-
+
+
+
The string 'undef' can be used anywhere a constant is expected, and
indicates that the user of the value may receive an unspecified bit-pattern.
- Undefined values may be of any type (other than label or void) and be used
- anywhere a constant is permitted.
+ Undefined values may be of any type (other than '
label'
+ or '
void') and be used anywhere a constant is permitted.
Undefined values are useful because they indicate to the compiler that the
program is well defined no matter what value is used. This gives the
@@ -2169,8 +2234,7 @@ Classifications
surprising) transformations that are valid (in pseudo IR):
-
-
+
%A = add %X, undef
%B = sub %X, undef
%C = xor %X, undef
@@ -2179,13 +2243,11 @@ Safe:
%B = undef
%C = undef
-
This is safe because all of the output bits are affected by the undef bits.
-Any output bit can have a zero or one depending on the input bits.
+ Any output bit can have a zero or one depending on the input bits.
-
-
+
%A = or %X, undef
%B = and %X, undef
Safe:
@@ -2195,19 +2257,18 @@ Unsafe:
%A = undef
%B = undef
-
These logical operations have bits that are not always affected by the input.
-For example, if "%X" has a zero bit, then the output of the 'and' operation will
-always be a zero, no matter what the corresponding bit from the undef is. As
-such, it is unsafe to optimize or assume that the result of the and is undef.
-However, it is safe to assume that all bits of the undef could be 0, and
-optimize the and to 0. Likewise, it is safe to assume that all the bits of
-the undef operand to the or could be set, allowing the or to be folded to
--1.
-
-
-
+ For example, if %X has a zero bit, then the output of the
+ 'and' operation will always be a zero for that bit, no matter what
+ the corresponding bit from the 'undef' is. As such, it is unsafe to
+ optimize or assume that the result of the 'and' is 'undef'.
+ However, it is safe to assume that all bits of the 'undef' could be
+ 0, and optimize the 'and' to 0. Likewise, it is safe to assume that
+ all the bits of the 'undef' operand to the 'or' could be
+ set, allowing the 'or' to be folded to -1.
+
+
%A = select undef, %X, %Y
%B = select undef, 42, %Y
%C = select %X, %Y, undef
@@ -2220,18 +2281,17 @@ Unsafe:
%B = undef
%C = undef
-
-
This set of examples show that undefined select (and conditional branch)
-conditions can go "either way" but they have to come from one of the two
-operands. In the %A example, if %X and %Y were both known to have a clear low
-bit, then %A would have to have a cleared low bit. However, in the %C example,
-the optimizer is allowed to assume that the undef operand could be the same as
-%Y, allowing the whole select to be eliminated.
+
This set of examples shows that undefined 'select' (and conditional
+ branch) conditions can go either way, but they have to come from one
+ of the two operands. In the %A example, if %X and
+ %Y were both known to have a clear low bit, then %A would
+ have to have a cleared low bit. However, in the %C example, the
+ optimizer is allowed to assume that the 'undef' operand could be the
+ same as %Y, allowing the whole 'select' to be
+ eliminated.
-
-
-
+
%A = xor undef, undef
%B = undef
@@ -2249,92 +2309,190 @@ Safe:
%E = undef
%F = undef
-
-
This example points out that two undef operands are not necessarily the same.
-This can be surprising to people (and also matches C semantics) where they
-assume that "X^X" is always zero, even if X is undef. This isn't true for a
-number of reasons, but the short answer is that an undef "variable" can
-arbitrarily change its value over its "live range". This is true because the
-"variable" doesn't actually have a live range. Instead, the value is
-logically read from arbitrary registers that happen to be around when needed,
-so the value is not necessarily consistent over time. In fact, %A and %C need
-to have the same semantics or the core LLVM "replace all uses with" concept
-would not hold.
+
This example points out that two 'undef' operands are not
+ necessarily the same. This can be surprising to people (and also matches C
+ semantics) where they assume that "X^X" is always zero, even
+ if X is undefined. This isn't true for a number of reasons, but the
+ short answer is that an 'undef' "variable" can arbitrarily change
+ its value over its "live range". This is true because the variable doesn't
+ actually have a live range. Instead, the value is logically read
+ from arbitrary registers that happen to be around when needed, so the value
+ is not necessarily consistent over time. In fact, %A and %C
+ need to have the same semantics or the core LLVM "replace all uses with"
+ concept would not hold.
-
-
+
%A = fdiv undef, %X
%B = fdiv %X, undef
Safe:
%A = undef
b: unreachable
-
These examples show the crucial difference between an undefined
-value and undefined behavior. An undefined value (like undef) is
-allowed to have an arbitrary bit-pattern. This means that the %A operation
-can be constant folded to undef because the undef could be an SNaN, and fdiv is
-not (currently) defined on SNaN's. However, in the second example, we can make
-a more aggressive assumption: because the undef is allowed to be an arbitrary
-value, we are allowed to assume that it could be zero. Since a divide by zero
-has undefined behavior, we are allowed to assume that the operation
-does not execute at all. This allows us to delete the divide and all code after
-it: since the undefined operation "can't happen", the optimizer can assume that
-it occurs in dead code.
-
-
-
-
+ value and undefined behavior. An undefined value (like
+ 'undef') is allowed to have an arbitrary bit-pattern. This means that
+ the %A operation can be constant folded to 'undef', because
+ the 'undef' could be an SNaN, and fdiv is not (currently)
+ defined on SNaN's. However, in the second example, we can make a more
+ aggressive assumption: because the undef is allowed to be an
+ arbitrary value, we are allowed to assume that it could be zero. Since a
+ divide by zero has undefined behavior, we are allowed to assume that
+ the operation does not execute at all. This allows us to delete the divide and
+ all code after it. Because the undefined operation "can't happen", the
+ optimizer can assume that it occurs in dead code.
+
+
a: store undef -> %X
b: store %X -> undef
Safe:
a: <deleted>
b: unreachable
-
-
These examples reiterate the fdiv example: a store "of" an undefined value
-can be assumed to not have any effect: we can assume that the value is
-overwritten with bits that happen to match what was already there. However, a
-store "to" an undefined location could clobber arbitrary memory, therefore, it
-has undefined behavior.
+
These examples reiterate the fdiv example: a store of an
+ undefined value can be assumed to not have any effect; we can assume that the
+ value is overwritten with bits that happen to match what was already there.
+ However, a store to an undefined location could clobber arbitrary
+ memory, therefore, it has undefined behavior.
-
+
-
Trap values are similar to undef values, however
+
+
+
Trap values are similar to undef values, however
instead of representing an unspecified bit pattern, they represent the
fact that an instruction or constant expression which cannot evoke side
effects has nevertheless detected a condition which results in undefined
- behavior.
+ behavior.
+
+
There is currently no way of representing a trap value in the IR; they
+ only exist when produced by operations such as
+ add with the nsw flag.
-
Any non-void instruction or constant expression other than non-intrinsic
- calls or invokes with a trap operand has trap as its result value.
- Any instruction with a trap operand which may have side effects emits
- those side effects as if it had an undef operand instead.
+
Trap value behavior is defined in terms of value dependence:
-
For example, an and of a trap value with
- zero still has a trap value result. Using that value as an index in a
- getelementptr yields a trap
- result. Using that result as the address of a
- store produces undefined behavior.
+
+- Values other than phi nodes depend on
+ their operands.
+
+- Phi nodes depend on the operand corresponding
+ to their dynamic predecessor basic block.
+
+- Function arguments depend on the corresponding actual argument values in
+ the dynamic callers of their functions.
+
+- Call instructions depend on the
+ ret instructions that dynamically transfer
+ control back to them.
+
+- Invoke instructions depend on the
+ ret, unwind,
+ or exception-throwing call instructions that dynamically transfer control
+ back to them.
+
+- Non-volatile loads and stores depend on the most recent stores to all of the
+ referenced memory addresses, following the order in the IR
+ (including loads and stores implied by intrinsics such as
+ @llvm.memcpy.)
+
+
+
+
+
+- An instruction with externally visible side effects depends on the most
+ recent preceding instruction with externally visible side effects, following
+ the order in the IR. (This includes
+ volatile operations.)
+
+- An instruction control-depends on a
+ terminator instruction
+ if the terminator instruction has multiple successors and the instruction
+ is always executed when control transfers to one of the successors, and
+ may not be executed when control is transferred to another.
+
+- Additionally, an instruction also control-depends on a terminator
+ instruction if the set of instructions it otherwise depends on would be
+ different if the terminator had transferred control to a different
+ successor.
+
+- Dependence is transitive.
+
+
+
+
Whenever a trap value is generated, all values which depend on it evaluate
+ to trap. If they have side effects, the evoke their side effects as if each
+ operand with a trap value were undef. If they have externally-visible side
+ effects, the behavior is undefined.
+
+
Here are some examples:
+
+
+entry:
+ %trap = sub nuw i32 0, 1 ; Results in a trap value.
+ %still_trap = and i32 %trap, 0 ; Whereas (and i32 undef, 0) would return 0.
+ %trap_yet_again = getelementptr i32* @h, i32 %still_trap
+ store i32 0, i32* %trap_yet_again ; undefined behavior
-There is currently no way of representing a trap constant in the IR; they
- only exist when produced by certain instructions, such as an
- add with the nsw flag
- set, when overflow occurs.
+ store i32 %trap, i32* @g ; Trap value conceptually stored to memory.
+ %trap2 = load i32* @g ; Returns a trap value, not just undef.
+
+ volatile store i32 %trap, i32* @g ; External observation; undefined behavior.
+
+ %narrowaddr = bitcast i32* @g to i16*
+ %wideaddr = bitcast i32* @g to i64*
+ %trap3 = load i16* %narrowaddr ; Returns a trap value.
+ %trap4 = load i64* %wideaddr ; Returns a trap value.
+
+ %cmp = icmp slt i32 %trap, 0 ; Returns a trap value.
+ br i1 %cmp, label %true, label %end ; Branch to either destination.
+
+true:
+ volatile store i32 0, i32* @g ; This is control-dependent on %cmp, so
+ ; it has undefined behavior.
+ br label %end
+
+end:
+ %p = phi i32 [ 0, %entry ], [ 1, %true ]
+ ; Both edges into this PHI are
+ ; control-dependent on %cmp, so this
+ ; always results in a trap value.
+
+ volatile store i32 0, i32* @g ; This would depend on the store in %true
+ ; if %cmp is true, or the store in %entry
+ ; otherwise, so this is undefined behavior.
+
+ br i1 %cmp, label %second_true, label %second_end
+ ; The same branch again, but this time the
+ ; true block doesn't have side effects.
+
+second_true:
+ ; No side effects!
+ ret void
+
+second_end:
+ volatile store i32 0, i32* @g ; This time, the instruction always depends
+ ; on the store in %end. Also, it is
+ ; control-equivalent to %end, so this is
+ ; well-defined (again, ignoring earlier
+ ; undefined behavior in this example).
+
-
-
+
+
+
blockaddress(@function, %block)
@@ -2343,133 +2501,143 @@ has undefined behavior.
the address of the entry block is illegal.
This value only has defined behavior when used as an operand to the
- 'indirectbr' instruction or for comparisons
- against null. Pointer equality tests between labels addresses is undefined
- behavior - though, again, comparison against null is ok, and no label is
- equal to the null pointer. This may also be passed around as an opaque
- pointer sized value as long as the bits are not inspected. This allows
- ptrtoint and arithmetic to be performed on these values so long as
- the original value is reconstituted before the indirectbr.
+ '
indirectbr' instruction, or for
+ comparisons against null. Pointer equality tests between labels addresses
+ results in undefined behavior — though, again, comparison against null
+ is ok, and no label is equal to the null pointer. This may be passed around
+ as an opaque pointer sized value as long as the bits are not inspected. This
+ allows
ptrtoint and arithmetic to be performed on these values so
+ long as the original value is reconstituted before the
indirectbr
+ instruction.
-
Finally, some targets may provide defined semantics when
- using the value as the operand to an inline assembly, but that is target
- specific.
-
+
Finally, some targets may provide defined semantics when using the value as
+ the operand to an inline assembly, but that is target specific.
-
+
-
+
Constant expressions are used to allow expressions involving other constants
to be used as constants. Constant expressions may be of
any first class type and may involve any LLVM
operation that does not have side effects (e.g. load and call are not
- supported). The following is the syntax for constant expressions:
+ supported). The following is the syntax for constant expressions:
- - trunc ( CST to TYPE )
+ - trunc (CST to TYPE)
- Truncate a constant to another type. The bit size of CST must be larger
than the bit size of TYPE. Both types must be integers.
- - zext ( CST to TYPE )
+ - zext (CST to TYPE)
- Zero extend a constant to another type. The bit size of CST must be
- smaller or equal to the bit size of TYPE. Both types must be
- integers.
+ smaller than the bit size of TYPE. Both types must be integers.
- - sext ( CST to TYPE )
+ - sext (CST to TYPE)
- Sign extend a constant to another type. The bit size of CST must be
- smaller or equal to the bit size of TYPE. Both types must be
- integers.
+ smaller than the bit size of TYPE. Both types must be integers.
- - fptrunc ( CST to TYPE )
+ - fptrunc (CST to TYPE)
- Truncate a floating point constant to another floating point type. The
size of CST must be larger than the size of TYPE. Both types must be
floating point.
- - fpext ( CST to TYPE )
+ - fpext (CST to TYPE)
- Floating point extend a constant to another type. The size of CST must be
smaller or equal to the size of TYPE. Both types must be floating
point.
- - fptoui ( CST to TYPE )
+ - fptoui (CST to TYPE)
- Convert a floating point constant to the corresponding unsigned integer
constant. TYPE must be a scalar or vector integer type. CST must be of
scalar or vector floating point type. Both CST and TYPE must be scalars,
or vectors of the same number of elements. If the value won't fit in the
integer type, the results are undefined.
- - fptosi ( CST to TYPE )
+ - fptosi (CST to TYPE)
- Convert a floating point constant to the corresponding signed integer
constant. TYPE must be a scalar or vector integer type. CST must be of
scalar or vector floating point type. Both CST and TYPE must be scalars,
or vectors of the same number of elements. If the value won't fit in the
integer type, the results are undefined.
- - uitofp ( CST to TYPE )
+ - uitofp (CST to TYPE)
- Convert an unsigned integer constant to the corresponding floating point
constant. TYPE must be a scalar or vector floating point type. CST must be
of scalar or vector integer type. Both CST and TYPE must be scalars, or
vectors of the same number of elements. If the value won't fit in the
floating point type, the results are undefined.
- - sitofp ( CST to TYPE )
+ - sitofp (CST to TYPE)
- Convert a signed integer constant to the corresponding floating point
constant. TYPE must be a scalar or vector floating point type. CST must be
of scalar or vector integer type. Both CST and TYPE must be scalars, or
vectors of the same number of elements. If the value won't fit in the
floating point type, the results are undefined.
- - ptrtoint ( CST to TYPE )
+ - ptrtoint (CST to TYPE)
- Convert a pointer typed constant to the corresponding integer constant
TYPE must be an integer type. CST must be of pointer
type. The CST value is zero extended, truncated, or unchanged to
make it fit in TYPE.
- - inttoptr ( CST to TYPE )
+ - inttoptr (CST to TYPE)
- Convert a integer constant to a pointer constant. TYPE must be a pointer
type. CST must be of integer type. The CST value is zero extended,
truncated, or unchanged to make it fit in a pointer size. This one is
really dangerous!
- - bitcast ( CST to TYPE )
+ - bitcast (CST to TYPE)
- Convert a constant, CST, to another TYPE. The constraints of the operands
are the same as those for the bitcast
instruction.
- - getelementptr ( CSTPTR, IDX0, IDX1, ... )
- - getelementptr inbounds ( CSTPTR, IDX0, IDX1, ... )
+ - getelementptr (CSTPTR, IDX0, IDX1, ...)
+ - getelementptr inbounds (CSTPTR, IDX0, IDX1, ...)
- Perform the getelementptr operation on
constants. As with the getelementptr
instruction, the index list may have zero or more indexes, which are
required to make sense for the type of "CSTPTR".
- - select ( COND, VAL1, VAL2 )
+ - select (COND, VAL1, VAL2)
- Perform the select operation on constants.
- - icmp COND ( VAL1, VAL2 )
+ - icmp COND (VAL1, VAL2)
- Performs the icmp operation on constants.
- - fcmp COND ( VAL1, VAL2 )
+ - fcmp COND (VAL1, VAL2)
- Performs the fcmp operation on constants.
- - extractelement ( VAL, IDX )
+ - extractelement (VAL, IDX)
- Perform the extractelement operation on
constants.
- - insertelement ( VAL, ELT, IDX )
+ - insertelement (VAL, ELT, IDX)
- Perform the insertelement operation on
constants.
- - shufflevector ( VEC1, VEC2, IDXMASK )
+ - shufflevector (VEC1, VEC2, IDXMASK)
- Perform the shufflevector operation on
constants.
- - OPCODE ( LHS, RHS )
+ - extractvalue (VAL, IDX0, IDX1, ...)
+ - Perform the extractvalue operation on
+ constants. The index list is interpreted in a similar manner as indices in
+ a 'getelementptr' operation. At least one
+ index value must be specified.
+
+ - insertvalue (VAL, ELT, IDX0, IDX1, ...)
+ - Perform the insertvalue operation on
+ constants. The index list is interpreted in a similar manner as indices in
+ a 'getelementptr' operation. At least one
+ index value must be specified.
+
+ - OPCODE (LHS, RHS)
- Perform the specified operation of the LHS and RHS constants. OPCODE may
be any of the binary
or bitwise binary operations. The constraints
@@ -2479,16 +2647,18 @@ has undefined behavior.
+
+
-
+
-
+
-
+
-
+
LLVM supports inline assembler expressions (as opposed
to Module-Level Inline Assembly) through the use of
@@ -2499,31 +2669,25 @@ has undefined behavior.
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,
@@ -2532,11 +2696,9 @@ call void asm sideeffect "eieio", ""()
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.
@@ -2545,40 +2707,40 @@ call void asm alignstack "eieio", ""()
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.
-
-
+
-
+
The call instructions that wrap inline asm nodes may have a "!srcloc" MDNode
- attached to it that contains a constant integer. If present, the code
- generator will use the integer as the location cookie value when report
+ attached to it that contains a list of constant integers. If present, the
+ code generator will use the integer as the location cookie value when report
errors through the LLVMContext error reporting mechanisms. This allows a
- front-end to corrolate backend errors that occur with inline asm back to the
+ front-end to correlate backend errors that occur with inline asm back to the
source code that produced it. For example:
-
-
+
call void asm sideeffect "something bad", ""(), !srcloc !42
...
!42 = !{ i32 1234567 }
-
It is up to the front-end to make sense of the magic numbers it places in the
- IR.
+ IR. If the MDNode contains multiple constants, the code generator will use
+ the one that corresponds to the line of the asm that the error occurs on.
-
-
-
+
+
+
+
LLVM IR allows metadata to be attached to instructions in the program that
can convey extra information about the code to the optimizers and code
@@ -2601,31 +2763,33 @@ call void asm sideeffect "something bad", ""(), !srcloc !42
example: "!foo = metadata !{!4, !3}".
Metadata can be used as function arguments. Here llvm.dbg.value
- function is using two metadata arguments.
+ function is using two metadata arguments.
-
-
- call void @llvm.dbg.value(metadata !24, i64 0, metadata !25)
-
-
+
+
+call void @llvm.dbg.value(metadata !24, i64 0, metadata !25)
+
+
Metadata can be attached with an instruction. Here metadata !21 is
- attached with add instruction using !dbg identifier.
+ attached with add instruction using !dbg identifier.
-
-
- %indvar.next = add i64 %indvar, 1, !dbg !21
-
-
+
+
+%indvar.next = add i64 %indvar, 1, !dbg !21
+
+
+
+
-
+
-
+
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
@@ -2633,11 +2797,11 @@ 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
@@ -2668,11 +2832,13 @@ object file to prevent the assembler and linker from molesting the symbol.
-
+
-
+
The @llvm.compiler.used directive is the same as the
@llvm.used directive, except that it only prevents the compiler from
@@ -2686,33 +2852,43 @@ should not be exposed to source languages.
-
-
-
+
-
TODO: Describe this.
+
+
+%0 = type { i32, void ()* }
+@llvm.global_ctors = appending global [1 x %0] [%0 { i32 65535, void ()* @ctor }]
+
+
The @llvm.global_ctors array contains a list of constructor functions and associated priorities. The functions referenced by this array will be called in ascending order of priority (i.e. lowest first) when the module is loaded. The order of functions with the same priority is not defined.
+
-
+
-
+
+
+%0 = type { i32, void ()* }
+@llvm.global_dtors = appending global [1 x %0] [%0 { i32 65535, void ()* @dtor }]
+
-
TODO: Describe this.
+
The @llvm.global_dtors array contains a list of destructor functions and associated priorities. The functions referenced by this array will be called in descending order of priority (i.e. highest first) when the module is loaded. The order of functions with the same priority is not defined.
+
+
-
+
-
+
-
-
+
-
+
As mentioned previously, every basic block
in a program ends with a "Terminator" instruction, which indicates which
@@ -2745,13 +2920,12 @@ Instructions
'
unwind' instruction, and the
'
unreachable' instruction.
-
-
-
+
-
+
Syntax:
@@ -2797,9 +2971,11 @@ Instruction
-
+
-
+
Syntax:
@@ -2838,11 +3014,11 @@ IfUnequal:
-
+
-
+
Syntax:
@@ -2893,11 +3069,11 @@ IfUnequal:
-
+
-
+
Syntax:
@@ -2941,11 +3117,11 @@ IfUnequal:
-
+
-
+
Syntax:
@@ -3031,10 +3207,11 @@ that the invoke/unwind semantics are likely to change in future versions.
-
+
-
+
Syntax:
@@ -3062,10 +3239,11 @@ that the invoke/unwind semantics are likely to change in future versions.
-
+
-
+
Syntax:
@@ -3083,10 +3261,14 @@ Instruction
+
+
-
+
-
+
Binary operators are used to do most of the computation in a program. They
require two operands of the same type, execute an operation on them, and
@@ -3094,16 +3276,14 @@ Instruction
the case with the
vector data type. The result value
has the same type as its operands.
-
There are several different binary operators:
-
-
+
There are several different binary operators:
-
+
-
+
Syntax:
@@ -3144,11 +3324,11 @@ Instruction
-
+
-
+
Syntax:
@@ -3174,11 +3354,11 @@ Instruction
-
+
-
+
Syntax:
@@ -3226,11 +3406,11 @@ Instruction
-
+
-
+
Syntax:
@@ -3262,11 +3442,11 @@ Instruction
-
+
-
+
Syntax:
@@ -3312,11 +3492,11 @@ Instruction
-
+
-
+
Syntax:
@@ -3342,14 +3522,16 @@ Instruction
-
+
-
+
Syntax:
- <result> = udiv <ty> <op1>, <op2> ; yields {ty}:result
+ <result> = udiv <ty> <op1>, <op2> ; yields {ty}:result
+ <result> = udiv exact <ty> <op1>, <op2> ; yields {ty}:result
Overview:
@@ -3368,6 +3550,11 @@ Instruction
Division by zero leads to undefined behavior.
+
If the exact keyword is present, the result value of the
+ udiv is a trap value if %op1 is not a
+ multiple of %op2 (as such, "((a udiv exact b) mul b) == a").
+
+
Example:
<result> = udiv i32 4, %var ; yields {i32}:result = 4 / %var
@@ -3376,10 +3563,11 @@ Instruction
-
+
-
+
Syntax:
@@ -3407,8 +3595,8 @@ Instruction
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.
+
sdiv is a
trap value if the result would
+ be rounded.
Example:
@@ -3418,10 +3606,11 @@ Instruction
-
+
-
+
Syntax:
@@ -3447,10 +3636,11 @@ Instruction
-
+
-
+
Syntax:
@@ -3484,11 +3674,11 @@ Instruction
-
+
-
+
Syntax:
@@ -3508,9 +3698,10 @@ Instruction
Semantics:
This instruction returns the remainder of a division (where the result
- has the same sign as the dividend, op1), not the modulo
- operator (where the result has the same sign as the divisor, op2) of
- a value. For more information about the difference,
+ is either zero or has the same sign as the dividend, op1), not the
+ modulo operator (where the result is either zero or has the same sign
+ as the divisor, op2) of a value.
+ For more information about the difference,
see The
Math Forum. For a table of how this is implemented in various languages,
please see
@@ -3534,10 +3725,11 @@ Instruction
-
+
-
+
Syntax:
@@ -3564,11 +3756,14 @@ Instruction
+
+
-
+
-
+
Bitwise binary operators are used to do various forms of bit-twiddling in a
program. They are generally very efficient instructions and can commonly be
@@ -3576,17 +3771,19 @@ Operations
same type, execute an operation on them, and produce a single value. The
resulting value is the same type as its operands.
-
-
-
+
-
+
Syntax:
- <result> = shl <ty> <op1>, <op2> ; yields {ty}:result
+ <result> = shl <ty> <op1>, <op2> ; yields {ty}:result
+ <result> = shl nuw <ty> <op1>, <op2> ; yields {ty}:result
+ <result> = shl nsw <ty> <op1>, <op2> ; yields {ty}:result
+ <result> = shl nuw nsw <ty> <op1>, <op2> ; yields {ty}:result
Overview:
@@ -3606,6 +3803,14 @@ Instruction
vectors, each vector element of
op1 is shifted by the corresponding
shift amount in
op2.
+
If the nuw keyword is present, then the shift produces a
+ trap value if it shifts out any non-zero bits. If
+ the nsw keyword is present, then the shift produces a
+ trap value if it shifts out any bits that disagree
+ with the resultant sign bit. As such, NUW/NSW have the same semantics as
+ they would if the shift were expressed as a mul instruction with the same
+ nsw/nuw bits in (mul %op1, (shl 1, %op2)).
+
Example:
<result> = shl i32 4, %var ; yields {i32}: 4 << %var
@@ -3618,14 +3823,16 @@ Instruction
-
+
-
+
Syntax:
- <result> = lshr <ty> <op1>, <op2> ; yields {ty}:result
+ <result> = lshr <ty> <op1>, <op2> ; yields {ty}:result
+ <result> = lshr exact <ty> <op1>, <op2> ; yields {ty}:result
Overview:
@@ -3645,6 +3852,11 @@ Instruction
vectors, each vector element of
op1 is shifted by the corresponding
shift amount in
op2.
+
If the exact keyword is present, the result value of the
+ lshr is a trap value if any of the bits
+ shifted out are non-zero.
+
+
Example:
<result> = lshr i32 4, 1 ; yields {i32}:result = 2
@@ -3658,13 +3870,16 @@ Instruction
-
-
+
+
+
Syntax:
- <result> = ashr <ty> <op1>, <op2> ; yields {ty}:result
+ <result> = ashr <ty> <op1>, <op2> ; yields {ty}:result
+ <result> = ashr exact <ty> <op1>, <op2> ; yields {ty}:result
Overview:
@@ -3685,6 +3900,10 @@ Instruction
the arguments are vectors, each vector element of
op1 is shifted by
the corresponding shift amount in
op2.
+
If the exact keyword is present, the result value of the
+ ashr is a trap value if any of the bits
+ shifted out are non-zero.
+
Example:
<result> = ashr i32 4, 1 ; yields {i32}:result = 2
@@ -3698,10 +3917,11 @@ Instruction
-
+
-
+
Syntax:
@@ -3758,9 +3978,11 @@ Instruction
-
+
-
+
Syntax:
@@ -3819,10 +4041,11 @@ Instruction
-
+
-
+
Syntax:
@@ -3882,12 +4105,14 @@ Instruction
+
+
-
+
-
+
LLVM supports several instructions to represent vector operations in a
target-independent manner. These instructions cover the element-access and
@@ -3896,14 +4121,12 @@ Instruction
will want to use target-specific intrinsics to take full advantage of a
specific target.
-
-
-
+
-
+
Syntax:
@@ -3935,11 +4158,11 @@ Instruction
-
+
-
+
Syntax:
@@ -3971,11 +4194,11 @@ Instruction
-
+
-
+
Syntax:
@@ -4018,24 +4241,24 @@ Instruction
+
+
-
+
-
+
LLVM supports several instructions for working with
aggregate values.
-
-
-
+
-
+
Syntax:
@@ -4048,10 +4271,18 @@ Instruction
Arguments:
The first operand of an 'extractvalue' instruction is a value
- of struct, union or
+ 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.
+
The major differences to getelementptr indexing are:
+
+ - Since the value being indexed is not a pointer, the first index is
+ omitted and assumed to be zero.
+ - At least one index must be specified.
+ - Not only struct indices but also array indices must be in
+ bounds.
+
Semantics:
The result is the value at the position in the aggregate specified by the
@@ -4065,15 +4296,15 @@ Instruction
-
+
-
+
Syntax:
- <result> = insertvalue <aggregate type> <val>, <ty> <elt>, <idx> ; yields <aggregate type>
+ <result> = insertvalue <aggregate type> <val>, <ty> <elt>, <idx>{, }* ; yields <aggregate type>
Overview:
@@ -4082,11 +4313,11 @@ Instruction
Arguments:
The first operand of an 'insertvalue' instruction is a value
- of struct, union or
+ 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
+ 'extractvalue' instruction. The
value to insert must have the same type as the value identified by the
indices.
@@ -4097,37 +4328,37 @@ Instruction
Example:
- %agg1 = insertvalue {i32, float} undef, i32 1, 0 ; yields {i32 1, float undef}
- %agg2 = insertvalue {i32, float} %agg1, float %val, 1 ; yields {i32 1, float %val}
+ %agg1 = insertvalue {i32, float} undef, i32 1, 0 ; yields {i32 1, float undef}
+ %agg2 = insertvalue {i32, float} %agg1, float %val, 1 ; yields {i32 1, float %val}
+ %agg3 = insertvalue {i32, {float}} %agg1, float %val, 1, 0 ; yields {i32 1, float %val}
+
-
+
-
+
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, and allocate
memory in LLVM.
-
-
-
+
-
+
Syntax:
- <result> = alloca <type>[, i32 <NumElements>][, align <alignment>] ; yields {type*}:result
+ <result> = alloca <type>[, <ty> <NumElements>][, align <alignment>] ; yields {type*}:result
Overview:
@@ -4170,10 +4401,11 @@ Instruction
-
+
-
+
Syntax:
@@ -4190,9 +4422,8 @@ Instruction
from which to load. The pointer must point to
a
first class type. If the
load is
marked as
volatile, then the optimizer is not allowed to modify the
- number or order of execution of this
load with other
- volatile
load and
store
- instructions.
+ number or order of execution of this
load with other
volatile operations.
The optional constant align argument specifies the alignment of the
operation (that is, the alignment of the memory address). A value of 0 or an
@@ -4229,15 +4460,16 @@ Instruction
-
+
-
+
Syntax:
- store <ty> <value>, <ty>* <pointer>[, align <alignment>][, !nontemporal !] ; yields {void}
- volatile store <ty> <value>, <ty>* <pointer>[, align <alignment>][, !nontemporal !] ; yields {void}
+ store <ty> <value>, <ty>* <pointer>[, align <alignment>][, !nontemporal !<index>] ; yields {void}
+ volatile store <ty> <value>, <ty>* <pointer>[, align <alignment>][, !nontemporal !<index>] ; yields {void}
Overview:
@@ -4248,11 +4480,10 @@ Instruction
and an address at which to store it. The type of the
'
<pointer>' operand must be a pointer to
the
first class type of the
- '
<value>' operand. If the
store is marked
- as
volatile, then the optimizer is not allowed to modify the number
- or order of execution of this
store with other
- volatile
load and
store
- instructions.
+ '
<value>' operand. If the
store is marked as
+
volatile, then the optimizer is not allowed to modify the number or
+ order of execution of this
store with other
volatile operations.
The optional constant "align" argument specifies the alignment of the
operation (that is, the alignment of the memory address). A value of 0 or an
@@ -4263,7 +4494,7 @@ Instruction
produce less efficient code. An alignment of 1 is always safe.
The optional !nontemporal metadata must reference a single metatadata
- name corresponding to a metadata node with one i32 entry of
+ name <index> corresponding to a metadata node with one i32 entry of
value 1. The existence of the !nontemporal metatadata on the
instruction tells the optimizer and code generator that this load is
not expected to be reused in the cache. The code generator may
@@ -4291,11 +4522,11 @@ Instruction
-
+
-
+
Syntax:
@@ -4317,12 +4548,12 @@ Instruction
indexes a value of the type pointed to (not necessarily the value directly
pointed to, since the first index can be non-zero), etc. The first type
indexed into must be a pointer value, subsequent types can be arrays,
- vectors, structs and unions. Note that subsequent types being indexed into
+ vectors, and structs. Note that subsequent types being indexed into
can never be pointers, since that would require loading the pointer before
continuing calculation.
The type of each index argument depends on the type it is indexing into.
- When indexing into a (optionally packed) structure or union, only i32
+ 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, and they are not required to be
constant.
@@ -4330,8 +4561,7 @@ Instruction
For example, let's consider a C code fragment and how it gets compiled to
LLVM:
-
-
+
struct RT {
char A;
int B[10][20];
@@ -4347,12 +4577,10 @@ int *foo(struct ST *s) {
return &s[1].Z.B[5][13];
}
-
The LLVM code generated by the GCC frontend is:
-
-
+
%RT = type { i8 , [10 x [20 x i32]], i8 }
%ST = type { i32, double, %RT }
@@ -4362,7 +4590,6 @@ entry:
ret i32* %reg
}
-
Semantics:
In the example above, the first index is indexing into the '%ST*'
@@ -4391,13 +4618,14 @@ entry:
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.
+
getelementptr is a
trap value 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
@@ -4424,23 +4652,25 @@ entry:
-
-
-
+
+
+
+
The instructions in this category are the conversion instructions (casting)
which all take a single operand and a type. They perform various bit
conversions on the operand.
-
-
-
-
+
+
+
Syntax:
@@ -4452,12 +4682,12 @@ entry:
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 integer type. The bit size of value must
- be larger than the bit size of ty2. Equal sized types are not
- allowed.
+The 'trunc' instruction takes a value to trunc, and a type to trunc it to.
+ Both types must be of integer types, or vectors
+ of the same number of integers.
+ The bit size of the value must be larger than
+ the bit size of the destination type, ty2.
+ Equal sized types are not allowed.
Semantics:
The 'trunc' instruction truncates the high order bits
@@ -4467,18 +4697,20 @@ entry:
Example:
- %X = trunc i32 257 to i8 ; yields i8:1
- %Y = trunc i32 123 to i1 ; yields i1:true
- %Z = trunc i32 122 to i1 ; yields i1:false
+ %X = trunc i32 257 to i8 ; yields i8:1
+ %Y = trunc i32 123 to i1 ; yields i1:true
+ %Z = trunc i32 122 to i1 ; yields i1:false
+ %W = trunc <2 x i16> <i16 8, i16 7> to <2 x i8> ; yields <i8 8, i8 7>
-
-
+
+
+
Syntax:
@@ -4491,10 +4723,11 @@ entry:
Arguments:
-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,
+
The 'zext' instruction takes a value to cast, and a type to cast it to.
+ Both types must be of integer types, or vectors
+ of the same number of integers.
+ The bit size of the value must be smaller than
+ the bit size of the destination type,
ty2.
Semantics:
@@ -4507,15 +4740,17 @@ entry:
%X = zext i32 257 to i64 ; yields i64:257
%Y = zext i1 true to i32 ; yields i32:1
+ %Z = zext <2 x i16> <i16 8, i16 7> to <2 x i32> ; yields <i32 8, i32 7>
-
-
+
+
+
Syntax:
@@ -4526,10 +4761,11 @@ entry:
The 'sext' sign extends value to the type ty2.
Arguments:
-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,
+
The 'sext' instruction takes a value to cast, and a type to cast it to.
+ Both types must be of integer types, or vectors
+ of the same number of integers.
+ The bit size of the value must be smaller than
+ the bit size of the destination type,
ty2.
Semantics:
@@ -4543,16 +4779,17 @@ entry:
%X = sext i8 -1 to i16 ; yields i16 :65535
%Y = sext i1 true to i32 ; yields i32:-1
+ %Z = sext <2 x i16> <i16 8, i16 7> to <2 x i32> ; yields <i32 8, i32 7>
-
+
-
+
Syntax:
@@ -4586,10 +4823,11 @@ entry:
-
-
+
+
+
Syntax:
@@ -4615,17 +4853,18 @@ entry:
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)
+ %X = fpext float 3.125 to double ; yields double:3.125000e+00
+ %Y = fpext double %X to fp128 ; yields fp128:0xL00000000000000004000900000000000
-
-
+
+
+
Syntax:
@@ -4659,10 +4898,11 @@ entry:
-
-
+
+
+
Syntax:
@@ -4697,10 +4937,11 @@ entry:
-
-
+
+
+
Syntax:
@@ -4733,10 +4974,11 @@ entry:
-
-
+
+
+
Syntax:
@@ -4768,10 +5010,11 @@ entry:
-
-
+
+
+
Syntax:
@@ -4805,10 +5048,11 @@ entry:
-
-
+
+
+
Syntax:
@@ -4842,10 +5086,11 @@ entry:
-
-
+
+
+
Syntax:
@@ -4884,21 +5129,24 @@ entry:
+
+
-
+
-
+
The instructions in this category are the "miscellaneous" instructions, which
defy better classification.
-
-
-
+
-
+
Syntax:
@@ -4997,10 +5245,11 @@ entry:
-
+
-
+
Syntax:
@@ -5117,11 +5366,11 @@ entry:
-
+
-
+
Syntax:
@@ -5165,11 +5414,11 @@ Loop: ; Infinite loop that counts from 0 on up...
-
+
-
+
Syntax:
@@ -5208,11 +5457,11 @@ Loop: ; Infinite loop that counts from 0 on up...
-
+
-
+
Syntax:
@@ -5295,7 +5544,7 @@ Loop: ; Infinite loop that counts from 0 on up...
Example:
%retval = call i32 @test(i32 %argc)
- call i32 (i8 *, ...)* @printf(i8 * %msg, i32 12, i8 42) ; yields i32
+ call i32 (i8*, ...)* @printf(i8* %msg, i32 12, i8 42) ; yields i32
%X = tail call i32 @foo() ; yields i32
%Y = tail call fastcc i32 @foo() ; yields i32
call void %foo(i8 97 signext)
@@ -5317,11 +5566,11 @@ freestanding environments and non-C-based languages.
-
+
-
+
Syntax:
@@ -5362,11 +5611,15 @@ freestanding environments and non-C-based languages.
+
+
+
+
-
+
-
+
LLVM supports the notion of an "intrinsic function". These functions have
well known names and semantics and are required to follow certain
@@ -5409,14 +5662,12 @@ freestanding environments and non-C-based languages.
To learn how to add an intrinsic function, please see the
Extending LLVM Guide.
-
-
-
+
-
+
Variable argument support is defined in LLVM with
the va_arg instruction and these three
@@ -5432,8 +5683,7 @@ freestanding environments and non-C-based languages.
instruction and the variable argument handling intrinsic functions are
used.
-
-
+
define i32 @test(i32 %X, ...) {
; Initialize variable argument processing
%ap = alloca i8*
@@ -5458,17 +5708,14 @@ declare void @llvm.va_start(i8*)
declare void @llvm.va_copy(i8*, i8*)
declare void @llvm.va_end(i8*)
-
-
-
-
+
-
+
Syntax:
@@ -5494,11 +5741,11 @@ declare void @llvm.va_end(i8*)
-
+
-
+
Syntax:
@@ -5525,11 +5772,11 @@ declare void @llvm.va_end(i8*)
-
+
-
+
Syntax:
@@ -5555,12 +5802,14 @@ declare void @llvm.va_end(i8*)
+
+
-
+
-
+
LLVM support for Accurate Garbage
Collection (GC) requires the implementation and generation of these
@@ -5575,14 +5824,12 @@ LLVM.
The garbage collection intrinsics only operate on objects in the generic
address space (address space zero).
-
-
-
+
-
+
Syntax:
@@ -5609,11 +5856,11 @@ LLVM.
-
+
-
+
Syntax:
@@ -5641,11 +5888,11 @@ LLVM.
-
+
-
+
Syntax:
@@ -5672,24 +5919,24 @@ LLVM.
+
+
-
+
-
+
These intrinsics are provided by LLVM to expose special features that may
only be implemented with code generator support.
-
-
-
+
-
+
Syntax:
@@ -5720,15 +5967,15 @@ LLVM.
-
+
-
+
Syntax:
- declare i8 *@llvm.frameaddress(i32 <level>)
+ declare i8* @llvm.frameaddress(i32 <level>)
Overview:
@@ -5754,15 +6001,15 @@ LLVM.
-
+
-
+
Syntax:
- declare i8 *@llvm.stacksave()
+ declare i8* @llvm.stacksave()
Overview:
@@ -5784,15 +6031,15 @@ LLVM.
-
+
-
+
Syntax:
- declare void @llvm.stackrestore(i8 * %ptr)
+ declare void @llvm.stackrestore(i8* %ptr)
Overview:
@@ -5809,11 +6056,11 @@ LLVM.
-
+
-
+
Syntax:
@@ -5842,11 +6089,11 @@ LLVM.
-
+
-
+
Syntax:
@@ -5873,15 +6120,15 @@ LLVM.
-
+
-
+
Syntax:
- declare i64 @llvm.readcyclecounter( )
+ declare i64 @llvm.readcyclecounter()
Overview:
@@ -5899,26 +6146,26 @@ LLVM.
+
+
-
+
-
+
LLVM provides intrinsics for a few important standard C library functions.
These intrinsics allow source-language front-ends to pass information about
the alignment of the pointer arguments to the code generator, providing
opportunity for more efficient code generation.
-
-
-
+
-
+
Syntax:
This is an overloaded intrinsic. You can use llvm.memcpy on any
@@ -5926,9 +6173,9 @@ LLVM.
all bit widths however.
- declare void @llvm.memcpy.p0i8.p0i8.i32(i8 * <dest>, i8 * <src>,
+ declare void @llvm.memcpy.p0i8.p0i8.i32(i8* <dest>, i8* <src>,
i32 <len>, i32 <align>, i1 <isvolatile>)
- declare void @llvm.memcpy.p0i8.p0i8.i64(i8 * <dest>, i8 * <src>,
+ declare void @llvm.memcpy.p0i8.p0i8.i64(i8* <dest>, i8* <src>,
i64 <len>, i32 <align>, i1 <isvolatile>)
@@ -5952,8 +6199,10 @@ LLVM.
then the caller guarantees that both the source and destination pointers are
aligned to that boundary.
-
Volatile accesses should not be deleted if dead, but the access behavior is
- not very cleanly specified and it is unwise to depend on it.
+
If the isvolatile parameter is true, the
+ llvm.memcpy call is a volatile operation.
+ The detailed access behavior is not very cleanly specified and it is unwise
+ to depend on it.
Semantics:
@@ -5966,11 +6215,11 @@ LLVM.
-
+
-
+
Syntax:
This is an overloaded intrinsic. You can use llvm.memmove on any integer bit
@@ -5978,9 +6227,9 @@ LLVM.
widths however.
- declare void @llvm.memmove.p0i8.p0i8.i32(i8 * <dest>, i8 * <src>,
+ declare void @llvm.memmove.p0i8.p0i8.i32(i8* <dest>, i8* <src>,
i32 <len>, i32 <align>, i1 <isvolatile>)
- declare void @llvm.memmove.p0i8.p0i8.i64(i8 * <dest>, i8 * <src>,
+ declare void @llvm.memmove.p0i8.p0i8.i64(i8* <dest>, i8* <src>,
i64 <len>, i32 <align>, i1 <isvolatile>)
@@ -6006,8 +6255,10 @@ LLVM.
then the caller guarantees that the source and destination pointers are
aligned to that boundary.
-
Volatile accesses should not be deleted if dead, but the access behavior is
- not very cleanly specified and it is unwise to depend on it.
+
If the isvolatile parameter is true, the
+ llvm.memmove call is a volatile operation.
+ The detailed access behavior is not very cleanly specified and it is unwise
+ to depend on it.
Semantics:
@@ -6020,21 +6271,21 @@ LLVM.
-
+
-
+
Syntax:
This is an overloaded intrinsic. You can use llvm.memset on any integer bit
- width and for different address spaces. Not all targets support all bit
- widths however.
+ width and for different address spaces. However, not all targets support all
+ bit widths.
- declare void @llvm.memset.p0i8.i32(i8 * <dest>, i8 <val>,
+ declare void @llvm.memset.p0i8.i32(i8* <dest>, i8 <val>,
i32 <len>, i32 <align>, i1 <isvolatile>)
- declare void @llvm.memset.p0i8.i64(i8 * <dest>, i8 <val>,
+ declare void @llvm.memset.p0i8.i64(i8* <dest>, i8 <val>,
i64 <len>, i32 <align>, i1 <isvolatile>)
@@ -6043,21 +6294,23 @@ LLVM.
particular byte value.
Note that, unlike the standard libc function, the llvm.memset
- intrinsic does not return a value, takes extra alignment/volatile arguments,
- and the destination can be in an arbitrary address space.
+ intrinsic does not return a value and takes extra alignment/volatile
+ arguments. Also, the destination can be in an arbitrary address space.
Arguments:
The first argument is a pointer to the destination to fill, the second is the
- byte value to fill it with, the third argument is an integer argument
+ byte value with which to fill it, the third argument is an integer argument
specifying the number of bytes to fill, and the fourth argument is the known
- alignment of destination location.
+ alignment of the destination location.
If the call to this intrinsic has an alignment value that is not 0 or 1,
then the caller guarantees that the destination pointer is aligned to that
boundary.
-
Volatile accesses should not be deleted if dead, but the access behavior is
- not very cleanly specified and it is unwise to depend on it.
+
If the isvolatile parameter is true, the
+ llvm.memset call is a volatile operation.
+ The detailed access behavior is not very cleanly specified and it is unwise
+ to depend on it.
Semantics:
The 'llvm.memset.*' intrinsics fill "len" bytes of memory starting
@@ -6068,11 +6321,11 @@ LLVM.
-
+
-
+
Syntax:
This is an overloaded intrinsic. You can use llvm.sqrt on any
@@ -6106,11 +6359,11 @@ LLVM.
-
+
-
+
Syntax:
This is an overloaded intrinsic. You can use llvm.powi on any
@@ -6142,11 +6395,11 @@ LLVM.
-
+
-
+
Syntax:
This is an overloaded intrinsic. You can use llvm.sin on any
@@ -6176,11 +6429,11 @@ LLVM.
-
+
-
+
Syntax:
This is an overloaded intrinsic. You can use llvm.cos on any
@@ -6210,11 +6463,11 @@ LLVM.
-
+
-
+
Syntax:
This is an overloaded intrinsic. You can use llvm.pow on any
@@ -6244,24 +6497,90 @@ LLVM.
+
+
+
+
+
+
+
+
Syntax:
+
This is an overloaded intrinsic. You can use llvm.exp on any
+ floating point or vector of floating point type. Not all targets support all
+ types however.
+
+
+ declare float @llvm.exp.f32(float %Val)
+ declare double @llvm.exp.f64(double %Val)
+ declare x86_fp80 @llvm.exp.f80(x86_fp80 %Val)
+ declare fp128 @llvm.exp.f128(fp128 %Val)
+ declare ppc_fp128 @llvm.exp.ppcf128(ppc_fp128 %Val)
+
+
+
Overview:
+
The 'llvm.exp.*' intrinsics perform the exp function.
+
+
Arguments:
+
The argument and return value are floating point numbers of the same
+ type.
+
+
Semantics:
+
This function returns the same values as the libm exp functions
+ would, and handles error conditions in the same way.
+
+
+
+
+
+
+
+
+
Syntax:
+
This is an overloaded intrinsic. You can use llvm.log on any
+ floating point or vector of floating point type. Not all targets support all
+ types however.
+
+
+ declare float @llvm.log.f32(float %Val)
+ declare double @llvm.log.f64(double %Val)
+ declare x86_fp80 @llvm.log.f80(x86_fp80 %Val)
+ declare fp128 @llvm.log.f128(fp128 %Val)
+ declare ppc_fp128 @llvm.log.ppcf128(ppc_fp128 %Val)
+
+
+
Overview:
+
The 'llvm.log.*' intrinsics perform the log function.
+
+
Arguments:
+
The argument and return value are floating point numbers of the same
+ type.
+
+
Semantics:
+
This function returns the same values as the libm log functions
+ would, and handles error conditions in the same way.
+
+
+
-
+
-
+
LLVM provides intrinsics for a few important bit manipulation operations.
These allow efficient code generation for some algorithms.
-
-
-
+
-
+
Syntax:
This is an overloaded intrinsic function. You can use bswap on any integer
@@ -6292,11 +6611,11 @@ LLVM.
-
+
-
+
Syntax:
This is an overloaded intrinsic. You can use llvm.ctpop on any integer bit
@@ -6324,11 +6643,11 @@ LLVM.
-
+
-
+
Syntax:
This is an overloaded intrinsic. You can use llvm.ctlz on any
@@ -6358,11 +6677,11 @@ LLVM.
-
+
-
+
Syntax:
This is an overloaded intrinsic. You can use llvm.cttz on any
@@ -6391,23 +6710,25 @@ LLVM.
+
+
-
+
-
+
LLVM provides intrinsics for some arithmetic with overflow operations.
-
-
-
+
-
+
Syntax:
This is an overloaded intrinsic. You can use llvm.sadd.with.overflow
@@ -6449,11 +6770,13 @@ LLVM.
-
+
-
+
Syntax:
This is an overloaded intrinsic. You can use llvm.uadd.with.overflow
@@ -6494,11 +6817,13 @@ LLVM.
-
+
-
+
Syntax:
This is an overloaded intrinsic. You can use llvm.ssub.with.overflow
@@ -6540,11 +6865,13 @@ LLVM.
-
+
-
+
Syntax:
This is an overloaded intrinsic. You can use llvm.usub.with.overflow
@@ -6586,11 +6913,13 @@ LLVM.
-
+
-
+
Syntax:
This is an overloaded intrinsic. You can use llvm.smul.with.overflow
@@ -6633,11 +6962,13 @@ LLVM.
-
+
-
+
Syntax:
This is an overloaded intrinsic. You can use llvm.umul.with.overflow
@@ -6678,12 +7009,14 @@ LLVM.
+
+
-
+
-
+
Half precision floating point is a storage-only format. This means that it is
a dense encoding (in memory) but does not support computation in the
@@ -6697,14 +7030,15 @@ LLVM.
float if needed, then converted to i16 with
llvm.convert.to.fp16, then
storing as an i16 value.
-
-
+
-
+
Syntax:
@@ -6735,11 +7069,13 @@ LLVM.
-
+
-
+
Syntax:
@@ -6769,12 +7105,14 @@ LLVM.
+
+
-
+
-
+
The LLVM debugger intrinsics (which all start with llvm.dbg.
prefix), are described in
@@ -6784,11 +7122,11 @@ LLVM.
-
+
-
+
The LLVM exception handling intrinsics (which all start with
llvm.eh. prefix), are described in
@@ -6798,14 +7136,15 @@ LLVM.
-
+
-
+
This intrinsic makes it possible to excise one parameter, marked with
- the nest attribute, from a function. The result is a callable
+ the nest attribute, from a function.
+ The result is a callable
function pointer lacking the nest parameter - the caller does not need to
provide a value for it. Instead, the value to use is stored in advance in a
"trampoline", a block of memory usually allocated on the stack, which also
@@ -6817,26 +7156,24 @@ LLVM.
pointer has signature
i32 (i32, i32)*. It can be created as
follows:
-
-
+
%tramp = alloca [10 x i8], align 4 ; size and alignment only correct for X86
%tramp1 = getelementptr [10 x i8]* %tramp, i32 0, i32 0
- %p = call i8* @llvm.init.trampoline( i8* %tramp1, i8* bitcast (i32 (i8* nest , i32, i32)* @f to i8*), i8* %nval )
+ %p = call i8* @llvm.init.trampoline(i8* %tramp1, i8* bitcast (i32 (i8* nest , i32, i32)* @f to i8*), i8* %nval)
%fp = bitcast i8* %p to i32 (i32, i32)*
-
-
-
The call %val = call i32 %fp( i32 %x, i32 %y ) is then equivalent
- to %val = call i32 %f( i8* %nval, i32 %x, i32 %y ).
-
+
The call %val = call i32 %fp(i32 %x, i32 %y) is then equivalent
+ to %val = call i32 %f(i8* %nval, i32 %x, i32 %y).
-
+
-
+
Syntax:
@@ -6873,12 +7210,14 @@ LLVM.
+
+
-
+
-
+
These intrinsic functions expand the "universal IR" of LLVM to represent
hardware constructs for atomic operations and memory synchronization. This
@@ -6898,16 +7237,15 @@ LLVM.
No one model or paradigm should be selected above others unless the hardware
itself ubiquitously does so.
-
-
-
-
+
+
+
Syntax:
- declare void @llvm.memory.barrier( i1 <ll>, i1 <ls>, i1 <sl>, i1 <ss>, i1 <device> )
+ declare void @llvm.memory.barrier(i1 <ll>, i1 <ls>, i1 <sl>, i1 <ss>, i1 <device>)
Overview:
@@ -6964,7 +7302,7 @@ LLVM.
store i32 4, %ptr
%result1 = load i32* %ptr
; yields {i32}:result1 = 4
- call void @llvm.memory.barrier( i1 false, i1 true, i1 false, i1 false )
+ call void @llvm.memory.barrier(i1 false, i1 true, i1 false, i1 false)
; guarantee the above finishes
store i32 8, %ptr
; before this begins
@@ -6972,11 +7310,11 @@ LLVM.
-
+
-
+
Syntax:
This is an overloaded intrinsic. You can use llvm.atomic.cmp.swap on
@@ -6984,10 +7322,10 @@ LLVM.
support all bit widths however.
- declare i8 @llvm.atomic.cmp.swap.i8.p0i8( i8* <ptr>, i8 <cmp>, i8 <val> )
- declare i16 @llvm.atomic.cmp.swap.i16.p0i16( i16* <ptr>, i16 <cmp>, i16 <val> )
- declare i32 @llvm.atomic.cmp.swap.i32.p0i32( i32* <ptr>, i32 <cmp>, i32 <val> )
- declare i64 @llvm.atomic.cmp.swap.i64.p0i64( i64* <ptr>, i64 <cmp>, i64 <val> )
+ declare i8 @llvm.atomic.cmp.swap.i8.p0i8(i8* <ptr>, i8 <cmp>, i8 <val>)
+ declare i16 @llvm.atomic.cmp.swap.i16.p0i16(i16* <ptr>, i16 <cmp>, i16 <val>)
+ declare i32 @llvm.atomic.cmp.swap.i32.p0i32(i32* <ptr>, i32 <cmp>, i32 <val>)
+ declare i64 @llvm.atomic.cmp.swap.i64.p0i64(i64* <ptr>, i64 <cmp>, i64 <val>)
Overview:
@@ -7016,13 +7354,13 @@ LLVM.
store i32 4, %ptr
%val1 = add i32 4, 4
-%result1 = call i32 @llvm.atomic.cmp.swap.i32.p0i32( i32* %ptr, i32 4, %val1 )
+%result1 = call i32 @llvm.atomic.cmp.swap.i32.p0i32(i32* %ptr, i32 4, %val1)
; yields {i32}:result1 = 4
%stored1 = icmp eq i32 %result1, 4
; yields {i1}:stored1 = true
%memval1 = load i32* %ptr
; yields {i32}:memval1 = 8
%val2 = add i32 1, 1
-%result2 = call i32 @llvm.atomic.cmp.swap.i32.p0i32( i32* %ptr, i32 5, %val2 )
+%result2 = call i32 @llvm.atomic.cmp.swap.i32.p0i32(i32* %ptr, i32 5, %val2)
; yields {i32}:result2 = 8
%stored2 = icmp eq i32 %result2, 5
; yields {i1}:stored2 = false
@@ -7032,20 +7370,21 @@ LLVM.
-
-
+
+
+
Syntax:
This is an overloaded intrinsic. You can use llvm.atomic.swap on any
integer bit width. Not all targets support all bit widths however.
- declare i8 @llvm.atomic.swap.i8.p0i8( i8* <ptr>, i8 <val> )
- declare i16 @llvm.atomic.swap.i16.p0i16( i16* <ptr>, i16 <val> )
- declare i32 @llvm.atomic.swap.i32.p0i32( i32* <ptr>, i32 <val> )
- declare i64 @llvm.atomic.swap.i64.p0i64( i64* <ptr>, i64 <val> )
+ declare i8 @llvm.atomic.swap.i8.p0i8(i8* <ptr>, i8 <val>)
+ declare i16 @llvm.atomic.swap.i16.p0i16(i16* <ptr>, i16 <val>)
+ declare i32 @llvm.atomic.swap.i32.p0i32(i32* <ptr>, i32 <val>)
+ declare i64 @llvm.atomic.swap.i64.p0i64(i64* <ptr>, i64 <val>)
Overview:
@@ -7072,13 +7411,13 @@ LLVM.
store i32 4, %ptr
%val1 = add i32 4, 4
-%result1 = call i32 @llvm.atomic.swap.i32.p0i32( i32* %ptr, i32 %val1 )
+%result1 = call i32 @llvm.atomic.swap.i32.p0i32(i32* %ptr, i32 %val1)
; yields {i32}:result1 = 4
%stored1 = icmp eq i32 %result1, 4
; yields {i1}:stored1 = true
%memval1 = load i32* %ptr
; yields {i32}:memval1 = 8
%val2 = add i32 1, 1
-%result2 = call i32 @llvm.atomic.swap.i32.p0i32( i32* %ptr, i32 %val2 )
+%result2 = call i32 @llvm.atomic.swap.i32.p0i32(i32* %ptr, i32 %val2)
; yields {i32}:result2 = 8
%stored2 = icmp eq i32 %result2, 8
; yields {i1}:stored2 = true
@@ -7088,22 +7427,21 @@ LLVM.
-
-
-
+
Syntax:
This is an overloaded intrinsic. You can use llvm.atomic.load.add on
any integer bit width. Not all targets support all bit widths however.
- declare i8 @llvm.atomic.load.add.i8..p0i8( i8* <ptr>, i8 <delta> )
- declare i16 @llvm.atomic.load.add.i16..p0i16( i16* <ptr>, i16 <delta> )
- declare i32 @llvm.atomic.load.add.i32..p0i32( i32* <ptr>, i32 <delta> )
- declare i64 @llvm.atomic.load.add.i64..p0i64( i64* <ptr>, i64 <delta> )
+ declare i8 @llvm.atomic.load.add.i8.p0i8(i8* <ptr>, i8 <delta>)
+ declare i16 @llvm.atomic.load.add.i16.p0i16(i16* <ptr>, i16 <delta>)
+ declare i32 @llvm.atomic.load.add.i32.p0i32(i32* <ptr>, i32 <delta>)
+ declare i64 @llvm.atomic.load.add.i64.p0i64(i64* <ptr>, i64 <delta>)
Overview:
@@ -7126,11 +7464,11 @@ LLVM.
%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 )
+%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 )
+%result2 = call i32 @llvm.atomic.load.add.i32.p0i32(i32* %ptr, i32 2)
; yields {i32}:result2 = 8
-%result3 = call i32 @llvm.atomic.load.add.i32.p0i32( i32* %ptr, i32 5 )
+%result3 = call i32 @llvm.atomic.load.add.i32.p0i32(i32* %ptr, i32 5)
; yields {i32}:result3 = 10
%memval1 = load i32* %ptr
; yields {i32}:memval1 = 15
@@ -7138,12 +7476,11 @@ LLVM.
-
-
-
+
Syntax:
This is an overloaded intrinsic. You can use llvm.atomic.load.sub on
@@ -7151,10 +7488,10 @@ LLVM.
support all bit widths however.
- declare i8 @llvm.atomic.load.sub.i8.p0i32( i8* <ptr>, i8 <delta> )
- declare i16 @llvm.atomic.load.sub.i16.p0i32( i16* <ptr>, i16 <delta> )
- declare i32 @llvm.atomic.load.sub.i32.p0i32( i32* <ptr>, i32 <delta> )
- declare i64 @llvm.atomic.load.sub.i64.p0i32( i64* <ptr>, i64 <delta> )
+ declare i8 @llvm.atomic.load.sub.i8.p0i32(i8* <ptr>, i8 <delta>)
+ declare i16 @llvm.atomic.load.sub.i16.p0i32(i16* <ptr>, i16 <delta>)
+ declare i32 @llvm.atomic.load.sub.i32.p0i32(i32* <ptr>, i32 <delta>)
+ declare i64 @llvm.atomic.load.sub.i64.p0i32(i64* <ptr>, i64 <delta>)
Overview:
@@ -7178,11 +7515,11 @@ LLVM.
%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 )
+%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 )
+%result2 = call i32 @llvm.atomic.load.sub.i32.p0i32(i32* %ptr, i32 2)
; yields {i32}:result2 = 4
-%result3 = call i32 @llvm.atomic.load.sub.i32.p0i32( i32* %ptr, i32 5 )
+%result3 = call i32 @llvm.atomic.load.sub.i32.p0i32(i32* %ptr, i32 5)
; yields {i32}:result3 = 2
%memval1 = load i32* %ptr
; yields {i32}:memval1 = -3
@@ -7190,14 +7527,25 @@ LLVM.
-
-
-
+
+
+
Syntax:
These are overloaded intrinsics. You can
@@ -7207,31 +7555,31 @@ LLVM.
widths however.
- declare i8 @llvm.atomic.load.and.i8.p0i8( i8* <ptr>, i8 <delta> )
- declare i16 @llvm.atomic.load.and.i16.p0i16( i16* <ptr>, i16 <delta> )
- declare i32 @llvm.atomic.load.and.i32.p0i32( i32* <ptr>, i32 <delta> )
- declare i64 @llvm.atomic.load.and.i64.p0i64( i64* <ptr>, i64 <delta> )
+ declare i8 @llvm.atomic.load.and.i8.p0i8(i8* <ptr>, i8 <delta>)
+ declare i16 @llvm.atomic.load.and.i16.p0i16(i16* <ptr>, i16 <delta>)
+ declare i32 @llvm.atomic.load.and.i32.p0i32(i32* <ptr>, i32 <delta>)
+ declare i64 @llvm.atomic.load.and.i64.p0i64(i64* <ptr>, i64 <delta>)
- declare i8 @llvm.atomic.load.or.i8.p0i8( i8* <ptr>, i8 <delta> )
- declare i16 @llvm.atomic.load.or.i16.p0i16( i16* <ptr>, i16 <delta> )
- declare i32 @llvm.atomic.load.or.i32.p0i32( i32* <ptr>, i32 <delta> )
- declare i64 @llvm.atomic.load.or.i64.p0i64( i64* <ptr>, i64 <delta> )
+ declare i8 @llvm.atomic.load.or.i8.p0i8(i8* <ptr>, i8 <delta>)
+ declare i16 @llvm.atomic.load.or.i16.p0i16(i16* <ptr>, i16 <delta>)
+ declare i32 @llvm.atomic.load.or.i32.p0i32(i32* <ptr>, i32 <delta>)
+ declare i64 @llvm.atomic.load.or.i64.p0i64(i64* <ptr>, i64 <delta>)
- declare i8 @llvm.atomic.load.nand.i8.p0i32( i8* <ptr>, i8 <delta> )
- declare i16 @llvm.atomic.load.nand.i16.p0i32( i16* <ptr>, i16 <delta> )
- declare i32 @llvm.atomic.load.nand.i32.p0i32( i32* <ptr>, i32 <delta> )
- declare i64 @llvm.atomic.load.nand.i64.p0i32( i64* <ptr>, i64 <delta> )
+ declare i8 @llvm.atomic.load.nand.i8.p0i32(i8* <ptr>, i8 <delta>)
+ declare i16 @llvm.atomic.load.nand.i16.p0i32(i16* <ptr>, i16 <delta>)
+ declare i32 @llvm.atomic.load.nand.i32.p0i32(i32* <ptr>, i32 <delta>)
+ declare i64 @llvm.atomic.load.nand.i64.p0i32(i64* <ptr>, i64 <delta>)
- declare i8 @llvm.atomic.load.xor.i8.p0i32( i8* <ptr>, i8 <delta> )
- declare i16 @llvm.atomic.load.xor.i16.p0i32( i16* <ptr>, i16 <delta> )
- declare i32 @llvm.atomic.load.xor.i32.p0i32( i32* <ptr>, i32 <delta> )
- declare i64 @llvm.atomic.load.xor.i64.p0i32( i64* <ptr>, i64 <delta> )
+ declare i8 @llvm.atomic.load.xor.i8.p0i32(i8* <ptr>, i8 <delta>)
+ declare i16 @llvm.atomic.load.xor.i16.p0i32(i16* <ptr>, i16 <delta>)
+ declare i32 @llvm.atomic.load.xor.i32.p0i32(i32* <ptr>, i32 <delta>)
+ declare i64 @llvm.atomic.load.xor.i64.p0i32(i64* <ptr>, i64 <delta>)
Overview:
@@ -7256,13 +7604,13 @@ LLVM.
%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 )
+%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 )
+%result1 = call i32 @llvm.atomic.load.and.i32.p0i32(i32* %ptr, i32 0xFF)
; yields {i32}:result1 = 0xFFFFFFF0
-%result2 = call i32 @llvm.atomic.load.or.i32.p0i32( i32* %ptr, i32 0F )
+%result2 = call i32 @llvm.atomic.load.or.i32.p0i32(i32* %ptr, i32 0F)
; yields {i32}:result2 = 0xF0
-%result3 = call i32 @llvm.atomic.load.xor.i32.p0i32( i32* %ptr, i32 0F )
+%result3 = call i32 @llvm.atomic.load.xor.i32.p0i32(i32* %ptr, i32 0F)
; yields {i32}:result3 = FF
%memval1 = load i32* %ptr
; yields {i32}:memval1 = F0
@@ -7270,14 +7618,25 @@ LLVM.
-
-
-
+
+
+
Syntax:
These are overloaded intrinsics. You can use llvm.atomic.load_max,
@@ -7286,31 +7645,31 @@ LLVM.
address spaces. Not all targets support all bit widths however.
- declare i8 @llvm.atomic.load.max.i8.p0i8( i8* <ptr>, i8 <delta> )
- declare i16 @llvm.atomic.load.max.i16.p0i16( i16* <ptr>, i16 <delta> )
- declare i32 @llvm.atomic.load.max.i32.p0i32( i32* <ptr>, i32 <delta> )
- declare i64 @llvm.atomic.load.max.i64.p0i64( i64* <ptr>, i64 <delta> )
+ declare i8 @llvm.atomic.load.max.i8.p0i8(i8* <ptr>, i8 <delta>)
+ declare i16 @llvm.atomic.load.max.i16.p0i16(i16* <ptr>, i16 <delta>)
+ declare i32 @llvm.atomic.load.max.i32.p0i32(i32* <ptr>, i32 <delta>)
+ declare i64 @llvm.atomic.load.max.i64.p0i64(i64* <ptr>, i64 <delta>)
- declare i8 @llvm.atomic.load.min.i8.p0i8( i8* <ptr>, i8 <delta> )
- declare i16 @llvm.atomic.load.min.i16.p0i16( i16* <ptr>, i16 <delta> )
- declare i32 @llvm.atomic.load.min.i32..p0i32( i32* <ptr>, i32 <delta> )
- declare i64 @llvm.atomic.load.min.i64..p0i64( i64* <ptr>, i64 <delta> )
+ declare i8 @llvm.atomic.load.min.i8.p0i8(i8* <ptr>, i8 <delta>)
+ declare i16 @llvm.atomic.load.min.i16.p0i16(i16* <ptr>, i16 <delta>)
+ declare i32 @llvm.atomic.load.min.i32.p0i32(i32* <ptr>, i32 <delta>)
+ declare i64 @llvm.atomic.load.min.i64.p0i64(i64* <ptr>, i64 <delta>)
- declare i8 @llvm.atomic.load.umax.i8.p0i8( i8* <ptr>, i8 <delta> )
- declare i16 @llvm.atomic.load.umax.i16.p0i16( i16* <ptr>, i16 <delta> )
- declare i32 @llvm.atomic.load.umax.i32.p0i32( i32* <ptr>, i32 <delta> )
- declare i64 @llvm.atomic.load.umax.i64.p0i64( i64* <ptr>, i64 <delta> )
+ declare i8 @llvm.atomic.load.umax.i8.p0i8(i8* <ptr>, i8 <delta>)
+ declare i16 @llvm.atomic.load.umax.i16.p0i16(i16* <ptr>, i16 <delta>)
+ declare i32 @llvm.atomic.load.umax.i32.p0i32(i32* <ptr>, i32 <delta>)
+ declare i64 @llvm.atomic.load.umax.i64.p0i64(i64* <ptr>, i64 <delta>)
- declare i8 @llvm.atomic.load.umin.i8..p0i8( i8* <ptr>, i8 <delta> )
- declare i16 @llvm.atomic.load.umin.i16.p0i16( i16* <ptr>, i16 <delta> )
- declare i32 @llvm.atomic.load.umin.i32..p0i32( i32* <ptr>, i32 <delta> )
- declare i64 @llvm.atomic.load.umin.i64..p0i64( i64* <ptr>, i64 <delta> )
+ declare i8 @llvm.atomic.load.umin.i8.p0i8(i8* <ptr>, i8 <delta>)
+ declare i16 @llvm.atomic.load.umin.i16.p0i16(i16* <ptr>, i16 <delta>)
+ declare i32 @llvm.atomic.load.umin.i32.p0i32(i32* <ptr>, i32 <delta>)
+ declare i64 @llvm.atomic.load.umin.i64.p0i64(i64* <ptr>, i64 <delta>)
Overview:
@@ -7335,38 +7694,37 @@ LLVM.
%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 )
+%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 )
+%result1 = call i32 @llvm.atomic.load.max.i32.p0i32(i32* %ptr, i32 8)
; yields {i32}:result1 = -2
-%result2 = call i32 @llvm.atomic.load.umin.i32.p0i32( i32* %ptr, i32 10 )
+%result2 = call i32 @llvm.atomic.load.umin.i32.p0i32(i32* %ptr, i32 10)
; yields {i32}:result2 = 8
-%result3 = call i32 @llvm.atomic.load.umax.i32.p0i32( i32* %ptr, i32 30 )
+%result3 = call i32 @llvm.atomic.load.umax.i32.p0i32(i32* %ptr, i32 30)
; yields {i32}:result3 = 8
%memval1 = load i32* %ptr
; yields {i32}:memval1 = 30
+
-
+
-
+
This class of intrinsics exists to information about the lifetime of memory
objects and ranges where variables are immutable.
-
-
-
+
-
+
Syntax:
@@ -7392,11 +7750,11 @@ LLVM.
-
+
-
+
Syntax:
@@ -7421,15 +7779,15 @@ LLVM.
-
+
-
+
Syntax:
- declare {}* @llvm.invariant.start(i64 <size>, i8* nocapture <ptr>) readonly
+ declare {}* @llvm.invariant.start(i64 <size>, i8* nocapture <ptr>)
Overview:
@@ -7449,11 +7807,11 @@ LLVM.
-
+
-
+
Syntax:
@@ -7475,28 +7833,28 @@ LLVM.
+
+
-
+
-
+
This class of intrinsics is designed to be generic and has no specific
purpose.
-
-
-
+
-
+
Syntax:
- declare void @llvm.var.annotation(i8* <val>, i8* <str>, i8* <str>, i32 <int> )
+ declare void @llvm.var.annotation(i8* <val>, i8* <str>, i8* <str>, i32 <int>)
Overview:
@@ -7516,22 +7874,22 @@ LLVM.
-
+
-
+
Syntax:
This is an overloaded intrinsic. You can use 'llvm.annotation' on
any integer bit width.
- declare i8 @llvm.annotation.i8(i8 <val>, i8* <str>, i8* <str>, i32 <int> )
- declare i16 @llvm.annotation.i16(i16 <val>, i8* <str>, i8* <str>, i32 <int> )
- declare i32 @llvm.annotation.i32(i32 <val>, i8* <str>, i8* <str>, i32 <int> )
- declare i64 @llvm.annotation.i64(i64 <val>, i8* <str>, i8* <str>, i32 <int> )
- declare i256 @llvm.annotation.i256(i256 <val>, i8* <str>, i8* <str>, i32 <int> )
+ declare i8 @llvm.annotation.i8(i8 <val>, i8* <str>, i8* <str>, i32 <int>)
+ declare i16 @llvm.annotation.i16(i16 <val>, i8* <str>, i8* <str>, i32 <int>)
+ declare i32 @llvm.annotation.i32(i32 <val>, i8* <str>, i8* <str>, i32 <int>)
+ declare i64 @llvm.annotation.i64(i64 <val>, i8* <str>, i8* <str>, i32 <int>)
+ declare i256 @llvm.annotation.i256(i256 <val>, i8* <str>, i8* <str>, i32 <int>)
Overview:
@@ -7552,11 +7910,11 @@ LLVM.
-
+
-
+
Syntax:
@@ -7577,15 +7935,15 @@ LLVM.
-
+
-
+
Syntax:
- declare void @llvm.stackprotector( i8* <guard>, i8** <slot> )
+ declare void @llvm.stackprotector(i8* <guard>, i8** <slot>)
Overview:
@@ -7604,45 +7962,48 @@ LLVM.
the
AllocaInst stack slot to be before local variables on the
stack. This is to ensure that if a local variable on the stack is
overwritten, it will destroy the value of the guard. When the function exits,
- the guard on the stack is checked against the original guard. If they're
+ the guard on the stack is checked against the original guard. If they are
different, then the program aborts by calling the
__stack_chk_fail()
function.
-
+
-
+
Syntax:
- declare i32 @llvm.objectsize.i32( i8* <object>, i1 <type> )
- declare i64 @llvm.objectsize.i64( i8* <object>, i1 <type> )
+ declare i32 @llvm.objectsize.i32(i8* <object>, i1 <type>)
+ declare i64 @llvm.objectsize.i64(i8* <object>, i1 <type>)
Overview:
-
The llvm.objectsize intrinsic is designed to provide information
- to the optimizers to 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 class, structure, array, or other object.
+
The llvm.objectsize intrinsic is designed to provide information to
+ the optimizers to determine at compile time whether a) an operation (like
+ memcpy) will overflow a buffer that corresponds to an object, or b) that a
+ runtime check for overflow isn't necessary. An object in this context means
+ an allocation of a specific class, structure, array, or other object.
Arguments:
-
The llvm.objectsize intrinsic takes two arguments. The first
+
The llvm.objectsize intrinsic takes two arguments. The first
argument is a pointer to or into the object. The second argument
- is a boolean 0 or 1. This argument determines whether you want the
- maximum (0) or minimum (1) bytes remaining. This needs to be a literal 0 or
+ is a boolean 0 or 1. This argument determines whether you want the
+ maximum (0) or minimum (1) bytes remaining. This needs to be a literal 0 or
1, variables are not allowed.
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.
+ 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.
+
+
+
+
@@ -7655,7 +8016,7 @@ LLVM.
src="http://www.w3.org/Icons/valid-html401-blue" alt="Valid HTML 4.01">
Chris Lattner
-
The LLVM Compiler Infrastructure
+
The LLVM Compiler Infrastructure
Last modified: $Date$