Lines Matching full:instruction
51 instruction is syntactically okay, but not well formed:
134 demonstrating instructions, we will follow an instruction with a comment
570 :ref:`terminator <terminators>` instruction (such as a branch or function
741 operands for the :ref:`bitcast instruction <i_bitcast>`. This is not a
1126 - The result value of an allocation instruction is associated with the
1184 data width to be executed as single instruction. For example, in C
1252 than one instruction to read the series of bytes.
1276 differently since they don't take an address. See that instruction's
1706 getting a pointer to a field with the '``getelementptr``' instruction.
1816 operated in parallel using a single instruction (SIMD). A vector type
1941 instruction stream, metadata is a place to attach additional
2103 they also represent the fact that an instruction or constant expression
2127 - An instruction with externally visible side effects depends on the
2128 most recent preceding instruction with externally visible side
2131 - An instruction *control-depends* on a :ref:`terminator
2132 instruction <terminators>` if the terminator instruction has
2133 multiple successors and the instruction is always executed when
2136 - Additionally, an instruction also *control-depends* on a terminator
2137 instruction if the set of instructions it otherwise depends on would
2143 with the additional affect that any instruction which has a *dependence*
2193 store volatile i32 0, i32* @g ; This time, the instruction always depends
2211 ':ref:`indirectbr <i_indirectbr>`' instruction, or for comparisons
2218 instruction.
2288 instruction <i_bitcast>`.
2292 instruction, the index list may have zero or more indexes, which are
2323 the same as those for the corresponding instruction (e.g. no bitwise
2348 of a :ref:`call <i_call>` or an :ref:`invoke <i_invoke>` instruction.
2450 Metadata can be attached with an instruction. Here metadata ``!21`` is
2451 attached to the ``add`` instruction using the ``!dbg`` identifier:
2530 ``fpmath`` metadata may be attached to any instruction of floating point
2532 result of that instruction, in ULPs, thus potentially allowing the
2558 - The type must match the type loaded by the instruction.
2586 loop metadata is implemented as metadata attached to the branch instruction
2625 the ``llvm.loop`` metadata to mark the loop latch branch instruction,
2628 is at least one memory accessing instruction not marked with the metadata,
3022 Instruction Reference
3025 The LLVM instruction set consists of several different classifications
3037 program ends with a "Terminator" instruction, which indicates which
3041 ':ref:`invoke <i_invoke>`' instruction).
3050 '``ret``' Instruction
3064 The '``ret``' instruction is used to return control flow (and optionally
3067 There are two forms of the '``ret``' instruction: one that returns a
3074 The '``ret``' instruction optionally accepts a single argument, the
3079 return type and contains a '``ret``' instruction with no return value or
3081 void return type and contains a '``ret``' instruction with a return
3087 When the '``ret``' instruction is executed, control flow returns back to
3089 ":ref:`call <i_call>`" instruction, execution continues at the
3090 instruction after the call. If the caller was an
3091 ":ref:`invoke <i_invoke>`" instruction, execution continues at the
3092 beginning of the "normal" destination block. If the instruction returns
3093 a value, that value shall set the call or invoke instruction's return
3107 '``br``' Instruction
3121 The '``br``' instruction is used to cause control flow to transfer to a
3123 this instruction, corresponding to a conditional branch and an
3129 The conditional branch form of the '``br``' instruction takes a single
3131 '``br``' instruction takes a single '``label``' value as a target.
3136 Upon execution of a conditional '``br``' instruction, the '``i1``'
3156 '``switch``' Instruction
3169 The '``switch``' instruction is used to transfer control flow to one of
3171 instruction, allowing a branch to occur to one of many possible
3177 The '``switch``' instruction uses three parameters: an integer
3185 The ``switch`` instruction specifies a table of values and destinations.
3186 When the '``switch``' instruction is executed, this table is searched
3195 ``switch`` instruction, this instruction may be code generated in
3204 ; Emulate a conditional br instruction
3208 ; Emulate an unconditional br instruction
3218 '``indirectbr``' Instruction
3231 The '``indirectbr``' instruction implements an indirect branch to a
3252 this instruction has undefined behavior. This implies that jumps to
3269 '``invoke``' Instruction
3283 The '``invoke``' instruction causes control to transfer to a specified
3286 returns with the "``ret``" instruction, control flow will return to the
3288 ":ref:`resume <i_resume>`" instruction or other exception handling
3295 ":ref:`landingpad <i_landingpad>`" instruction, which contains the
3297 as its first non-PHI instruction. The restrictions on the
3298 "``landingpad``" instruction's tightly couples it to the "``invoke``"
3299 instruction, so that the important information contained within the
3300 "``landingpad``" instruction can't be lost through normal code motion.
3305 This instruction requires several arguments:
3325 executes a '``ret``' instruction.
3327 the :ref:`resume <i_resume>` instruction or other exception handling
3336 This instruction is designed to operate as a standard '``call``'
3337 instruction in most regards. The primary difference is that it
3341 This instruction is used in languages with destructors to ensure that
3347 by the '``invoke``' instruction is deemed to occur on the edge from the
3363 '``resume``' Instruction
3376 The '``resume``' instruction is a terminator instruction that has no
3382 The '``resume``' instruction requires one argument, which must have the
3383 same type as the result of any '``landingpad``' instruction in the same
3389 The '``resume``' instruction resumes propagation of an existing
3391 :ref:`landingpad <i_landingpad>` instruction.
3402 '``unreachable``' Instruction
3415 The '``unreachable``' instruction has no defined semantics. This
3416 instruction is used to inform the optimizer that a particular portion of
3423 The '``unreachable``' instruction has no defined semantics.
3440 '``add``' Instruction
3456 The '``add``' instruction returns the sum of its two operands.
3461 The two arguments to the '``add``' instruction must be
3475 instruction is appropriate for both signed and unsigned integers.
3491 '``fadd``' Instruction
3504 The '``fadd``' instruction returns the sum of its two operands.
3509 The two arguments to the '``fadd``' instruction must be :ref:`floating
3517 instruction can also take any number of :ref:`fast-math flags <fastmath>`,
3528 '``sub``' Instruction
3544 The '``sub``' instruction returns the difference of its two operands.
3546 Note that the '``sub``' instruction is used to represent the '``neg``'
3547 instruction present in most other intermediate representations.
3552 The two arguments to the '``sub``' instruction must be
3566 instruction is appropriate for both signed and unsigned integers.
3583 '``fsub``' Instruction
3596 The '``fsub``' instruction returns the difference of its two operands.
3598 Note that the '``fsub``' instruction is used to represent the '``fneg``'
3599 instruction present in most other intermediate representations.
3604 The two arguments to the '``fsub``' instruction must be :ref:`floating
3612 This instruction can also take any number of :ref:`fast-math
3624 '``mul``' Instruction
3640 The '``mul``' instruction returns the product of its two operands.
3645 The two arguments to the '``mul``' instruction must be
3659 result is the same width as the operands, this instruction returns the
3679 '``fmul``' Instruction
3692 The '``fmul``' instruction returns the product of its two operands.
3697 The two arguments to the '``fmul``' instruction must be :ref:`floating
3705 This instruction can also take any number of :ref:`fast-math
3716 '``udiv``' Instruction
3730 The '``udiv``' instruction returns the quotient of its two operands.
3735 The two arguments to the '``udiv``' instruction must be
3760 '``sdiv``' Instruction
3774 The '``sdiv``' instruction returns the quotient of its two operands.
3779 The two arguments to the '``sdiv``' instruction must be
3808 '``fdiv``' Instruction
3821 The '``fdiv``' instruction returns the quotient of its two operands.
3826 The two arguments to the '``fdiv``' instruction must be :ref:`floating
3834 This instruction can also take any number of :ref:`fast-math
3845 '``urem``' Instruction
3858 The '``urem``' instruction returns the remainder from the unsigned
3864 The two arguments to the '``urem``' instruction must be
3871 This instruction returns the unsigned integer *remainder* of a division.
3872 This instruction always performs an unsigned division to get the
3887 '``srem``' Instruction
3900 The '``srem``' instruction returns the remainder from the signed
3901 division of its two operands. This instruction can also take
3908 The two arguments to the '``srem``' instruction must be
3915 This instruction returns the *remainder* of a division (where the result
3944 '``frem``' Instruction
3957 The '``frem``' instruction returns the remainder from the division of
3963 The two arguments to the '``frem``' instruction must be :ref:`floating
3970 This instruction returns the *remainder* of a division. The remainder
3971 has the same sign as the dividend. This instruction can also take any
3993 '``shl``' Instruction
4009 The '``shl``' instruction returns the first operand shifted to the left
4015 Both arguments to the '``shl``' instruction must be the same
4034 would if the shift were expressed as a mul instruction with the same
4048 '``lshr``' Instruction
4062 The '``lshr``' instruction (logical shift right) returns the first
4068 Both arguments to the '``lshr``' instruction must be the same
4075 This instruction always performs a logical shift right operation. The
4098 '``ashr``' Instruction
4112 The '``ashr``' instruction (arithmetic shift right) returns the first
4119 Both arguments to the '``ashr``' instruction must be the same
4126 This instruction always performs an arithmetic shift right operation,
4149 '``and``' Instruction
4162 The '``and``' instruction returns the bitwise logical and of its two
4168 The two arguments to the '``and``' instruction must be
4175 The truth table used for the '``and``' instruction is:
4198 '``or``' Instruction
4211 The '``or``' instruction returns the bitwise logical inclusive or of its
4217 The two arguments to the '``or``' instruction must be
4224 The truth table used for the '``or``' instruction is:
4247 '``xor``' Instruction
4260 The '``xor``' instruction returns the bitwise logical exclusive or of
4267 The two arguments to the '``xor``' instruction must be
4274 The truth table used for the '``xor``' instruction is:
4310 '``extractelement``' Instruction
4323 The '``extractelement``' instruction extracts a single scalar element
4329 The first operand of an '``extractelement``' instruction is a value of
4350 '``insertelement``' Instruction
4363 The '``insertelement``' instruction inserts a scalar element into a
4369 The first operand of an '``insertelement``' instruction is a value of
4392 '``shufflevector``' Instruction
4405 The '``shufflevector``' instruction constructs a permutation of elements
4412 The first two operands of a '``shufflevector``' instruction are vectors
4414 type is always 'i32'. The result of the instruction is a vector whose
4453 '``extractvalue``' Instruction
4466 The '``extractvalue``' instruction extracts the value of a member field
4472 The first operand of an '``extractvalue``' instruction is a value of
4475 as indices in a '``getelementptr``' instruction.
4499 '``insertvalue``' Instruction
4512 The '``insertvalue``' instruction inserts a value into a member field in
4518 The first operand of an '``insertvalue``' instruction is a value of
4522 similar manner as indices in a '``extractvalue``' instruction. The value
4554 '``alloca``' Instruction
4567 The '``alloca``' instruction allocates memory on the stack frame of the
4575 The '``alloca``' instruction allocates ``sizeof(<type>)*NumElements``
4592 '``alloca``' instruction is commonly used to represent automatic
4611 '``load``' Instruction
4626 The '``load``' instruction is used to read from memory.
4631 The argument to the ``load`` instruction specifies the memory address
4661 metadata on the instruction tells the optimizer and code generator
4664 as the ``MOVNT`` instruction on x86.
4669 instruction tells the optimizer and code generator that this load
4696 '``store``' Instruction
4710 The '``store``' instruction is used to write to memory.
4715 There are two arguments to the ``store`` instruction: a value to store
4746 value 1. The existence of the ``!nontemporal`` metadata on the instruction
4749 instructions to save cache bandwidth, such as the MOVNT instruction on
4775 '``fence``' Instruction
4788 The '``fence``' instruction is used to introduce happens-before edges
4831 '``cmpxchg``' Instruction
4844 The '``cmpxchg``' instruction is used to atomically modify memory. It
4851 There are three arguments to the '``cmpxchg``' instruction: an address
4881 A successful ``cmpxchg`` is a read-modify-write instruction for the purpose
4907 '``atomicrmw``' Instruction
4920 The '``atomicrmw``' instruction is used to atomically modify memory.
4925 There are three arguments to the '``atomicrmw``' instruction: an
4980 '``getelementptr``' Instruction
4995 The '``getelementptr``' instruction is used to get the address of a
5066 type. The '``getelementptr``' instruction returns a pointer to this
5105 The getelementptr instruction is often confusing. For some more insight
5136 '``trunc .. to``' Instruction
5149 The '``trunc``' instruction truncates its operand to the type ``ty2``.
5154 The '``trunc``' instruction takes a value to trunc, and a type to trunc
5163 The '``trunc``' instruction truncates the high order bits in ``value``
5178 '``zext .. to``' Instruction
5191 The '``zext``' instruction zero extends its operand to type ``ty2``.
5196 The '``zext``' instruction takes a value to cast, and a type to cast it
5218 '``sext .. to``' Instruction
5236 The '``sext``' instruction takes a value to cast, and a type to cast it
5244 The '``sext``' instruction performs a sign extension by copying the sign
5259 '``fptrunc .. to``' Instruction
5272 The '``fptrunc``' instruction truncates ``value`` to type ``ty2``.
5277 The '``fptrunc``' instruction takes a :ref:`floating point <t_floating>`
5285 The '``fptrunc``' instruction truncates a ``value`` from a larger
5298 '``fpext .. to``' Instruction
5317 The '``fpext``' instruction takes a :ref:`floating point <t_floating>`
5324 The '``fpext``' instruction extends the ``value`` from a smaller
5338 '``fptoui .. to``' Instruction
5357 The '``fptoui``' instruction takes a value to cast, which must be a
5366 The '``fptoui``' instruction converts its :ref:`floating
5380 '``fptosi .. to``' Instruction
5393 The '``fptosi``' instruction converts :ref:`floating point <t_floating>`
5399 The '``fptosi``' instruction takes a value to cast, which must be a
5408 The '``fptosi``' instruction converts its :ref:`floating
5422 '``uitofp .. to``' Instruction
5435 The '``uitofp``' instruction regards ``value`` as an unsigned integer
5441 The '``uitofp``' instruction takes a value to cast, which must be a
5450 The '``uitofp``' instruction interprets its operand as an unsigned
5463 '``sitofp .. to``' Instruction
5476 The '``sitofp``' instruction regards ``value`` as a signed integer and
5482 The '``sitofp``' instruction takes a value to cast, which must be a
5491 The '``sitofp``' instruction interprets its operand as a signed integer
5506 '``ptrtoint .. to``' Instruction
5519 The '``ptrtoint``' instruction converts the pointer or a vector of
5525 The '``ptrtoint``' instruction takes a ``value`` to cast, which must be
5533 The '``ptrtoint``' instruction converts ``value`` to integer type
5552 '``inttoptr .. to``' Instruction
5565 The '``inttoptr``' instruction converts an integer ``value`` to a
5571 The '``inttoptr``' instruction takes an :ref:`integer <t_integer>` value to
5578 The '``inttoptr``' instruction converts ``value`` to type ``ty2`` by
5597 '``bitcast .. to``' Instruction
5610 The '``bitcast``' instruction converts ``value`` to type ``ty2`` without
5616 The '``bitcast``' instruction takes a value to cast, which must be a
5621 also be a pointer of the same size. This instruction supports bitwise
5628 The '``bitcast``' instruction converts ``value`` to type ``ty2``. It
5633 pointers) types with this instruction if the pointer sizes are
5657 '``icmp``' Instruction
5670 The '``icmp``' instruction returns a boolean value or a vector of
5677 The '``icmp``' instruction takes three operands. The first operand is
5744 ``icmp`` instruction.
5748 '``fcmp``' Instruction
5761 The '``fcmp``' instruction returns a boolean value or vector of boolean
5774 The '``fcmp``' instruction takes three operands. The first operand is
5805 The '``fcmp``' instruction compares ``op1`` and ``op2`` according to the
5850 ``fcmp`` instruction.
5854 '``phi``' Instruction
5867 The '``phi``' instruction is used to implement the ? node in the SSA
5874 After this, the '``phi``' instruction takes a list of pairs as
5887 instruction's return value on the same edge).
5892 At runtime, the '``phi``' instruction logically takes on the value
5908 '``select``' Instruction
5923 The '``select``' instruction is used to choose one value based on a
5929 The '``select``' instruction requires an 'i1' value or a vector of 'i1'
5938 If the condition is an i1 and it evaluates to 1, the instruction returns
5954 '``call``' Instruction
5967 The '``call``' instruction represents a simple function call.
5972 This instruction requires several arguments:
5977 :ref:`ret <i_ret>` instruction. If the "tail" marker is present, the
6002 #. '``ty``': the type of the call instruction itself which is also the
6026 The '``call``' instruction is used to cause control flow to transfer to
6028 values. Upon a '``ret``' instruction in the called function, control
6029 flow continues with the instruction after the function call, and the
6058 '``va_arg``' Instruction
6071 The '``va_arg``' instruction is used to access arguments passed through
6078 This instruction takes a ``va_list*`` value and the type of the
6086 The '``va_arg``' instruction loads an argument of the specified type
6091 It is legal for this instruction to be called in a function which does
6095 ``va_arg`` is an LLVM instruction instead of an :ref:`intrinsic
6109 '``landingpad``' Instruction
6126 The '``landingpad``' instruction is used by `LLVM's exception handling
6136 This instruction takes a ``pers_fn`` value. This is the personality
6145 '``landingpad``' instruction must contain *at least* one ``clause`` or
6151 The '``landingpad``' instruction defines the values which are set by the
6153 therefore the "result type" of the ``landingpad`` instruction. As with
6165 The ``landingpad`` instruction has several restrictions:
6168 of an '``invoke``' instruction.
6169 - A landing pad block must have a '``landingpad``' instruction as its
6170 first non-PHI instruction.
6171 - There can be only one '``landingpad``' instruction within the landing
6174 '``landingpad``' instruction.
6248 :ref:`va_arg <i_va_arg>` instruction and these three intrinsic
6257 This example shows how the :ref:`va_arg <i_va_arg>` instruction and the
6466 instruction, but may be replaced with substantially more complex code by
6502 instruction, but may be replaced with substantially more complex code by
6660 insert a prefetch instruction if supported; otherwise, it is a noop.
6672 instruction (0) cache. The ``rw``, ``locality`` and ``cache type``
6700 guarantees that it will remain with any specific instruction after
8025 target instruction set has support for a fused operation, and (b) that the
8543 This intrinsic is lowered to the target dependent trap instruction. If
8544 the target does not have a trap instruction, this intrinsic will be
8691 only intrinsic that can be called with an invoke instruction.
