Instructions

Instruction

An instruction in the LLVM IR.

copy(inst::Instruction)

Create a copy of the given instruction.

remove!(inst::Instruction)

Remove the given instruction from the containing basic block, but do not delete the object.

erase!(inst::Instruction)

Remove the given instruction from the containing basic block and delete the object.

parent(inst::Instruction)

Get the basic block that contains the given instruction.

IRBuilder

An instruction builder, which is used to build instructions within a basic block.

IRBuilder()

Create a new, unpositioned instruction builder.

This object needs to be disposed of using dispose.

dispose(builder::IRBuilder)

Dispose of an instruction builder.

context(builder::IRBuilder)

Get the context associated with an instruction builder.

position(builder::IRBuilder)

Return the current position of the instruction builder.

position!(builder::IRBuilder, inst::Instruction)

Position the instruction builder before the given instruction.

position!(builder::IRBuilder, bb::BasicBlock)

Position the instruction builder at the end of the given basic block.

position!(builder::IRBuilder)

Clear the current position of the instruction builder.

insert!(builder::IRBuilder, inst::Instruction, [name::String])

Insert an instruction into the current basic block at the current position, optionally giving it a name.

debuglocation(builder::IRBuilder)

Get the current debug location of the instruction builder, or nothing if no location is set.

debuglocation!(builder::IRBuilder)

Clear the current debug location of the instruction builder.

debuglocation!(builder::IRBuilder, loc)

Set the current debug location of the instruction builder to loc, which can be a Metadata or MetadataAsValue.

debuglocation!(builder::IRBuilder, inst::Instruction)

Set the current debug location of the instruction builder to the location of the given instruction.

function_attributes(instr::CallBase)

Get the attributes of the given instruction.

This is a mutable iterator, supporting push!, append! and delete!.

argument_attributes(instr::CallBase, idx::Integer)

Get the attributes of the given argument of the given instruction.

This is a mutable iterator, supporting push!, append! and delete!.

return_attributes(instr::CallBase)

Get the attributes of the return value of the given instruction.

This is a mutable iterator, supporting push!, append! and delete!.

predicate(inst::ICmpInst)
predicate(inst::FCmpInst)

Get the comparison predicate of the given integer or floating-point comparison instruction.

is_atomic(inst::Instruction)

Check if the given instruction is atomic. This includes atomic operations such as atomicrmw or fence, but also loads and stores that have been made atomic by setting an atomic ordering.

ordering(atomic_inst::Instruction)

Get the atomic ordering of the given atomic instruction.

ordering!(inst::Instruction, ordering::LLVM.AtomicOrdering)

Set the atomic ordering of the given instruction.

SyncScope

A synchronization scope for atomic operations.

syncscope(inst::AtomicInst)

Get the synchronization scope of the given atomic instruction.

syncscope!(inst::AtomicInst, scope::SyncScope)

Set the synchronization scope of the given atomic instruction.

binop(inst::AtomicRMWInst)

Get the binary operation of the given atomic read-modify-write instruction.

isweak(inst::AtomicCmpXchgInst)

Check if the given atomic compare-and-exchange instruction is weak.

weak!(inst::AtomicCmpXchgInst, is_weak::Bool)

Set whether the given atomic compare-and-exchange instruction is weak.

success_ordering(inst::AtomicCmpXchgInst)

Get the success ordering of the given atomic compare-and-exchange instruction.

success_ordering!(inst::AtomicCmpXchgInst, ord::API.LLVMAtomicOrdering)

Set the success ordering of the given atomic compare-and-exchange instruction.

failure_ordering(inst::AtomicCmpXchgInst)

Get the failure ordering of the given atomic compare-and-exchange instruction.

failure_ordering!(inst::AtomicCmpXchgInst, ord::API.LLVMAtomicOrdering)

Set the failure ordering of the given atomic compare-and-exchange instruction.

callconv(call_inst::Instruction)

Get the calling convention of the given callable instruction.

callconv!(call_inst::Instruction, cc)

Set the calling convention of the given callable instruction.

istailcall(call_inst::Instruction)

Tests if this call site must be tail call optimized.

tailcall!(call_inst::Instruction, is_tail::Bool)

Sets whether this call site must be tail call optimized.

called_operand(call_inst::Instruction)

Get the operand of a callable instruction that represents the called function.

arguments(call_inst::Instruction)

Get the arguments of a callable instruction.

called_type(call_inst::Instruction)

Get the type of the function being called by the given callable instruction.

OperandBundle

An operand bundle attached to a call site.

operand_bundles(call_inst::Instruction)

Get the operand bundles attached to the given call instruction.

tag(bundle::OperandBundle)

Get the tag of the given operand bundle.

inputs(bundle::OperandBundle)

Get an iterator over the inputs of the given operand bundle.

isterminator(inst::Instruction)

Check if the given instruction is a terminator instruction.

isconditional(br::BrInst)

Check if the given branch instruction is conditional.

condition(br::BrInst)

Get the condition of the given branch instruction.

condition!(br::BrInst, cond::Value)

Set the condition of the given branch instruction.

default_dest(switch::SwitchInst)

Get the default destination of the given switch instruction.

successors(term::Instruction)

Get an iterator over the successors of the given terminator instruction.

This is a mutable iterator, so you can modify the successors of the terminator by calling setindex!.

incoming(phi::PhiInst)

Get an iterator over the incoming values of the given phi node.

This is a mutable iterator, so you can modify the incoming values of the phi node by calling push! or append!, passing a tuple of the incoming value and the originating basic block.

fast_math(inst::Instruction)

Get the fast math flags on an instruction.

fast_math!(inst::Instruction; [flag=...], [all=...])

Set the fast math flags on an instruction. If all is true, then all flags are set.

The following flags are supported:

• nnan: assume arguments and results are not NaN
• ninf: assume arguments and results are not Inf
• nsz: treat the sign of zero arguments and results as insignificant
• arcp: allow use of reciprocal rather than perform division
• contract: allow contraction of operations
• afn: allow substitution of approximate calculations for functions
• reassoc: allow reassociation of operations

alignment(gv::GlobalVariable)

Get the alignment of the global variable.

alignment(val::Instruction)

Get the alignment of the instruction.

alignment!(gv::GlobalVariable, bytes::Integer)

Set the alignment of the global variable.

alignment!(val::Instruction, bytes::Integer)

Set the alignment of the instruction.