Documentation ¶
Overview ¶
Package ir declares the types used to represent LLVM IR modules.
Example ¶
package main import ( "fmt" "github.com/llir/llvm/ir" "github.com/llir/llvm/ir/constant" "github.com/llir/llvm/ir/types" ) func main() { // This example produces LLVM IR code equivalent to the following C code, // which implements a pseudo-random number generator. // // int abs(int x); // // int seed = 0; // // // ref: https://en.wikipedia.org/wiki/Linear_congruential_generator // // a = 0x15A4E35 // // c = 1 // int rand(void) { // seed = seed*0x15A4E35 + 1; // return abs(seed); // } // Create convenience types and constants. i32 := types.I32 zero := constant.NewInt(i32, 0) a := constant.NewInt(i32, 0x15A4E35) // multiplier of the PRNG. c := constant.NewInt(i32, 1) // increment of the PRNG. // Create a new LLVM IR module. m := ir.NewModule() // Create an external function declaration and append it to the module. // // int abs(int x); abs := m.NewFunc("abs", i32, ir.NewParam("x", i32)) // Create a global variable definition and append it to the module. // // int seed = 0; seed := m.NewGlobalDef("seed", zero) // Create a function definition and append it to the module. // // int rand(void) { ... } rand := m.NewFunc("rand", i32) // Create an unnamed entry basic block and append it to the `rand` function. entry := rand.NewBlock("") // Create instructions and append them to the entry basic block. tmp1 := entry.NewLoad(types.I32, seed) tmp2 := entry.NewMul(tmp1, a) tmp3 := entry.NewAdd(tmp2, c) entry.NewStore(tmp3, seed) tmp4 := entry.NewCall(abs, tmp3) entry.NewRet(tmp4) // Print the LLVM IR assembly of the module. fmt.Println(m) }
Output: @seed = global i32 0 declare i32 @abs(i32 %x) define i32 @rand() { 0: %1 = load i32, i32* @seed %2 = mul i32 %1, 22695477 %3 = add i32 %2, 1 store i32 %3, i32* @seed %4 = call i32 @abs(i32 %3) ret i32 %4 }
Example (Callgraph) ¶
// This example program analyses an LLVM IR module to produce a callgraph in // Graphviz DOT format. package main import ( "fmt" "strings" "github.com/llir/llvm/asm" "github.com/llir/llvm/ir" ) func main() { // Parse LLVM IR assembly file. m, err := asm.ParseFile("testdata/eval.ll") if err != nil { panic(err) } // Produce callgraph of module. callgraph := genCallgraph(m) // Output callgraph in Graphviz DOT format. fmt.Println(callgraph) } // genCallgraph returns the callgraph in Graphviz DOT format of the given LLVM // IR module. func genCallgraph(m *ir.Module) string { buf := &strings.Builder{} buf.WriteString("digraph {\n") // For each function of the module. for _, f := range m.Funcs { // Add caller node. caller := f.Ident() fmt.Fprintf(buf, "\t%q\n", caller) // For each basic block of the function. for _, block := range f.Blocks { // For each non-branching instruction of the basic block. for _, inst := range block.Insts { // Type switch on instruction to find call instructions. switch inst := inst.(type) { case *ir.InstCall: callee := inst.Callee.Ident() // Add edges from caller to callee. fmt.Fprintf(buf, "\t%q -> %q\n", caller, callee) } } // Terminator of basic block. switch term := block.Term.(type) { case *ir.TermRet: // do something. _ = term } } } buf.WriteString("}") return buf.String() }
Output: digraph { "@add" "@sub" "@f" "@f" -> "@printf" "@main" "@main" -> "@add" "@main" -> "@sub" "@main" -> "@f" "@printf" }
Example (Evaluator) ¶
// This example program parses testdata/eval.ll, evaluates the return value of // the @main function and prints the result to standard output. The result // should be 42. package main import ( "fmt" "log" "github.com/llir/llvm/asm" "github.com/llir/llvm/ir" "github.com/llir/llvm/ir/constant" "github.com/llir/llvm/ir/types" "github.com/llir/llvm/ir/value" ) func main() { // Parse the LLVM IR assembly file `eval.ll`. m, err := asm.ParseFile("testdata/eval.ll") if err != nil { log.Fatalf("%+v", err) } // Evalute and print the return value of the `@main` function. for _, f := range m.Funcs { if f.Name() == "main" { e := newEvaluator(f) fmt.Println("result:", e.eval()) break } } } // evaluator is a function evaluator. type evaluator struct { // Function being evaluated. f *ir.Func // Function arguments. args []value.Value } // newEvaluator returns a new function evaluator, for evaluating the result of // invoking f with args. func newEvaluator(f *ir.Func, args ...value.Value) *evaluator { return &evaluator{f: f, args: args} } // eval evalutes f and returns the corresponding 32-bit integer. func (e *evaluator) eval() uint32 { f := e.f if !types.Equal(f.Sig.RetType, types.I32) { panic(fmt.Errorf("support for function return type %s not yet implemented", f.Sig.RetType)) } for _, block := range f.Blocks { switch term := block.Term.(type) { case *ir.TermRet: // Note: support for functions with more than one ret terminator not // yet implemented. if term.X != nil { // The result of the first return value of a function is evaluated. return e.evalValue(term.X) } } } panic(fmt.Errorf("unable to locate ret terminator in function %q", f.Ident())) } // evalInst evaluates inst and returns the corresponding 32-bit integer. func (e *evaluator) evalInst(inst ir.Instruction) uint32 { switch inst := inst.(type) { // Binary instructions. case *ir.InstAdd: return e.evalValue(inst.X) + e.evalValue(inst.Y) case *ir.InstSub: return e.evalValue(inst.X) - e.evalValue(inst.Y) case *ir.InstMul: return e.evalValue(inst.X) * e.evalValue(inst.Y) case *ir.InstUDiv: return e.evalValue(inst.X) / e.evalValue(inst.Y) case *ir.InstSDiv: return e.evalValue(inst.X) / e.evalValue(inst.Y) case *ir.InstURem: return e.evalValue(inst.X) % e.evalValue(inst.Y) case *ir.InstSRem: return e.evalValue(inst.X) % e.evalValue(inst.Y) // Bitwise instructions. case *ir.InstShl: return e.evalValue(inst.X) << e.evalValue(inst.Y) case *ir.InstLShr: return e.evalValue(inst.X) >> e.evalValue(inst.Y) case *ir.InstAShr: x, y := e.evalValue(inst.X), e.evalValue(inst.Y) result := x >> y // sign extend. if x&0x80000000 != 0 { result = signExt(result) } return result case *ir.InstAnd: return e.evalValue(inst.X) & e.evalValue(inst.Y) case *ir.InstOr: return e.evalValue(inst.X) | e.evalValue(inst.Y) case *ir.InstXor: return e.evalValue(inst.X) ^ e.evalValue(inst.Y) // Other instructions. case *ir.InstCall: callee, ok := inst.Callee.(*ir.Func) if !ok { panic(fmt.Errorf("support for callee type %T not yet implemented", inst.Callee)) } ee := newEvaluator(callee, inst.Args...) return ee.eval() default: panic(fmt.Errorf("support for instruction type %T not yet implemented", inst)) } } // evalValue evalutes v and returns the corresponding 32-bit integer. func (e *evaluator) evalValue(v value.Value) uint32 { switch v := v.(type) { case ir.Instruction: return e.evalInst(v) case *constant.Int: return uint32(v.X.Int64()) case *ir.Param: f := e.f for i, param := range f.Params { if v.Ident() == param.Ident() { return e.evalValue(e.args[i]) } } panic(fmt.Errorf("unable to locate paramater %q of function %q", v.Ident(), f.Ident())) default: panic(fmt.Errorf("support for value type %T not yet implemented", v)) } } // signExt sign extends x. func signExt(x uint32) uint32 { for i := uint32(31); i >= 0; i-- { mask := uint32(1 << i) if x&mask != 0 { break } x |= mask } return x }
Output: result: 42
Example (Main) ¶
package main import ( "fmt" "github.com/llir/llvm/ir" "github.com/llir/llvm/ir/constant" "github.com/llir/llvm/ir/types" ) func main() { // This example produces LLVM IR code equivalent to the following C code: // // int main() { // int a = 32; // int b = 16; // return a + b; // } // // Read: https://blog.felixangell.com/an-introduction-to-llvm-in-go for inspiration. // Create convenience types. i32 := types.I32 // Create a new LLVM IR module. m := ir.NewModule() // int main() { ... } main := m.NewFunc("main", i32) // Create an unnamed entry basic block and append it to the `main` function. entry := main.NewBlock("") // Create instructions and append them to the entry basic block. // %a = alloca i32 a := entry.NewAlloca(i32) a.SetName("a") // %b = alloca i32 b := entry.NewAlloca(i32) b.SetName("b") // store i32 32, i32* %a entry.NewStore(constant.NewInt(i32, 32), a) // store i32 16, i32* %b entry.NewStore(constant.NewInt(i32, 16), b) // %1 = load i32, i32* %a tmpA := entry.NewLoad(types.I32, a) // %2 = load i32, i32* %b tmpB := entry.NewLoad(types.I32, b) // %3 = add nsw i32 %1, %2 tmpC := entry.NewAdd(tmpA, tmpB) // ret i32 %3 entry.NewRet(tmpC) // Print the LLVM IR assembly of the module. fmt.Println(m) }
Output: define i32 @main() { 0: %a = alloca i32 %b = alloca i32 store i32 32, i32* %a store i32 16, i32* %b %1 = load i32, i32* %a %2 = load i32, i32* %b %3 = add i32 %1, %2 ret i32 %3 }
Index ¶
- type Alias
- type Align
- type AlignStack
- type AllocSize
- type Arg
- type AttrGroupDef
- type AttrPair
- type AttrString
- type Block
- func (block *Block) LLString() string
- func (block *Block) NewAShr(x, y value.Value) *InstAShr
- func (block *Block) NewAdd(x, y value.Value) *InstAdd
- func (block *Block) NewAddrSpaceCast(from value.Value, to types.Type) *InstAddrSpaceCast
- func (block *Block) NewAlloca(elemType types.Type) *InstAlloca
- func (block *Block) NewAnd(x, y value.Value) *InstAnd
- func (block *Block) NewAtomicRMW(op enum.AtomicOp, dst, x value.Value, ordering enum.AtomicOrdering) *InstAtomicRMW
- func (block *Block) NewBitCast(from value.Value, to types.Type) *InstBitCast
- func (block *Block) NewBr(target *Block) *TermBr
- func (block *Block) NewCall(callee value.Value, args ...value.Value) *InstCall
- func (block *Block) NewCallBr(callee value.Value, args []value.Value, normalRetTarget *Block, ...) *TermCallBr
- func (block *Block) NewCatchPad(catchSwitch *TermCatchSwitch, args ...value.Value) *InstCatchPad
- func (block *Block) NewCatchRet(catchPad *InstCatchPad, target *Block) *TermCatchRet
- func (block *Block) NewCatchSwitch(parentPad ExceptionPad, handlers []*Block, defaultUnwindTarget *Block) *TermCatchSwitch
- func (block *Block) NewCleanupPad(parentPad ExceptionPad, args ...value.Value) *InstCleanupPad
- func (block *Block) NewCleanupRet(cleanupPad *InstCleanupPad, unwindTarget *Block) *TermCleanupRet
- func (block *Block) NewCmpXchg(ptr, cmp, new value.Value, ...) *InstCmpXchg
- func (block *Block) NewCondBr(cond value.Value, targetTrue, targetFalse *Block) *TermCondBr
- func (block *Block) NewExtractElement(x, index value.Value) *InstExtractElement
- func (block *Block) NewExtractValue(x value.Value, indices ...uint64) *InstExtractValue
- func (block *Block) NewFAdd(x, y value.Value) *InstFAdd
- func (block *Block) NewFCmp(pred enum.FPred, x, y value.Value) *InstFCmp
- func (block *Block) NewFDiv(x, y value.Value) *InstFDiv
- func (block *Block) NewFMul(x, y value.Value) *InstFMul
- func (block *Block) NewFNeg(x value.Value) *InstFNeg
- func (block *Block) NewFPExt(from value.Value, to types.Type) *InstFPExt
- func (block *Block) NewFPToSI(from value.Value, to types.Type) *InstFPToSI
- func (block *Block) NewFPToUI(from value.Value, to types.Type) *InstFPToUI
- func (block *Block) NewFPTrunc(from value.Value, to types.Type) *InstFPTrunc
- func (block *Block) NewFRem(x, y value.Value) *InstFRem
- func (block *Block) NewFSub(x, y value.Value) *InstFSub
- func (block *Block) NewFence(ordering enum.AtomicOrdering) *InstFence
- func (block *Block) NewGetElementPtr(elemType types.Type, src value.Value, indices ...value.Value) *InstGetElementPtr
- func (block *Block) NewICmp(pred enum.IPred, x, y value.Value) *InstICmp
- func (block *Block) NewIndirectBr(addr value.Value, validTargets ...*Block) *TermIndirectBr
- func (block *Block) NewInsertElement(x, elem, index value.Value) *InstInsertElement
- func (block *Block) NewInsertValue(x, elem value.Value, indices ...uint64) *InstInsertValue
- func (block *Block) NewIntToPtr(from value.Value, to types.Type) *InstIntToPtr
- func (block *Block) NewInvoke(invokee value.Value, args []value.Value, ...) *TermInvoke
- func (block *Block) NewLShr(x, y value.Value) *InstLShr
- func (block *Block) NewLandingPad(resultType types.Type, clauses ...*Clause) *InstLandingPad
- func (block *Block) NewLoad(elemType types.Type, src value.Value) *InstLoad
- func (block *Block) NewMul(x, y value.Value) *InstMul
- func (block *Block) NewOr(x, y value.Value) *InstOr
- func (block *Block) NewPhi(incs ...*Incoming) *InstPhi
- func (block *Block) NewPtrToInt(from value.Value, to types.Type) *InstPtrToInt
- func (block *Block) NewResume(x value.Value) *TermResume
- func (block *Block) NewRet(x value.Value) *TermRet
- func (block *Block) NewSDiv(x, y value.Value) *InstSDiv
- func (block *Block) NewSExt(from value.Value, to types.Type) *InstSExt
- func (block *Block) NewSIToFP(from value.Value, to types.Type) *InstSIToFP
- func (block *Block) NewSRem(x, y value.Value) *InstSRem
- func (block *Block) NewSelect(cond, valueTrue, valueFalse value.Value) *InstSelect
- func (block *Block) NewShl(x, y value.Value) *InstShl
- func (block *Block) NewShuffleVector(x, y, mask value.Value) *InstShuffleVector
- func (block *Block) NewStore(src, dst value.Value) *InstStore
- func (block *Block) NewSub(x, y value.Value) *InstSub
- func (block *Block) NewSwitch(x value.Value, targetDefault *Block, cases ...*Case) *TermSwitch
- func (block *Block) NewTrunc(from value.Value, to types.Type) *InstTrunc
- func (block *Block) NewUDiv(x, y value.Value) *InstUDiv
- func (block *Block) NewUIToFP(from value.Value, to types.Type) *InstUIToFP
- func (block *Block) NewURem(x, y value.Value) *InstURem
- func (block *Block) NewUnreachable() *TermUnreachable
- func (block *Block) NewVAArg(vaList value.Value, argType types.Type) *InstVAArg
- func (block *Block) NewXor(x, y value.Value) *InstXor
- func (block *Block) NewZExt(from value.Value, to types.Type) *InstZExt
- func (block *Block) String() string
- func (block *Block) Type() types.Type
- type ByRef
- type Byval
- type Case
- type Clause
- type ComdatDef
- type Dereferenceable
- type ElementType
- type ExceptionPad
- type Func
- type FuncAttribute
- type Global
- type GlobalIdent
- type IFunc
- type InAlloca
- type Incoming
- type InlineAsm
- type InstAShr
- type InstAdd
- type InstAddrSpaceCast
- type InstAlloca
- type InstAnd
- type InstAtomicRMW
- type InstBitCast
- type InstCall
- type InstCatchPad
- type InstCleanupPad
- type InstCmpXchg
- type InstExtractElement
- type InstExtractValue
- type InstFAdd
- type InstFCmp
- type InstFDiv
- type InstFMul
- type InstFNeg
- type InstFPExt
- type InstFPToSI
- type InstFPToUI
- type InstFPTrunc
- type InstFRem
- type InstFSub
- type InstFence
- type InstFreeze
- type InstGetElementPtr
- type InstICmp
- type InstInsertElement
- type InstInsertValue
- type InstIntToPtr
- type InstLShr
- type InstLandingPad
- type InstLoad
- type InstMul
- type InstOr
- type InstPhi
- type InstPtrToInt
- type InstSDiv
- type InstSExt
- type InstSIToFP
- type InstSRem
- type InstSelect
- type InstShl
- type InstShuffleVector
- type InstStore
- type InstSub
- type InstTrunc
- type InstUDiv
- type InstUIToFP
- type InstURem
- type InstVAArg
- type InstXor
- type InstZExt
- type Instruction
- type LLStringer
- type LocalIdent
- type Metadata
- type Module
- func (m *Module) AssignGlobalIDs() error
- func (m *Module) AssignMetadataIDs() error
- func (m *Module) NewAlias(name string, aliasee constant.Constant) *Alias
- func (m *Module) NewFunc(name string, retType types.Type, params ...*Param) *Func
- func (m *Module) NewGlobal(name string, contentType types.Type) *Global
- func (m *Module) NewGlobalDef(name string, init constant.Constant) *Global
- func (m *Module) NewIFunc(name string, resolver constant.Constant) *IFunc
- func (m *Module) NewTypeDef(name string, typ types.Type) types.Type
- func (m *Module) String() string
- func (m *Module) WriteTo(w io.Writer) (n int64, err error)
- type OperandBundle
- type Param
- type ParamAttribute
- type Preallocated
- type ReturnAttribute
- type SRet
- type TermBr
- type TermCallBr
- type TermCatchRet
- type TermCatchSwitch
- type TermCleanupRet
- type TermCondBr
- type TermIndirectBr
- type TermInvoke
- type TermResume
- type TermRet
- type TermSwitch
- type TermUnreachable
- type Terminator
- type UseListOrder
- type UseListOrderBB
- type VectorScaleRange
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type Alias ¶
type Alias struct { // Alias name (without '@' prefix). GlobalIdent // Aliasee. Aliasee constant.Constant // Pointer type of aliasee. Typ *types.PointerType // (optional) Linkage; zero value if not present. Linkage enum.Linkage // (optional) Preemption; zero value if not present. Preemption enum.Preemption // (optional) Visibility; zero value if not present. Visibility enum.Visibility // (optional) DLL storage class; zero value if not present. DLLStorageClass enum.DLLStorageClass // (optional) Thread local storage model; zero value if not present. TLSModel enum.TLSModel // (optional) Unnamed address; zero value if not present. UnnamedAddr enum.UnnamedAddr // (optional) Partition name; empty if not present. Partition string }
Alias is an alias of a global identifier or constant expression.
func (*Alias) IsConstant ¶
func (*Alias) IsConstant()
IsConstant ensures that only constants can be assigned to the constant.Constant interface.
func (*Alias) LLString ¶
LLString returns the LLVM syntax representation of the alias definition.
Name=GlobalIdent '=' (ExternLinkage | Linkageopt) Preemptionopt Visibilityopt DLLStorageClassopt ThreadLocalopt UnnamedAddropt IndirectSymbolKind ContentType=Type ',' IndirectSymbol Partitions=(',' Partition)*
type Align ¶
type Align uint64
Align is a memory alignment attribute.
func (Align) IsFuncAttribute ¶
func (Align) IsFuncAttribute()
IsFuncAttribute ensures that only function attributes can be assigned to the ir.FuncAttribute interface.
func (Align) IsParamAttribute ¶
func (Align) IsParamAttribute()
IsParamAttribute ensures that only parameter attributes can be assigned to the ir.ParamAttribute interface.
func (Align) IsReturnAttribute ¶
func (Align) IsReturnAttribute()
IsReturnAttribute ensures that only return attributes can be assigned to the ir.ReturnAttribute interface.
type AlignStack ¶
type AlignStack uint64
AlignStack is a stack alignment attribute.
func (AlignStack) IsFuncAttribute ¶
func (AlignStack) IsFuncAttribute()
IsFuncAttribute ensures that only function attributes can be assigned to the ir.FuncAttribute interface.
func (AlignStack) IsParamAttribute ¶ added in v0.3.5
func (AlignStack) IsParamAttribute()
IsParamAttribute ensures that only parameter attributes can be assigned to the ir.ParamAttribute interface.
func (AlignStack) String ¶
func (align AlignStack) String() string
String returns the string representation of the stack alignment attribute.
type AllocSize ¶
type AllocSize struct { // Element size parameter index. ElemSizeIndex int // Number of elements parameter index; -1 if not present. NElemsIndex int }
AllocSize is an attribute for functions like malloc. If the second parameter is omitted, NElemsIndex will be -1.
func (AllocSize) IsFuncAttribute ¶
func (AllocSize) IsFuncAttribute()
IsFuncAttribute ensures that only function attributes can be assigned to the ir.FuncAttribute interface.
type Arg ¶
type Arg struct { // Argument value. value.Value // (optional) Parameter attributes. Attrs []ParamAttribute }
Arg is a function argument with optional parameter attributes.
type AttrGroupDef ¶
type AttrGroupDef struct { // Attribute group ID (without '#' prefix). ID int64 // Function attributes. FuncAttrs []FuncAttribute }
AttrGroupDef is an attribute group definition.
func (*AttrGroupDef) IsFuncAttribute ¶
func (*AttrGroupDef) IsFuncAttribute()
IsFuncAttribute ensures that only function attributes can be assigned to the ir.FuncAttribute interface.
func (*AttrGroupDef) LLString ¶
func (a *AttrGroupDef) LLString() string
LLString returns the LLVM syntax representation of the attribute group definition.
'attributes' ID=AttrGroupID '=' '{' FuncAttrs=FuncAttribute* '}'
func (*AttrGroupDef) String ¶
func (a *AttrGroupDef) String() string
String returns the string representation of the attribute group definition.
type AttrPair ¶
AttrPair is an attribute key-value pair (used in function, parameter and return attributes).
func (AttrPair) IsFuncAttribute ¶
func (AttrPair) IsFuncAttribute()
IsFuncAttribute ensures that only function attributes can be assigned to the ir.FuncAttribute interface.
func (AttrPair) IsParamAttribute ¶
func (AttrPair) IsParamAttribute()
IsParamAttribute ensures that only parameter attributes can be assigned to the ir.ParamAttribute interface.
func (AttrPair) IsReturnAttribute ¶
func (AttrPair) IsReturnAttribute()
IsReturnAttribute ensures that only return attributes can be assigned to the ir.ReturnAttribute interface.
type AttrString ¶
type AttrString string
AttrString is an attribute string (used in function, parameter and return attributes).
func (AttrString) IsFuncAttribute ¶
func (AttrString) IsFuncAttribute()
IsFuncAttribute ensures that only function attributes can be assigned to the ir.FuncAttribute interface.
func (AttrString) IsParamAttribute ¶
func (AttrString) IsParamAttribute()
IsParamAttribute ensures that only parameter attributes can be assigned to the ir.ParamAttribute interface.
func (AttrString) IsReturnAttribute ¶
func (AttrString) IsReturnAttribute()
IsReturnAttribute ensures that only return attributes can be assigned to the ir.ReturnAttribute interface.
func (AttrString) String ¶
func (a AttrString) String() string
String returns the string representation of the attribute string.
type Block ¶
type Block struct { // Name of local variable associated with the basic block. LocalIdent // Instructions of the basic block. Insts []Instruction // Terminator of the basic block. Term Terminator // Parent function; field set by ir.Func.NewBlock. Parent *Func `json:"-"` }
Block is an LLVM IR basic block; a sequence of non-branching instructions terminated by a control flow instruction (e.g. br or ret).
func NewBlock ¶
NewBlock returns a new basic block based on the given label name. An empty label name indicates an unnamed basic block.
func (*Block) LLString ¶
LLString returns the LLVM syntax representation of the basic block definition.
Name=LabelIdentopt Insts=Instruction* Term=Terminator
func (*Block) NewAShr ¶
NewAShr appends a new ashr instruction to the basic block based on the given operands.
func (*Block) NewAdd ¶
NewAdd appends a new add instruction to the basic block based on the given operands.
func (*Block) NewAddrSpaceCast ¶
NewAddrSpaceCast appends a new addrspacecast instruction to the basic block based on the given source value and target type.
func (*Block) NewAlloca ¶
func (block *Block) NewAlloca(elemType types.Type) *InstAlloca
NewAlloca appends a new alloca instruction to the basic block based on the given element type.
func (*Block) NewAnd ¶
NewAnd appends a new and instruction to the basic block based on the given operands.
func (*Block) NewAtomicRMW ¶
func (block *Block) NewAtomicRMW(op enum.AtomicOp, dst, x value.Value, ordering enum.AtomicOrdering) *InstAtomicRMW
NewAtomicRMW appends a new atomicrmw instruction to the basic block based on the given atomic operation, destination address, operand and atomic ordering.
func (*Block) NewBitCast ¶
NewBitCast appends a new bitcast instruction to the basic block based on the given source value and target type.
func (*Block) NewBr ¶
NewBr sets the terminator of the basic block to a new unconditional br terminator based on the given target basic block.
func (*Block) NewCall ¶
NewCall appends a new call instruction to the basic block based on the given callee and function arguments.
TODO: specify the set of underlying types of callee.
func (*Block) NewCallBr ¶
func (block *Block) NewCallBr(callee value.Value, args []value.Value, normalRetTarget *Block, otherRetTargets ...*Block) *TermCallBr
NewCallBr sets the terminator of the basic block to a new callbr terminator based on the given callee, function arguments and control flow return points for normal and exceptional execution.
TODO: specify the set of underlying types of callee.
func (*Block) NewCatchPad ¶
func (block *Block) NewCatchPad(catchSwitch *TermCatchSwitch, args ...value.Value) *InstCatchPad
NewCatchPad appends a new catchpad instruction to the basic block based on the given parent catchswitch terminator and exception arguments.
func (*Block) NewCatchRet ¶
func (block *Block) NewCatchRet(catchPad *InstCatchPad, target *Block) *TermCatchRet
NewCatchRet sets the terminator of the basic block to a new catchret terminator based on the given exit catchpad and target basic block.
func (*Block) NewCatchSwitch ¶
func (block *Block) NewCatchSwitch(parentPad ExceptionPad, handlers []*Block, defaultUnwindTarget *Block) *TermCatchSwitch
NewCatchSwitch sets the terminator of the basic block to a new catchswitch terminator based on the given parent exception pad, exception handlers and optional default unwind target. If defaultUnwindTarget is nil, catchswitch unwinds to caller function.
func (*Block) NewCleanupPad ¶
func (block *Block) NewCleanupPad(parentPad ExceptionPad, args ...value.Value) *InstCleanupPad
NewCleanupPad appends a new cleanuppad instruction to the basic block based on the given parent exception pad and exception arguments.
func (*Block) NewCleanupRet ¶
func (block *Block) NewCleanupRet(cleanupPad *InstCleanupPad, unwindTarget *Block) *TermCleanupRet
NewCleanupRet sets the terminator of the basic block to a new cleanupret terminator based on the given exit cleanuppad and optional unwind target. If unwindTarget is nil, cleanupret unwinds to caller function.
func (*Block) NewCmpXchg ¶
func (block *Block) NewCmpXchg(ptr, cmp, new value.Value, successOrdering, failureOrdering enum.AtomicOrdering) *InstCmpXchg
NewCmpXchg appends a new cmpxchg instruction to the basic block based on the given address, value to compare against, new value to store, and atomic orderings for success and failure.
func (*Block) NewCondBr ¶
func (block *Block) NewCondBr(cond value.Value, targetTrue, targetFalse *Block) *TermCondBr
NewCondBr sets the terminator of the basic block to a new conditional br terminator based on the given branching condition and conditional target basic blocks.
func (*Block) NewExtractElement ¶
func (block *Block) NewExtractElement(x, index value.Value) *InstExtractElement
NewExtractElement appends a new extractelement instruction to the basic block based on the given vector and element index.
func (*Block) NewExtractValue ¶
func (block *Block) NewExtractValue(x value.Value, indices ...uint64) *InstExtractValue
NewExtractValue appends a new extractvalue instruction to the basic block based on the given aggregate value and indicies.
func (*Block) NewFAdd ¶
NewFAdd appends a new fadd instruction to the basic block based on the given operands.
func (*Block) NewFCmp ¶
NewFCmp appends a new fcmp instruction to the basic block based on the given floating-point comparison predicate and floating-point scalar or vector operands.
func (*Block) NewFDiv ¶
NewFDiv appends a new fdiv instruction to the basic block based on the given operands.
func (*Block) NewFMul ¶
NewFMul appends a new fmul instruction to the basic block based on the given operands.
func (*Block) NewFNeg ¶
NewFNeg appends a new fneg instruction to the basic block based on the given operand.
func (*Block) NewFPExt ¶
NewFPExt appends a new fpext instruction to the basic block based on the given source value and target type.
func (*Block) NewFPToSI ¶
NewFPToSI appends a new fptosi instruction to the basic block based on the given source value and target type.
func (*Block) NewFPToUI ¶
NewFPToUI appends a new fptoui instruction to the basic block based on the given source value and target type.
func (*Block) NewFPTrunc ¶
NewFPTrunc appends a new fptrunc instruction to the basic block based on the given source value and target type.
func (*Block) NewFRem ¶
NewFRem appends a new frem instruction to the basic block based on the given operands.
func (*Block) NewFSub ¶
NewFSub appends a new fsub instruction to the basic block based on the given operands.
func (*Block) NewFence ¶
func (block *Block) NewFence(ordering enum.AtomicOrdering) *InstFence
NewFence appends a new fence instruction to the basic block based on the given atomic ordering.
func (*Block) NewGetElementPtr ¶
func (block *Block) NewGetElementPtr(elemType types.Type, src value.Value, indices ...value.Value) *InstGetElementPtr
NewGetElementPtr appends a new getelementptr instruction to the basic block based on the given element type, source address and element indices.
func (*Block) NewICmp ¶
NewICmp appends a new icmp instruction to the basic block based on the given integer comparison predicate and integer scalar or vector operands.
func (*Block) NewIndirectBr ¶
func (block *Block) NewIndirectBr(addr value.Value, validTargets ...*Block) *TermIndirectBr
NewIndirectBr sets the terminator of the basic block to a new indirectbr terminator based on the given target address (derived from a blockaddress constant of type i8*) and set of valid target basic blocks.
func (*Block) NewInsertElement ¶
func (block *Block) NewInsertElement(x, elem, index value.Value) *InstInsertElement
NewInsertElement appends a new insertelement instruction to the basic block based on the given vector, element and element index.
func (*Block) NewInsertValue ¶
func (block *Block) NewInsertValue(x, elem value.Value, indices ...uint64) *InstInsertValue
NewInsertValue appends a new insertvalue instruction to the basic block based on the given aggregate value, element and indicies.
func (*Block) NewIntToPtr ¶
NewIntToPtr appends a new inttoptr instruction to the basic block based on the given source value and target type.
func (*Block) NewInvoke ¶
func (block *Block) NewInvoke(invokee value.Value, args []value.Value, normalRetTarget, exceptionRetTarget *Block) *TermInvoke
NewInvoke sets the terminator of the basic block to a new invoke terminator based on the given invokee, function arguments and control flow return points for normal and exceptional execution.
TODO: specify the set of underlying types of invokee.
func (*Block) NewLShr ¶
NewLShr appends a new lshr instruction to the basic block based on the given operands.
func (*Block) NewLandingPad ¶
func (block *Block) NewLandingPad(resultType types.Type, clauses ...*Clause) *InstLandingPad
NewLandingPad appends a new landingpad instruction to the basic block based on the given result type and filter/catch clauses.
func (*Block) NewLoad ¶
NewLoad appends a new load instruction to the basic block based on the given element type and source address.
func (*Block) NewMul ¶
NewMul appends a new mul instruction to the basic block based on the given operands.
func (*Block) NewOr ¶
NewOr appends a new or instruction to the basic block based on the given operands.
func (*Block) NewPhi ¶
NewPhi appends a new phi instruction to the basic block based on the given incoming values.
func (*Block) NewPtrToInt ¶
NewPtrToInt appends a new ptrtoint instruction to the basic block based on the given source value and target type.
func (*Block) NewResume ¶
func (block *Block) NewResume(x value.Value) *TermResume
NewResume sets the terminator of the basic block to a new resume terminator based on the given exception argument to propagate.
func (*Block) NewRet ¶
NewRet sets the terminator of the basic block to a new ret terminator based on the given return value. A nil return value indicates a void return.
func (*Block) NewSDiv ¶
NewSDiv appends a new sdiv instruction to the basic block based on the given operands.
func (*Block) NewSExt ¶
NewSExt appends a new sext instruction to the basic block based on the given source value and target type.
func (*Block) NewSIToFP ¶
NewSIToFP appends a new sitofp instruction to the basic block based on the given source value and target type.
func (*Block) NewSRem ¶
NewSRem appends a new srem instruction to the basic block based on the given operands.
func (*Block) NewSelect ¶
func (block *Block) NewSelect(cond, valueTrue, valueFalse value.Value) *InstSelect
NewSelect appends a new select instruction to the basic block based on the given selection condition and true and false condition values.
func (*Block) NewShl ¶
NewShl appends a new shl instruction to the basic block based on the given operands.
func (*Block) NewShuffleVector ¶
func (block *Block) NewShuffleVector(x, y, mask value.Value) *InstShuffleVector
NewShuffleVector appends a new shufflevector instruction to the basic block based on the given vectors and shuffle mask.
func (*Block) NewStore ¶
NewStore appends a new store instruction to the basic block based on the given source value and destination address.
func (*Block) NewSub ¶
NewSub appends a new sub instruction to the basic block based on the given operands.
func (*Block) NewSwitch ¶
NewSwitch sets the terminator of the basic block to a new switch terminator based on the given control variable, default target basic block and switch cases.
func (*Block) NewTrunc ¶
NewTrunc appends a new trunc instruction to the basic block based on the given source value and target type.
func (*Block) NewUDiv ¶
NewUDiv appends a new udiv instruction to the basic block based on the given operands.
func (*Block) NewUIToFP ¶
NewUIToFP appends a new uitofp instruction to the basic block based on the given source value and target type.
func (*Block) NewURem ¶
NewURem appends a new urem instruction to the basic block based on the given operands.
func (*Block) NewUnreachable ¶
func (block *Block) NewUnreachable() *TermUnreachable
NewUnreachable sets the terminator of the basic block to a new unreachable terminator.
func (*Block) NewVAArg ¶
NewVAArg appends a new va_arg instruction to the basic block based on the given variable argument list and argument type.
func (*Block) NewXor ¶
NewXor appends a new xor instruction to the basic block based on the given operands.
func (*Block) NewZExt ¶
NewZExt appends a new zext instruction to the basic block based on the given source value and target type.
type ByRef ¶ added in v0.3.5
ByRef is a byref parameter attribute.
func (ByRef) IsParamAttribute ¶ added in v0.3.5
func (ByRef) IsParamAttribute()
IsParamAttribute ensures that only parameter attributes can be assigned to the ir.ParamAttribute interface.
type Byval ¶
Byval is a byval parameter attribute.
func (Byval) IsParamAttribute ¶
func (Byval) IsParamAttribute()
IsParamAttribute ensures that only parameter attributes can be assigned to the ir.ParamAttribute interface.
type Case ¶
type Case struct { // Case comparand. X value.Value // constant.Constant (integer constant or integer constant expression) // Case target branch. Target value.Value // *ir.Block }
Case is a switch case.
type Clause ¶
type Clause struct { // Clause type (catch or filter). Type enum.ClauseType // Operand. X value.Value }
Clause is a landingpad catch or filter clause.
type ComdatDef ¶
type ComdatDef struct { // Comdat name (without '$' prefix). Name string // Comdat kind. Kind enum.SelectionKind }
ComdatDef is a comdat definition top-level entity.
type Dereferenceable ¶
type Dereferenceable struct { // Number of bytes known to be dereferenceable. N uint64 // (optional) Either dereferenceable or null if set. DerefOrNull bool }
Dereferenceable is a dereferenceable memory attribute.
func (Dereferenceable) IsParamAttribute ¶
func (Dereferenceable) IsParamAttribute()
IsParamAttribute ensures that only parameter attributes can be assigned to the ir.ParamAttribute interface.
func (Dereferenceable) IsReturnAttribute ¶
func (Dereferenceable) IsReturnAttribute()
IsReturnAttribute ensures that only return attributes can be assigned to the ir.ReturnAttribute interface.
func (Dereferenceable) String ¶
func (d Dereferenceable) String() string
String returns the string representation of the dereferenceable memory attribute.
type ElementType ¶ added in v0.3.5
ElementType is a elementtype parameter attribute.
func (ElementType) IsParamAttribute ¶ added in v0.3.5
func (ElementType) IsParamAttribute()
IsParamAttribute ensures that only parameter attributes can be assigned to the ir.ParamAttribute interface.
func (ElementType) String ¶ added in v0.3.5
func (b ElementType) String() string
String returns the string representation of the elementtype parameter attribute.
type ExceptionPad ¶
ExceptionPad is an exception pad or the none token.
An ExceptionPad has one of the following underlying types.
*ir.InstCatchPad *ir.InstCleanupPad *constant.NoneToken
type Func ¶
type Func struct { // Function name (without '@' prefix). GlobalIdent // Function signature. Sig *types.FuncType // Function parameters. Params []*Param // Basic blocks. Blocks []*Block // nil if declaration. // Pointer type to function, including an optional address space. If Typ is // nil, the first invocation of Type stores a pointer type with Sig as // element. Typ *types.PointerType // (optional) Linkage. Linkage enum.Linkage // (optional) Preemption; zero value if not present. Preemption enum.Preemption // (optional) Visibility; zero value if not present. Visibility enum.Visibility // (optional) DLL storage class; zero value if not present. DLLStorageClass enum.DLLStorageClass // (optional) Calling convention; zero value if not present. CallingConv enum.CallingConv // (optional) Return attributes. ReturnAttrs []ReturnAttribute // (optional) Unnamed address. UnnamedAddr enum.UnnamedAddr // (optional) Address space; zero if not present. AddrSpace types.AddrSpace // (optional) Function attributes. FuncAttrs []FuncAttribute // (optional) Section name; empty if not present. Section string // (optional) Partition name; empty if not present. Partition string // (optional) Comdat; nil if not present. Comdat *ComdatDef // (optional) Alignment; zero if not present. Align Align // (optional) Garbage collection; empty if not present. GC string // (optional) Prefix; nil if not present. Prefix constant.Constant // (optional) Prologue; nil if not present. Prologue constant.Constant // (optional) Personality; nil if not present. Personality constant.Constant // (optional) Use list orders. UseListOrders []*UseListOrder // (optional) Metadata. Metadata // Parent module; field set by ir.Module.NewFunc. Parent *Module `json:"-"` // contains filtered or unexported fields }
Func is an LLVM IR function. The body of a function definition consists of a set of basic blocks, interconnected by terminator control flow instructions.
func NewFunc ¶
NewFunc returns a new function based on the given function name, return type and function parameters.
func (*Func) IsConstant ¶
func (*Func) IsConstant()
IsConstant ensures that only constants can be assigned to the constant.Constant interface.
func (*Func) LLString ¶
LLString returns the LLVM syntax representation of the function definition or declaration.
Function declaration.
'declare' Metadata=MetadataAttachment* Header=FuncHeader
Function definition.
'define' Header=FuncHeader Metadata=MetadataAttachment* Body=FuncBody
func (*Func) NewBlock ¶
NewBlock appends a new basic block to the function based on the given label name. An empty label name indicates an unnamed basic block.
The Parent field of the block is set to f.
type FuncAttribute ¶
type FuncAttribute interface { fmt.Stringer // IsFuncAttribute ensures that only function attributes can be assigned to // the ir.FuncAttribute interface. IsFuncAttribute() }
FuncAttribute is a function attribute.
A FuncAttribute has one of the following underlying types.
ir.AttrString ir.AttrPair *ir.AttrGroupDef ir.Align ir.AlignStack ir.AllocSize enum.FuncAttr
type Global ¶
type Global struct { // Global variable name (without '@' prefix). GlobalIdent // Immutability of global variable (constant or global). Immutable bool // Content type. ContentType types.Type // Initial value; or nil if declaration. Init constant.Constant // Pointer type to global variable, including an optional address space. If // Typ is nil, the first invocation of Type stores a pointer type with // ContentType as element. Typ *types.PointerType // (optional) Linkage; zero value if not present. Linkage enum.Linkage // (optional) Preemption; zero value if not present. Preemption enum.Preemption // (optional) Visibility; zero value if not present. Visibility enum.Visibility // (optional) DLL storage class; zero value if not present. DLLStorageClass enum.DLLStorageClass // (optional) Thread local storage model; zero value if not present. TLSModel enum.TLSModel // (optional) Unnamed address; zero value if not present. UnnamedAddr enum.UnnamedAddr // (optional) Address space; zero if not present. AddrSpace types.AddrSpace // (optional) Externally initialized; false if not present. ExternallyInitialized bool // (optional) Section name; empty if not present. Section string // (optional) Partition name; empty if not present. Partition string // (optional) Comdat; nil if not present. Comdat *ComdatDef // (optional) Alignment; zero if not present. Align Align // (optional) Function attributes. FuncAttrs []FuncAttribute // (optional) Metadata. Metadata }
Global is a global variable declaration or definition.
func NewGlobal ¶
NewGlobal returns a new global variable declaration based on the given global variable name and content type.
func NewGlobalDef ¶
NewGlobalDef returns a new global variable definition based on the given global variable name and initial value.
func (*Global) IsConstant ¶
func (*Global) IsConstant()
IsConstant ensures that only constants can be assigned to the constant.Constant interface.
func (*Global) LLString ¶
LLString returns the LLVM syntax representation of the global variable definition or declaration.
Global declaration.
Name=GlobalIdent '=' Linkage=ExternLinkage Preemptionopt Visibilityopt DLLStorageClassopt ThreadLocalopt UnnamedAddropt AddrSpaceopt ExternallyInitializedopt Immutable ContentType=Type (',' Section)? (',' Partition)? (',' Comdat)? (',' Align)? Metadata=(',' MetadataAttachment)+? FuncAttrs=FuncAttribute+?
Global definition.
Name=GlobalIdent '=' Linkage=Linkageopt Preemptionopt Visibilityopt DLLStorageClassopt ThreadLocalopt UnnamedAddropt AddrSpaceopt ExternallyInitializedopt Immutable ContentType=Type Init=Constant (',' Section)? (',' Partition)? (',' Comdat)? (',' Align)? Metadata=(',' MetadataAttachment)+? FuncAttrs=FuncAttribute+?
type GlobalIdent ¶
GlobalIdent is a global identifier.
func (GlobalIdent) Ident ¶
func (i GlobalIdent) Ident() string
Ident returns the identifier associated with the global identifier.
func (GlobalIdent) IsUnnamed ¶
func (i GlobalIdent) IsUnnamed() bool
IsUnnamed reports whether the global identifier is unnamed.
func (GlobalIdent) Name ¶
func (i GlobalIdent) Name() string
Name returns the name of the global identifier.
If unnamed, the global ID is returned. To distinguish numeric names from unnamed IDs, numeric names are quoted.
func (*GlobalIdent) SetID ¶
func (i *GlobalIdent) SetID(id int64)
SetID sets the ID of the global identifier.
func (*GlobalIdent) SetName ¶
func (i *GlobalIdent) SetName(name string)
SetName sets the name of the global identifier.
type IFunc ¶
type IFunc struct { // IFunc name (without '@' prefix). GlobalIdent // Resolver. Resolver constant.Constant // Pointer type of resolver. Typ *types.PointerType // (optional) Linkage; zero value if not present. Linkage enum.Linkage // (optional) Preemption; zero value if not present. Preemption enum.Preemption // (optional) Visibility; zero value if not present. Visibility enum.Visibility // (optional) DLL storage class; zero value if not present. DLLStorageClass enum.DLLStorageClass // (optional) Thread local storage model; zero value if not present. TLSModel enum.TLSModel // (optional) Unnamed address; zero value if not present. UnnamedAddr enum.UnnamedAddr // (optional) Partition name; empty if not present. Partition string }
IFunc is an indirect function (a special kind of function alias).
func NewIFunc ¶
NewIFunc returns a new indirect function based on the given IFunc name and resolver.
func (*IFunc) IsConstant ¶
func (*IFunc) IsConstant()
IsConstant ensures that only constants can be assigned to the constant.Constant interface.
func (*IFunc) LLString ¶
LLString returns the LLVM syntax representation of the IFunc definition.
Name=GlobalIdent '=' (ExternLinkage | Linkageopt) Preemptionopt Visibilityopt DLLStorageClassopt ThreadLocalopt UnnamedAddropt IndirectSymbolKind ContentType=Type ',' IndirectSymbol Partitions=(',' Partition)*
type InAlloca ¶ added in v0.3.5
InAlloca is a param attribute.
func (InAlloca) IsParamAttribute ¶ added in v0.3.5
func (InAlloca) IsParamAttribute()
IsParamAttribute ensures that only parameter attributes can be assigned to the ir.ParamAttribute interface.
type Incoming ¶
type Incoming struct { // Incoming value. X value.Value // Predecessor basic block of the incoming value. Pred value.Value // *ir.Block }
Incoming is an incoming value of a phi instruction.
func NewIncoming ¶
NewIncoming returns a new incoming value based on the given value and predecessor basic block.
type InlineAsm ¶
type InlineAsm struct { // Assembly instructions. Asm string // Constraints. Constraint string // Type of result produced by the inline assembler expression. Typ types.Type // (optional) Side effect. SideEffect bool // (optional) Stack alignment. AlignStack bool // (optional) Intel dialect. IntelDialect bool }
InlineAsm is an inline assembler expression.
func NewInlineAsm ¶
NewInlineAsm returns a new inline assembler expression based on the given type, assembly instructions and constraints.
func (*InlineAsm) Ident ¶
Ident returns the identifier associated with the inline assembler expression.
type InstAShr ¶
type InstAShr struct { // Name of local variable associated with the result. LocalIdent // Operands. X, Y value.Value // integer scalars or vectors // Type of result produced by the instruction. Typ types.Type // (optional) Exact. Exact bool // (optional) Metadata. Metadata }
InstAShr is an LLVM IR ashr instruction.
func (*InstAShr) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
'ashr' Exactopt X=TypeValue ',' Y=Value Metadata=(',' MetadataAttachment)+?
func (*InstAShr) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type InstAdd ¶
type InstAdd struct { // Name of local variable associated with the result. LocalIdent // Operands. X, Y value.Value // integer scalar or integer vector // Type of result produced by the instruction. Typ types.Type // (optional) Overflow flags. OverflowFlags []enum.OverflowFlag // (optional) Metadata. Metadata }
InstAdd is an LLVM IR add instruction.
func (*InstAdd) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
'add' OverflowFlags=OverflowFlag* X=TypeValue ',' Y=Value Metadata=(',' MetadataAttachment)+?
func (*InstAdd) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type InstAddrSpaceCast ¶
type InstAddrSpaceCast struct { // Name of local variable associated with the result. LocalIdent // Value before conversion. From value.Value // Type after conversion. To types.Type // (optional) Metadata. Metadata }
InstAddrSpaceCast is an LLVM IR addrspacecast instruction.
func NewAddrSpaceCast ¶
func NewAddrSpaceCast(from value.Value, to types.Type) *InstAddrSpaceCast
NewAddrSpaceCast returns a new addrspacecast instruction based on the given source value and target type.
func (*InstAddrSpaceCast) LLString ¶
func (inst *InstAddrSpaceCast) LLString() string
LLString returns the LLVM syntax representation of the instruction.
'addrspacecast' From=TypeValue 'to' To=Type Metadata=(',' MetadataAttachment)+?
func (*InstAddrSpaceCast) Operands ¶ added in v0.3.5
func (inst *InstAddrSpaceCast) Operands() []*value.Value
Operands returns a mutable list of operands of the given instruction.
func (*InstAddrSpaceCast) String ¶
func (inst *InstAddrSpaceCast) String() string
String returns the LLVM syntax representation of the instruction as a type-value pair.
func (*InstAddrSpaceCast) Type ¶
func (inst *InstAddrSpaceCast) Type() types.Type
Type returns the type of the instruction.
type InstAlloca ¶
type InstAlloca struct { // Name of local variable associated with the result. LocalIdent // Element type. ElemType types.Type // (optional) Number of elements; nil if not present. NElems value.Value // Type of result produced by the instruction, including an optional address // space. Typ *types.PointerType // (optional) In-alloca. InAlloca bool // (optional) Swift error. SwiftError bool // (optional) Alignment; zero if not present. Align Align // (optional) Address space; zero if not present. AddrSpace types.AddrSpace // (optional) Metadata. Metadata }
InstAlloca is an LLVM IR alloca instruction.
func NewAlloca ¶
func NewAlloca(elemType types.Type) *InstAlloca
NewAlloca returns a new alloca instruction based on the given element type.
func (*InstAlloca) LLString ¶
func (inst *InstAlloca) LLString() string
LLString returns the LLVM syntax representation of the instruction.
'alloca' InAllocaopt SwiftErroropt ElemType=Type NElems=(',' TypeValue)? (',' Align)? (',' AddrSpace)? Metadata=(',' MetadataAttachment)+?
func (*InstAlloca) Operands ¶ added in v0.3.5
func (inst *InstAlloca) Operands() []*value.Value
Operands returns a mutable list of operands of the given instruction.
func (*InstAlloca) String ¶
func (inst *InstAlloca) String() string
String returns the LLVM syntax representation of the instruction as a type-value pair.
func (*InstAlloca) Type ¶
func (inst *InstAlloca) Type() types.Type
Type returns the type of the instruction.
type InstAnd ¶
type InstAnd struct { // Name of local variable associated with the result. LocalIdent // Operands. X, Y value.Value // integer scalars or vectors // Type of result produced by the instruction. Typ types.Type // (optional) Metadata. Metadata }
InstAnd is an LLVM IR and instruction.
func (*InstAnd) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
'and' X=TypeValue ',' Y=Value Metadata=(',' MetadataAttachment)+?
func (*InstAnd) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type InstAtomicRMW ¶
type InstAtomicRMW struct { // Name of local variable associated with the result. LocalIdent // Atomic operation. Op enum.AtomicOp // Destination address. Dst value.Value // Operand. X value.Value // Atomic memory ordering constraints. Ordering enum.AtomicOrdering // Type of result produced by the instruction. Typ types.Type // (optional) Volatile. Volatile bool // (optional) Sync scope; empty if not present. SyncScope string // (optional) Metadata. Metadata }
InstAtomicRMW is an LLVM IR atomicrmw instruction.
func NewAtomicRMW ¶
func NewAtomicRMW(op enum.AtomicOp, dst, x value.Value, ordering enum.AtomicOrdering) *InstAtomicRMW
NewAtomicRMW returns a new atomicrmw instruction based on the given atomic operation, destination address, operand and atomic ordering.
func (*InstAtomicRMW) LLString ¶
func (inst *InstAtomicRMW) LLString() string
LLString returns the LLVM syntax representation of the instruction.
'atomicrmw' Volatileopt Op=AtomicOp Dst=TypeValue ',' X=TypeValue SyncScopeopt Ordering=AtomicOrdering Metadata=(',' MetadataAttachment)+?
func (*InstAtomicRMW) Operands ¶ added in v0.3.5
func (inst *InstAtomicRMW) Operands() []*value.Value
Operands returns a mutable list of operands of the given instruction.
func (*InstAtomicRMW) String ¶
func (inst *InstAtomicRMW) String() string
String returns the LLVM syntax representation of the instruction as a type-value pair.
func (*InstAtomicRMW) Type ¶
func (inst *InstAtomicRMW) Type() types.Type
Type returns the type of the instruction.
type InstBitCast ¶
type InstBitCast struct { // Name of local variable associated with the result. LocalIdent // Value before conversion. From value.Value // Type after conversion. To types.Type // (optional) Metadata. Metadata }
InstBitCast is an LLVM IR bitcast instruction.
func NewBitCast ¶
func NewBitCast(from value.Value, to types.Type) *InstBitCast
NewBitCast returns a new bitcast instruction based on the given source value and target type.
func (*InstBitCast) LLString ¶
func (inst *InstBitCast) LLString() string
LLString returns the LLVM syntax representation of the instruction.
'bitcast' From=TypeValue 'to' To=Type Metadata=(',' MetadataAttachment)+?
func (*InstBitCast) Operands ¶ added in v0.3.5
func (inst *InstBitCast) Operands() []*value.Value
Operands returns a mutable list of operands of the given instruction.
func (*InstBitCast) String ¶
func (inst *InstBitCast) String() string
String returns the LLVM syntax representation of the instruction as a type-value pair.
func (*InstBitCast) Type ¶
func (inst *InstBitCast) Type() types.Type
Type returns the type of the instruction.
type InstCall ¶
type InstCall struct { // Name of local variable associated with the result. LocalIdent // Callee. // TODO: specify the set of underlying types of Callee. Callee value.Value // Function arguments. // // Arg has one of the following underlying types: // value.Value // *ir.Arg // TODO: add metadata value? Args []value.Value // Type of result produced by the instruction. Typ types.Type // (optional) Tail; zero if not present. Tail enum.Tail // (optional) Fast math flags. FastMathFlags []enum.FastMathFlag // (optional) Calling convention; zero if not present. CallingConv enum.CallingConv // (optional) Return attributes. ReturnAttrs []ReturnAttribute // (optional) Address space; zero if not present. AddrSpace types.AddrSpace // (optional) Function attributes. FuncAttrs []FuncAttribute // (optional) Operand bundles. OperandBundles []*OperandBundle // (optional) Metadata. Metadata }
InstCall is an LLVM IR call instruction.
func NewCall ¶
NewCall returns a new call instruction based on the given callee and function arguments.
TODO: specify the set of underlying types of callee.
func (*InstCall) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
Tailopt 'call' FastMathFlags=FastMathFlag* CallingConvopt ReturnAttrs=ReturnAttribute* AddrSpaceopt Typ=Type Callee=Value '(' Args ')' FuncAttrs=FuncAttribute* OperandBundles=('[' (OperandBundle separator ',')+ ']')? Metadata=(',' MetadataAttachment)+?
func (*InstCall) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type InstCatchPad ¶
type InstCatchPad struct { // Name of local variable associated with the result. LocalIdent // Parent catchswitch terminator. CatchSwitch value.Value // *ir.TermCatchSwitch // Exception arguments. // // Arg has one of the following underlying types: // value.Value // TODO: add metadata value? Args []value.Value // (optional) Metadata. Metadata }
InstCatchPad is an LLVM IR catchpad instruction.
func NewCatchPad ¶
func NewCatchPad(catchSwitch *TermCatchSwitch, args ...value.Value) *InstCatchPad
NewCatchPad returns a new catchpad instruction based on the given parent catchswitch terminator and exception arguments.
func (*InstCatchPad) LLString ¶
func (inst *InstCatchPad) LLString() string
LLString returns the LLVM syntax representation of the instruction.
'catchpad' 'within' CatchSwitch=LocalIdent '[' Args=(ExceptionArg separator ',')* ']' Metadata=(',' MetadataAttachment)+?
func (*InstCatchPad) Operands ¶ added in v0.3.5
func (inst *InstCatchPad) Operands() []*value.Value
Operands returns a mutable list of operands of the given instruction.
func (*InstCatchPad) String ¶
func (inst *InstCatchPad) String() string
String returns the LLVM syntax representation of the instruction as a type-value pair.
func (*InstCatchPad) Type ¶
func (inst *InstCatchPad) Type() types.Type
Type returns the type of the instruction.
type InstCleanupPad ¶
type InstCleanupPad struct { // Name of local variable associated with the result. LocalIdent // Parent exception pad. ParentPad value.Value // ir.ExceptionPad // Exception arguments. // // Arg has one of the following underlying types: // value.Value // TODO: add metadata value? Args []value.Value // (optional) Metadata. Metadata }
InstCleanupPad is an LLVM IR cleanuppad instruction.
func NewCleanupPad ¶
func NewCleanupPad(parentPad ExceptionPad, args ...value.Value) *InstCleanupPad
NewCleanupPad returns a new cleanuppad instruction based on the given parent exception pad and exception arguments.
func (*InstCleanupPad) LLString ¶
func (inst *InstCleanupPad) LLString() string
LLString returns the LLVM syntax representation of the instruction.
'cleanuppad' 'within' ParentPad=ExceptionPad '[' Args=(ExceptionArg separator ',')* ']' Metadata=(',' MetadataAttachment)+?
func (*InstCleanupPad) Operands ¶ added in v0.3.5
func (inst *InstCleanupPad) Operands() []*value.Value
Operands returns a mutable list of operands of the given instruction.
func (*InstCleanupPad) String ¶
func (inst *InstCleanupPad) String() string
String returns the LLVM syntax representation of the instruction as a type-value pair.
func (*InstCleanupPad) Type ¶
func (inst *InstCleanupPad) Type() types.Type
Type returns the type of the instruction.
type InstCmpXchg ¶
type InstCmpXchg struct { // Name of local variable associated with the result. LocalIdent // Address to read from, compare against and store to. Ptr value.Value // Value to compare against. Cmp value.Value // New value to store. New value.Value // Atomic memory ordering constraints on success. SuccessOrdering enum.AtomicOrdering // Atomic memory ordering constraints on failure. FailureOrdering enum.AtomicOrdering // Type of result produced by the instruction; the first field of the struct // holds the old value, and the second field indicates success. Typ *types.StructType // (optional) Weak. Weak bool // (optional) Volatile. Volatile bool // (optional) Sync scope; empty if not present. SyncScope string // (optional) Metadata. Metadata }
InstCmpXchg is an LLVM IR cmpxchg instruction.
func NewCmpXchg ¶
func NewCmpXchg(ptr, cmp, new value.Value, successOrdering, failureOrdering enum.AtomicOrdering) *InstCmpXchg
NewCmpXchg returns a new cmpxchg instruction based on the given address, value to compare against, new value to store, and atomic orderings for success and failure.
func (*InstCmpXchg) LLString ¶
func (inst *InstCmpXchg) LLString() string
LLString returns the LLVM syntax representation of the instruction.
'cmpxchg' Weakopt Volatileopt Ptr=TypeValue ',' Cmp=TypeValue ',' New=TypeValue SyncScopeopt SuccessOrdering=AtomicOrdering FailureOrdering=AtomicOrdering Metadata=(',' MetadataAttachment)+?
func (*InstCmpXchg) Operands ¶ added in v0.3.5
func (inst *InstCmpXchg) Operands() []*value.Value
Operands returns a mutable list of operands of the given instruction.
func (*InstCmpXchg) String ¶
func (inst *InstCmpXchg) String() string
String returns the LLVM syntax representation of the instruction as a type-value pair.
func (*InstCmpXchg) Type ¶
func (inst *InstCmpXchg) Type() types.Type
Type returns the type of the instruction. The result type is a struct type with two fields, the first field has the type of the old value and the second field has boolean type.
type InstExtractElement ¶
type InstExtractElement struct { // Name of local variable associated with the result. LocalIdent // Vector. X value.Value // Element index. Index value.Value // Type of result produced by the instruction. Typ types.Type // (optional) Metadata. Metadata }
InstExtractElement is an LLVM IR extractelement instruction.
func NewExtractElement ¶
func NewExtractElement(x, index value.Value) *InstExtractElement
NewExtractElement returns a new extractelement instruction based on the given vector and element index.
func (*InstExtractElement) LLString ¶
func (inst *InstExtractElement) LLString() string
LLString returns the LLVM syntax representation of the instruction.
'extractelement' X=TypeValue ',' Index=TypeValue Metadata=(',' MetadataAttachment)+?
func (*InstExtractElement) Operands ¶ added in v0.3.5
func (inst *InstExtractElement) Operands() []*value.Value
Operands returns a mutable list of operands of the given instruction.
func (*InstExtractElement) String ¶
func (inst *InstExtractElement) String() string
String returns the LLVM syntax representation of the instruction as a type-value pair.
func (*InstExtractElement) Type ¶
func (inst *InstExtractElement) Type() types.Type
Type returns the type of the instruction.
type InstExtractValue ¶
type InstExtractValue struct { // Name of local variable associated with the result. LocalIdent // Aggregate value. X value.Value // array or struct // Element indices. Indices []uint64 // Type of result produced by the instruction. Typ types.Type // (optional) Metadata. Metadata }
InstExtractValue is an LLVM IR extractvalue instruction.
func NewExtractValue ¶
func NewExtractValue(x value.Value, indices ...uint64) *InstExtractValue
NewExtractValue returns a new extractvalue instruction based on the given aggregate value and indicies.
func (*InstExtractValue) LLString ¶
func (inst *InstExtractValue) LLString() string
LLString returns the LLVM syntax representation of the instruction.
'extractvalue' X=TypeValue Indices=(',' UintLit)+ Metadata=(',' MetadataAttachment)+?
func (*InstExtractValue) Operands ¶ added in v0.3.5
func (inst *InstExtractValue) Operands() []*value.Value
Operands returns a mutable list of operands of the given instruction.
func (*InstExtractValue) String ¶
func (inst *InstExtractValue) String() string
String returns the LLVM syntax representation of the instruction as a type-value pair.
func (*InstExtractValue) Type ¶
func (inst *InstExtractValue) Type() types.Type
Type returns the type of the instruction.
type InstFAdd ¶
type InstFAdd struct { // Name of local variable associated with the result. LocalIdent // Operands. X, Y value.Value // floating-point scalar or floating-point vector // Type of result produced by the instruction. Typ types.Type // (optional) Fast math flags. FastMathFlags []enum.FastMathFlag // (optional) Metadata. Metadata }
InstFAdd is an LLVM IR fadd instruction.
func (*InstFAdd) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
'fadd' FastMathFlags=FastMathFlag* X=TypeValue ',' Y=Value Metadata=(',' MetadataAttachment)+?
func (*InstFAdd) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type InstFCmp ¶
type InstFCmp struct { // Name of local variable associated with the result. LocalIdent // Floating-point comparison predicate. Pred enum.FPred // Floating-point scalar or vector operands. X, Y value.Value // floating-point scalar or floating-point vector // Type of result produced by the instruction. Typ types.Type // boolean or boolean vector // (optional) Fast math flags. FastMathFlags []enum.FastMathFlag // (optional) Metadata. Metadata }
InstFCmp is an LLVM IR fcmp instruction.
func NewFCmp ¶
NewFCmp returns a new fcmp instruction based on the given floating-point comparison predicate and floating-point scalar or vector operands.
func (*InstFCmp) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
'fcmp' FastMathFlags=FastMathFlag* Pred=FPred X=TypeValue ',' Y=Value Metadata=(',' MetadataAttachment)+?
func (*InstFCmp) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type InstFDiv ¶
type InstFDiv struct { // Name of local variable associated with the result. LocalIdent // Operands. X, Y value.Value // floating-point scalar or floating-point vector // Type of result produced by the instruction. Typ types.Type // (optional) Fast math flags. FastMathFlags []enum.FastMathFlag // (optional) Metadata. Metadata }
InstFDiv is an LLVM IR fdiv instruction.
func (*InstFDiv) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
'fdiv' FastMathFlags=FastMathFlag* X=TypeValue ',' Y=Value Metadata=(',' MetadataAttachment)+?
func (*InstFDiv) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type InstFMul ¶
type InstFMul struct { // Name of local variable associated with the result. LocalIdent // Operands. X, Y value.Value // floating-point scalar or floating-point vector // Type of result produced by the instruction. Typ types.Type // (optional) Fast math flags. FastMathFlags []enum.FastMathFlag // (optional) Metadata. Metadata }
InstFMul is an LLVM IR fmul instruction.
func (*InstFMul) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
'fmul' FastMathFlags=FastMathFlag* X=TypeValue ',' Y=Value Metadata=(',' MetadataAttachment)+?
func (*InstFMul) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type InstFNeg ¶
type InstFNeg struct { // Name of local variable associated with the result. LocalIdent // Operand. X value.Value // floating-point scalar or floating-point vector // Type of result produced by the instruction. Typ types.Type // (optional) Fast math flags. FastMathFlags []enum.FastMathFlag // (optional) Metadata. Metadata }
InstFNeg is an LLVM IR fneg instruction.
func (*InstFNeg) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
'fneg' FastMathFlags=FastMathFlag* X=TypeValue Metadata=(',' MetadataAttachment)+?
func (*InstFNeg) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type InstFPExt ¶
type InstFPExt struct { // Name of local variable associated with the result. LocalIdent // Value before conversion. From value.Value // Type after conversion. To types.Type // (optional) Metadata. Metadata }
InstFPExt is an LLVM IR fpext instruction.
func NewFPExt ¶
NewFPExt returns a new fpext instruction based on the given source value and target type.
func (*InstFPExt) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
'fpext' From=TypeValue 'to' To=Type Metadata=(',' MetadataAttachment)+?
func (*InstFPExt) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type InstFPToSI ¶
type InstFPToSI struct { // Name of local variable associated with the result. LocalIdent // Value before conversion. From value.Value // Type after conversion. To types.Type // (optional) Metadata. Metadata }
InstFPToSI is an LLVM IR fptosi instruction.
func NewFPToSI ¶
func NewFPToSI(from value.Value, to types.Type) *InstFPToSI
NewFPToSI returns a new fptosi instruction based on the given source value and target type.
func (*InstFPToSI) LLString ¶
func (inst *InstFPToSI) LLString() string
LLString returns the LLVM syntax representation of the instruction.
'fptosi' From=TypeValue 'to' To=Type Metadata=(',' MetadataAttachment)+?
func (*InstFPToSI) Operands ¶ added in v0.3.5
func (inst *InstFPToSI) Operands() []*value.Value
Operands returns a mutable list of operands of the given instruction.
func (*InstFPToSI) String ¶
func (inst *InstFPToSI) String() string
String returns the LLVM syntax representation of the instruction as a type-value pair.
func (*InstFPToSI) Type ¶
func (inst *InstFPToSI) Type() types.Type
Type returns the type of the instruction.
type InstFPToUI ¶
type InstFPToUI struct { // Name of local variable associated with the result. LocalIdent // Value before conversion. From value.Value // Type after conversion. To types.Type // (optional) Metadata. Metadata }
InstFPToUI is an LLVM IR fptoui instruction.
func NewFPToUI ¶
func NewFPToUI(from value.Value, to types.Type) *InstFPToUI
NewFPToUI returns a new fptoui instruction based on the given source value and target type.
func (*InstFPToUI) LLString ¶
func (inst *InstFPToUI) LLString() string
LLString returns the LLVM syntax representation of the instruction.
'fptoui' From=TypeValue 'to' To=Type Metadata=(',' MetadataAttachment)+?
func (*InstFPToUI) Operands ¶ added in v0.3.5
func (inst *InstFPToUI) Operands() []*value.Value
Operands returns a mutable list of operands of the given instruction.
func (*InstFPToUI) String ¶
func (inst *InstFPToUI) String() string
String returns the LLVM syntax representation of the instruction as a type-value pair.
func (*InstFPToUI) Type ¶
func (inst *InstFPToUI) Type() types.Type
Type returns the type of the instruction.
type InstFPTrunc ¶
type InstFPTrunc struct { // Name of local variable associated with the result. LocalIdent // Value before conversion. From value.Value // Type after conversion. To types.Type // (optional) Metadata. Metadata }
InstFPTrunc is an LLVM IR fptrunc instruction.
func NewFPTrunc ¶
func NewFPTrunc(from value.Value, to types.Type) *InstFPTrunc
NewFPTrunc returns a new fptrunc instruction based on the given source value and target type.
func (*InstFPTrunc) LLString ¶
func (inst *InstFPTrunc) LLString() string
LLString returns the LLVM syntax representation of the instruction.
'fptrunc' From=TypeValue 'to' To=Type Metadata=(',' MetadataAttachment)+?
func (*InstFPTrunc) Operands ¶ added in v0.3.5
func (inst *InstFPTrunc) Operands() []*value.Value
Operands returns a mutable list of operands of the given instruction.
func (*InstFPTrunc) String ¶
func (inst *InstFPTrunc) String() string
String returns the LLVM syntax representation of the instruction as a type-value pair.
func (*InstFPTrunc) Type ¶
func (inst *InstFPTrunc) Type() types.Type
Type returns the type of the instruction.
type InstFRem ¶
type InstFRem struct { // Name of local variable associated with the result. LocalIdent // Operands. X, Y value.Value // floating-point scalar or floating-point vector // Type of result produced by the instruction. Typ types.Type // (optional) Fast math flags. FastMathFlags []enum.FastMathFlag // (optional) Metadata. Metadata }
InstFRem is an LLVM IR frem instruction.
func (*InstFRem) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
'frem' FastMathFlags=FastMathFlag* X=TypeValue ',' Y=Value Metadata=(',' MetadataAttachment)+?
func (*InstFRem) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type InstFSub ¶
type InstFSub struct { // Name of local variable associated with the result. LocalIdent // Operands. X, Y value.Value // floating-point scalar or floating-point vector // Type of result produced by the instruction. Typ types.Type // (optional) Fast math flags. FastMathFlags []enum.FastMathFlag // (optional) Metadata. Metadata }
InstFSub is an LLVM IR fsub instruction.
func (*InstFSub) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
'fsub' FastMathFlags=FastMathFlag* X=TypeValue ',' Y=Value Metadata=(',' MetadataAttachment)+?
func (*InstFSub) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type InstFence ¶
type InstFence struct { // Atomic memory ordering constraints. Ordering enum.AtomicOrdering // (optional) Sync scope; empty if not present. SyncScope string // (optional) Metadata. Metadata }
InstFence is an LLVM IR fence instruction.
func NewFence ¶
func NewFence(ordering enum.AtomicOrdering) *InstFence
NewFence returns a new fence instruction based on the given atomic ordering.
type InstFreeze ¶ added in v0.3.1
type InstFreeze struct { // Name of local variable associated with the result. LocalIdent // Operand. X value.Value // Type of result produced by the instruction. Typ types.Type // (optional) Metadata. Metadata }
InstFreeze is an LLVM IR freeze instruction.
func NewInstFreeze ¶ added in v0.3.1
func NewInstFreeze(x value.Value) *InstFreeze
NewInstFreeze returns a new freeze instruction based on the given operand.
func (*InstFreeze) LLString ¶ added in v0.3.1
func (inst *InstFreeze) LLString() string
LLString returns the LLVM syntax representation of the instruction.
'freeze' Type Value
func (*InstFreeze) Operands ¶ added in v0.3.5
func (inst *InstFreeze) Operands() []*value.Value
Operands returns a mutable list of operands of the given instruction.
func (*InstFreeze) String ¶ added in v0.3.1
func (inst *InstFreeze) String() string
String returns the LLVM syntax representation of the instruction as a type-value pair.
func (*InstFreeze) Type ¶ added in v0.3.1
func (inst *InstFreeze) Type() types.Type
Type returns the type of the instruction.
type InstGetElementPtr ¶
type InstGetElementPtr struct { // Name of local variable associated with the result. LocalIdent // Element type. ElemType types.Type // Source address. Src value.Value // Element indicies. Indices []value.Value // Type of result produced by the instruction. Typ types.Type // *types.PointerType or *types.VectorType (with elements of pointer type) // (optional) In-bounds. InBounds bool // (optional) Metadata. Metadata }
InstGetElementPtr is an LLVM IR getelementptr instruction.
func NewGetElementPtr ¶
func NewGetElementPtr(elemType types.Type, src value.Value, indices ...value.Value) *InstGetElementPtr
NewGetElementPtr returns a new getelementptr instruction based on the given element type, source address and element indices.
func (*InstGetElementPtr) LLString ¶
func (inst *InstGetElementPtr) LLString() string
LLString returns the LLVM syntax representation of the instruction.
'getelementptr' InBoundsopt ElemType=Type ',' Src=TypeValue Indices=(',' TypeValue)* Metadata=(',' MetadataAttachment)+?
func (*InstGetElementPtr) Operands ¶ added in v0.3.5
func (inst *InstGetElementPtr) Operands() []*value.Value
Operands returns a mutable list of operands of the given instruction.
func (*InstGetElementPtr) String ¶
func (inst *InstGetElementPtr) String() string
String returns the LLVM syntax representation of the instruction as a type-value pair.
func (*InstGetElementPtr) Type ¶
func (inst *InstGetElementPtr) Type() types.Type
Type returns the type of the instruction.
type InstICmp ¶
type InstICmp struct { // Name of local variable associated with the result. LocalIdent // Integer comparison predicate. Pred enum.IPred // Integer scalar or vector operands. X, Y value.Value // integer scalar, pointer, integer vector or pointer vector. // Type of result produced by the instruction. Typ types.Type // boolean or boolean vector // (optional) Metadata. Metadata }
InstICmp is an LLVM IR icmp instruction.
func NewICmp ¶
NewICmp returns a new icmp instruction based on the given integer comparison predicate and integer scalar or vector operands.
func (*InstICmp) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
'icmp' Pred=IPred X=TypeValue ',' Y=Value Metadata=(',' MetadataAttachment)+?
func (*InstICmp) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type InstInsertElement ¶
type InstInsertElement struct { // Name of local variable associated with the result. LocalIdent // Vector. X value.Value // Element to insert. Elem value.Value // Element index. Index value.Value // Type of result produced by the instruction. Typ *types.VectorType // (optional) Metadata. Metadata }
InstInsertElement is an LLVM IR insertelement instruction.
func NewInsertElement ¶
func NewInsertElement(x, elem, index value.Value) *InstInsertElement
NewInsertElement returns a new insertelement instruction based on the given vector, element and element index.
func (*InstInsertElement) LLString ¶
func (inst *InstInsertElement) LLString() string
LLString returns the LLVM syntax representation of the instruction.
'insertelement' X=TypeValue ',' Elem=TypeValue ',' Index=TypeValue Metadata=(',' MetadataAttachment)+?
func (*InstInsertElement) Operands ¶ added in v0.3.5
func (inst *InstInsertElement) Operands() []*value.Value
Operands returns a mutable list of operands of the given instruction.
func (*InstInsertElement) String ¶
func (inst *InstInsertElement) String() string
String returns the LLVM syntax representation of the instruction as a type-value pair.
func (*InstInsertElement) Type ¶
func (inst *InstInsertElement) Type() types.Type
Type returns the type of the instruction.
type InstInsertValue ¶
type InstInsertValue struct { // Name of local variable associated with the result. LocalIdent // Aggregate value. X value.Value // array or struct // Element to insert. Elem value.Value // Element indices. Indices []uint64 // Type of result produced by the instruction. Typ types.Type // (optional) Metadata. Metadata }
InstInsertValue is an LLVM IR insertvalue instruction.
func NewInsertValue ¶
func NewInsertValue(x, elem value.Value, indices ...uint64) *InstInsertValue
NewInsertValue returns a new insertvalue instruction based on the given aggregate value, element and indicies.
func (*InstInsertValue) LLString ¶
func (inst *InstInsertValue) LLString() string
LLString returns the LLVM syntax representation of the instruction.
'insertvalue' X=TypeValue ',' Elem=TypeValue Indices=(',' UintLit)+ Metadata=(',' MetadataAttachment)+?
func (*InstInsertValue) Operands ¶ added in v0.3.5
func (inst *InstInsertValue) Operands() []*value.Value
Operands returns a mutable list of operands of the given instruction.
func (*InstInsertValue) String ¶
func (inst *InstInsertValue) String() string
String returns the LLVM syntax representation of the instruction as a type-value pair.
func (*InstInsertValue) Type ¶
func (inst *InstInsertValue) Type() types.Type
Type returns the type of the instruction.
type InstIntToPtr ¶
type InstIntToPtr struct { // Name of local variable associated with the result. LocalIdent // Value before conversion. From value.Value // Type after conversion. To types.Type // (optional) Metadata. Metadata }
InstIntToPtr is an LLVM IR inttoptr instruction.
func NewIntToPtr ¶
func NewIntToPtr(from value.Value, to types.Type) *InstIntToPtr
NewIntToPtr returns a new inttoptr instruction based on the given source value and target type.
func (*InstIntToPtr) LLString ¶
func (inst *InstIntToPtr) LLString() string
LLString returns the LLVM syntax representation of the instruction.
'inttoptr' From=TypeValue 'to' To=Type Metadata=(',' MetadataAttachment)+?
func (*InstIntToPtr) Operands ¶ added in v0.3.5
func (inst *InstIntToPtr) Operands() []*value.Value
Operands returns a mutable list of operands of the given instruction.
func (*InstIntToPtr) String ¶
func (inst *InstIntToPtr) String() string
String returns the LLVM syntax representation of the instruction as a type-value pair.
func (*InstIntToPtr) Type ¶
func (inst *InstIntToPtr) Type() types.Type
Type returns the type of the instruction.
type InstLShr ¶
type InstLShr struct { // Name of local variable associated with the result. LocalIdent // Operands. X, Y value.Value // integer scalars or vectors // Type of result produced by the instruction. Typ types.Type // (optional) Exact. Exact bool // (optional) Metadata. Metadata }
InstLShr is an LLVM IR lshr instruction.
func (*InstLShr) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
'lshr' Exactopt X=TypeValue ',' Y=Value Metadata=(',' MetadataAttachment)+?
func (*InstLShr) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type InstLandingPad ¶
type InstLandingPad struct { // Name of local variable associated with the result. LocalIdent // Result type. ResultType types.Type // (optional) Cleanup landing pad. Cleanup bool // Filter and catch clauses; zero or more if Cleanup is true, otherwise one // or more. Clauses []*Clause // (optional) Metadata. Metadata }
InstLandingPad is an LLVM IR landingpad instruction.
func NewLandingPad ¶
func NewLandingPad(resultType types.Type, clauses ...*Clause) *InstLandingPad
NewLandingPad returns a new landingpad instruction based on the given result type and filter/catch clauses.
func (*InstLandingPad) LLString ¶
func (inst *InstLandingPad) LLString() string
LLString returns the LLVM syntax representation of the instruction.
'landingpad' ResultType=Type Cleanupopt Clauses=Clause* Metadata=(',' MetadataAttachment)+?
func (*InstLandingPad) Operands ¶ added in v0.3.5
func (inst *InstLandingPad) Operands() []*value.Value
Operands returns a mutable list of operands of the given instruction.
func (*InstLandingPad) String ¶
func (inst *InstLandingPad) String() string
String returns the LLVM syntax representation of the instruction as a type-value pair.
func (*InstLandingPad) Type ¶
func (inst *InstLandingPad) Type() types.Type
Type returns the type of the instruction.
type InstLoad ¶
type InstLoad struct { // Name of local variable associated with the result. LocalIdent // Element type of src. ElemType types.Type // Source address. Src value.Value // (optional) Atomic. Atomic bool // (optional) Volatile. Volatile bool // (optional) Sync scope; empty if not present. SyncScope string // (optional) Atomic memory ordering constraints; zero if not present. Ordering enum.AtomicOrdering // (optional) Alignment; zero if not present. Align Align // (optional) Metadata. Metadata }
InstLoad is an LLVM IR load instruction.
func NewLoad ¶
NewLoad returns a new load instruction based on the given element type and source address.
func (*InstLoad) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
Load instruction.
'load' Volatileopt ElemType=Type ',' Src=TypeValue (',' Align)? Metadata=(',' MetadataAttachment)+?
Atomic load instruction.
'load' Atomic Volatileopt ElemType=Type ',' Src=TypeValue SyncScopeopt Ordering=AtomicOrdering (',' Align)? Metadata=(',' MetadataAttachment)+?
func (*InstLoad) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type InstMul ¶
type InstMul struct { // Name of local variable associated with the result. LocalIdent // Operands. X, Y value.Value // integer scalar or integer vector // Type of result produced by the instruction. Typ types.Type // (optional) Overflow flags. OverflowFlags []enum.OverflowFlag // (optional) Metadata. Metadata }
InstMul is an LLVM IR mul instruction.
func (*InstMul) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
'mul' OverflowFlags=OverflowFlag* X=TypeValue ',' Y=Value Metadata=(',' MetadataAttachment)+?
func (*InstMul) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type InstOr ¶
type InstOr struct { // Name of local variable associated with the result. LocalIdent // Operands. X, Y value.Value // integer scalars or vectors // Type of result produced by the instruction. Typ types.Type // (optional) Metadata. Metadata }
InstOr is an LLVM IR or instruction.
func (*InstOr) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
'or' X=TypeValue ',' Y=Value Metadata=(',' MetadataAttachment)+?
func (*InstOr) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type InstPhi ¶
type InstPhi struct { // Name of local variable associated with the result. LocalIdent // Incoming values. Incs []*Incoming // Type of result produced by the instruction. Typ types.Type // type of incoming value // (optional) Fast math flags. FastMathFlags []enum.FastMathFlag // (optional) Metadata. Metadata }
InstPhi is an LLVM IR phi instruction.
func (*InstPhi) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
'phi' Typ=Type Incs=(Inc separator ',')+ Metadata=(',' MetadataAttachment)+?
func (*InstPhi) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type InstPtrToInt ¶
type InstPtrToInt struct { // Name of local variable associated with the result. LocalIdent // Value before conversion. From value.Value // Type after conversion. To types.Type // (optional) Metadata. Metadata }
InstPtrToInt is an LLVM IR ptrtoint instruction.
func NewPtrToInt ¶
func NewPtrToInt(from value.Value, to types.Type) *InstPtrToInt
NewPtrToInt returns a new ptrtoint instruction based on the given source value and target type.
func (*InstPtrToInt) LLString ¶
func (inst *InstPtrToInt) LLString() string
LLString returns the LLVM syntax representation of the instruction.
'ptrtoint' From=TypeValue 'to' To=Type Metadata=(',' MetadataAttachment)+?
func (*InstPtrToInt) Operands ¶ added in v0.3.5
func (inst *InstPtrToInt) Operands() []*value.Value
Operands returns a mutable list of operands of the given instruction.
func (*InstPtrToInt) String ¶
func (inst *InstPtrToInt) String() string
String returns the LLVM syntax representation of the instruction as a type-value pair.
func (*InstPtrToInt) Type ¶
func (inst *InstPtrToInt) Type() types.Type
Type returns the type of the instruction.
type InstSDiv ¶
type InstSDiv struct { // Name of local variable associated with the result. LocalIdent // Operands. X, Y value.Value // integer scalar or integer vector // Type of result produced by the instruction. Typ types.Type // (optional) Exact. Exact bool // (optional) Metadata. Metadata }
InstSDiv is an LLVM IR sdiv instruction.
func (*InstSDiv) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
'sdiv' Exactopt X=TypeValue ',' Y=Value Metadata=(',' MetadataAttachment)+?
func (*InstSDiv) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type InstSExt ¶
type InstSExt struct { // Name of local variable associated with the result. LocalIdent // Value before conversion. From value.Value // Type after conversion. To types.Type // (optional) Metadata. Metadata }
InstSExt is an LLVM IR sext instruction.
func NewSExt ¶
NewSExt returns a new sext instruction based on the given source value and target type.
func (*InstSExt) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
'sext' From=TypeValue 'to' To=Type Metadata=(',' MetadataAttachment)+?
func (*InstSExt) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type InstSIToFP ¶
type InstSIToFP struct { // Name of local variable associated with the result. LocalIdent // Value before conversion. From value.Value // Type after conversion. To types.Type // (optional) Metadata. Metadata }
InstSIToFP is an LLVM IR sitofp instruction.
func NewSIToFP ¶
func NewSIToFP(from value.Value, to types.Type) *InstSIToFP
NewSIToFP returns a new sitofp instruction based on the given source value and target type.
func (*InstSIToFP) LLString ¶
func (inst *InstSIToFP) LLString() string
LLString returns the LLVM syntax representation of the instruction.
'sitofp' From=TypeValue 'to' To=Type Metadata=(',' MetadataAttachment)+?
func (*InstSIToFP) Operands ¶ added in v0.3.5
func (inst *InstSIToFP) Operands() []*value.Value
Operands returns a mutable list of operands of the given instruction.
func (*InstSIToFP) String ¶
func (inst *InstSIToFP) String() string
String returns the LLVM syntax representation of the instruction as a type-value pair.
func (*InstSIToFP) Type ¶
func (inst *InstSIToFP) Type() types.Type
Type returns the type of the instruction.
type InstSRem ¶
type InstSRem struct { // Name of local variable associated with the result. LocalIdent // Operands. X, Y value.Value // integer scalar or integer vector // Type of result produced by the instruction. Typ types.Type // (optional) Metadata. Metadata }
InstSRem is an LLVM IR srem instruction.
func (*InstSRem) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
'srem' X=TypeValue ',' Y=Value Metadata=(',' MetadataAttachment)+?
func (*InstSRem) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type InstSelect ¶
type InstSelect struct { // Name of local variable associated with the result. LocalIdent // Selection condition. Cond value.Value // boolean or boolean vector // True condition value. ValueTrue value.Value // False condition value. ValueFalse value.Value // Type of result produced by the instruction. Typ types.Type // (optional) Fast math flags. FastMathFlags []enum.FastMathFlag // (optional) Metadata. Metadata }
InstSelect is an LLVM IR select instruction.
func NewSelect ¶
func NewSelect(cond, valueTrue, valueFalse value.Value) *InstSelect
NewSelect returns a new select instruction based on the given selection condition and true and false condition values.
func (*InstSelect) LLString ¶
func (inst *InstSelect) LLString() string
LLString returns the LLVM syntax representation of the instruction.
'select' FastMathFlags=FastMathFlag* Cond=TypeValue ',' ValueTrue=TypeValue ',' ValueFalse=TypeValue Metadata=(',' MetadataAttachment)+?
func (*InstSelect) Operands ¶ added in v0.3.5
func (inst *InstSelect) Operands() []*value.Value
Operands returns a mutable list of operands of the given instruction.
func (*InstSelect) String ¶
func (inst *InstSelect) String() string
String returns the LLVM syntax representation of the instruction as a type-value pair.
func (*InstSelect) Type ¶
func (inst *InstSelect) Type() types.Type
Type returns the type of the instruction.
type InstShl ¶
type InstShl struct { // Name of local variable associated with the result. LocalIdent // Operands. X, Y value.Value // integer scalar or integer vector // Type of result produced by the instruction. Typ types.Type // (optional) Overflow flags. OverflowFlags []enum.OverflowFlag // (optional) Metadata. Metadata }
InstShl is an LLVM IR shl instruction.
func (*InstShl) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
'shl' OverflowFlags=OverflowFlag* X=TypeValue ',' Y=Value Metadata=(',' MetadataAttachment)+?
func (*InstShl) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type InstShuffleVector ¶
type InstShuffleVector struct { // Name of local variable associated with the result. LocalIdent // Vectors. X, Y value.Value // Shuffle mask. Mask value.Value // Type of result produced by the instruction. Typ *types.VectorType // (optional) Metadata. Metadata }
InstShuffleVector is an LLVM IR shufflevector instruction.
func NewShuffleVector ¶
func NewShuffleVector(x, y, mask value.Value) *InstShuffleVector
NewShuffleVector returns a new shufflevector instruction based on the given vectors and shuffle mask.
func (*InstShuffleVector) LLString ¶
func (inst *InstShuffleVector) LLString() string
LLString returns the LLVM syntax representation of the instruction.
'shufflevector' X=TypeValue ',' Y=TypeValue ',' Mask=TypeValue Metadata=(',' MetadataAttachment)+?
func (*InstShuffleVector) Operands ¶ added in v0.3.5
func (inst *InstShuffleVector) Operands() []*value.Value
Operands returns a mutable list of operands of the given instruction.
func (*InstShuffleVector) String ¶
func (inst *InstShuffleVector) String() string
String returns the LLVM syntax representation of the instruction as a type-value pair.
func (*InstShuffleVector) Type ¶
func (inst *InstShuffleVector) Type() types.Type
Type returns the type of the instruction.
type InstStore ¶
type InstStore struct { // Source value. Src value.Value // Destination address. Dst value.Value // (optional) Atomic. Atomic bool // (optional) Volatile. Volatile bool // (optional) Sync scope; empty if not present. SyncScope string // (optional) Atomic memory ordering constraints; zero if not present. Ordering enum.AtomicOrdering // (optional) Alignment; zero if not present. Align Align // (optional) Metadata. Metadata }
InstStore is an LLVM IR store instruction.
func NewStore ¶
NewStore returns a new store instruction based on the given source value and destination address.
func (*InstStore) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
Store instruction.
'store' Volatileopt Src=TypeValue ',' Dst=TypeValue (',' Align)? Metadata=(',' MetadataAttachment)+?
Atomic store instruction.
'store' Atomic Volatileopt Src=TypeValue ',' Dst=TypeValue SyncScopeopt Ordering=AtomicOrdering (',' Align)? Metadata=(',' MetadataAttachment)+?
type InstSub ¶
type InstSub struct { // Name of local variable associated with the result. LocalIdent // Operands. X, Y value.Value // integer scalar or integer vector // Type of result produced by the instruction. Typ types.Type // (optional) Overflow flags. OverflowFlags []enum.OverflowFlag // (optional) Metadata. Metadata }
InstSub is an LLVM IR sub instruction.
func (*InstSub) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
'sub' OverflowFlags=OverflowFlag* X=TypeValue ',' Y=Value Metadata=(',' MetadataAttachment)+?
func (*InstSub) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type InstTrunc ¶
type InstTrunc struct { // Name of local variable associated with the result. LocalIdent // Value before conversion. From value.Value // Type after conversion. To types.Type // (optional) Metadata. Metadata }
InstTrunc is an LLVM IR trunc instruction.
func NewTrunc ¶
NewTrunc returns a new trunc instruction based on the given source value and target type.
func (*InstTrunc) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
'trunc' From=TypeValue 'to' To=Type Metadata=(',' MetadataAttachment)+?
func (*InstTrunc) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type InstUDiv ¶
type InstUDiv struct { // Name of local variable associated with the result. LocalIdent // Operands. X, Y value.Value // integer scalar or integer vector // Type of result produced by the instruction. Typ types.Type // (optional) Exact. Exact bool // (optional) Metadata. Metadata }
InstUDiv is an LLVM IR udiv instruction.
func (*InstUDiv) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
'udiv' Exactopt X=TypeValue ',' Y=Value Metadata=(',' MetadataAttachment)+?
func (*InstUDiv) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type InstUIToFP ¶
type InstUIToFP struct { // Name of local variable associated with the result. LocalIdent // Value before conversion. From value.Value // Type after conversion. To types.Type // (optional) Metadata. Metadata }
InstUIToFP is an LLVM IR uitofp instruction.
func NewUIToFP ¶
func NewUIToFP(from value.Value, to types.Type) *InstUIToFP
NewUIToFP returns a new uitofp instruction based on the given source value and target type.
func (*InstUIToFP) LLString ¶
func (inst *InstUIToFP) LLString() string
LLString returns the LLVM syntax representation of the instruction.
'uitofp' From=TypeValue 'to' To=Type Metadata=(',' MetadataAttachment)+?
func (*InstUIToFP) Operands ¶ added in v0.3.5
func (inst *InstUIToFP) Operands() []*value.Value
Operands returns a mutable list of operands of the given instruction.
func (*InstUIToFP) String ¶
func (inst *InstUIToFP) String() string
String returns the LLVM syntax representation of the instruction as a type-value pair.
func (*InstUIToFP) Type ¶
func (inst *InstUIToFP) Type() types.Type
Type returns the type of the instruction.
type InstURem ¶
type InstURem struct { // Name of local variable associated with the result. LocalIdent // Operands. X, Y value.Value // integer scalar or integer vector // Type of result produced by the instruction. Typ types.Type // (optional) Metadata. Metadata }
InstURem is an LLVM IR urem instruction.
func (*InstURem) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
'urem' X=TypeValue ',' Y=Value Metadata=(',' MetadataAttachment)+?
func (*InstURem) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type InstVAArg ¶
type InstVAArg struct { // Name of local variable associated with the result. LocalIdent // Variable argument list. ArgList value.Value // Argument type. ArgType types.Type // (optional) Metadata. Metadata }
InstVAArg is an LLVM IR va_arg instruction.
func NewVAArg ¶
NewVAArg returns a new va_arg instruction based on the given variable argument list and argument type.
func (*InstVAArg) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
'va_arg' ArgList=TypeValue ',' ArgType=Type Metadata=(',' MetadataAttachment)+?
func (*InstVAArg) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type InstXor ¶
type InstXor struct { // Name of local variable associated with the result. LocalIdent // Operands. X, Y value.Value // integer scalars or vectors // Type of result produced by the instruction. Typ types.Type // (optional) Metadata. Metadata }
InstXor is an LLVM IR xor instruction.
func (*InstXor) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
'xor' X=TypeValue ',' Y=Value Metadata=(',' MetadataAttachment)+?
func (*InstXor) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type InstZExt ¶
type InstZExt struct { // Name of local variable associated with the result. LocalIdent // Value before conversion. From value.Value // Type after conversion. To types.Type // (optional) Metadata. Metadata }
InstZExt is an LLVM IR zext instruction.
func NewZExt ¶
NewZExt returns a new zext instruction based on the given source value and target type.
func (*InstZExt) LLString ¶
LLString returns the LLVM syntax representation of the instruction.
'zext' From=TypeValue 'to' To=Type Metadata=(',' MetadataAttachment)+?
func (*InstZExt) Operands ¶ added in v0.3.5
Operands returns a mutable list of operands of the given instruction.
type Instruction ¶
type Instruction interface { LLStringer // Instruction implements the value.User interface. value.User // contains filtered or unexported methods }
Instruction is an LLVM IR instruction. All instructions (except store and fence) implement the value.Named interface and may thus be used directly as values.
An Instruction has one of the following underlying types.
Unary instructions ¶
https://llvm.org/docs/LangRef.html#unary-operations
*ir.InstFNeg // https://pkg.go.dev/github.com/llir/llvm/ir#InstFNeg
Binary instructions ¶
https://llvm.org/docs/LangRef.html#binary-operations
*ir.InstAdd // https://pkg.go.dev/github.com/llir/llvm/ir#InstAdd *ir.InstFAdd // https://pkg.go.dev/github.com/llir/llvm/ir#InstFAdd *ir.InstSub // https://pkg.go.dev/github.com/llir/llvm/ir#InstSub *ir.InstFSub // https://pkg.go.dev/github.com/llir/llvm/ir#InstFSub *ir.InstMul // https://pkg.go.dev/github.com/llir/llvm/ir#InstMul *ir.InstFMul // https://pkg.go.dev/github.com/llir/llvm/ir#InstFMul *ir.InstUDiv // https://pkg.go.dev/github.com/llir/llvm/ir#InstUDiv *ir.InstSDiv // https://pkg.go.dev/github.com/llir/llvm/ir#InstSDiv *ir.InstFDiv // https://pkg.go.dev/github.com/llir/llvm/ir#InstFDiv *ir.InstURem // https://pkg.go.dev/github.com/llir/llvm/ir#InstURem *ir.InstSRem // https://pkg.go.dev/github.com/llir/llvm/ir#InstSRem *ir.InstFRem // https://pkg.go.dev/github.com/llir/llvm/ir#InstFRem
Bitwise instructions ¶
https://llvm.org/docs/LangRef.html#bitwise-binary-operations
*ir.InstShl // https://pkg.go.dev/github.com/llir/llvm/ir#InstShl *ir.InstLShr // https://pkg.go.dev/github.com/llir/llvm/ir#InstLShr *ir.InstAShr // https://pkg.go.dev/github.com/llir/llvm/ir#InstAShr *ir.InstAnd // https://pkg.go.dev/github.com/llir/llvm/ir#InstAnd *ir.InstOr // https://pkg.go.dev/github.com/llir/llvm/ir#InstOr *ir.InstXor // https://pkg.go.dev/github.com/llir/llvm/ir#InstXor
Vector instructions ¶
https://llvm.org/docs/LangRef.html#vector-operations
*ir.InstExtractElement // https://pkg.go.dev/github.com/llir/llvm/ir#InstExtractElement *ir.InstInsertElement // https://pkg.go.dev/github.com/llir/llvm/ir#InstInsertElement *ir.InstShuffleVector // https://pkg.go.dev/github.com/llir/llvm/ir#InstShuffleVector
Aggregate instructions ¶
https://llvm.org/docs/LangRef.html#aggregate-operations
*ir.InstExtractValue // https://pkg.go.dev/github.com/llir/llvm/ir#InstExtractValue *ir.InstInsertValue // https://pkg.go.dev/github.com/llir/llvm/ir#InstInsertValue
Memory instructions ¶
https://llvm.org/docs/LangRef.html#memory-access-and-addressing-operations
*ir.InstAlloca // https://pkg.go.dev/github.com/llir/llvm/ir#InstAlloca *ir.InstLoad // https://pkg.go.dev/github.com/llir/llvm/ir#InstLoad *ir.InstStore // https://pkg.go.dev/github.com/llir/llvm/ir#InstStore *ir.InstFence // https://pkg.go.dev/github.com/llir/llvm/ir#InstFence *ir.InstCmpXchg // https://pkg.go.dev/github.com/llir/llvm/ir#InstCmpXchg *ir.InstAtomicRMW // https://pkg.go.dev/github.com/llir/llvm/ir#InstAtomicRMW *ir.InstGetElementPtr // https://pkg.go.dev/github.com/llir/llvm/ir#InstGetElementPtr
Conversion instructions ¶
https://llvm.org/docs/LangRef.html#conversion-operations
*ir.InstTrunc // https://pkg.go.dev/github.com/llir/llvm/ir#InstTrunc *ir.InstZExt // https://pkg.go.dev/github.com/llir/llvm/ir#InstZExt *ir.InstSExt // https://pkg.go.dev/github.com/llir/llvm/ir#InstSExt *ir.InstFPTrunc // https://pkg.go.dev/github.com/llir/llvm/ir#InstFPTrunc *ir.InstFPExt // https://pkg.go.dev/github.com/llir/llvm/ir#InstFPExt *ir.InstFPToUI // https://pkg.go.dev/github.com/llir/llvm/ir#InstFPToUI *ir.InstFPToSI // https://pkg.go.dev/github.com/llir/llvm/ir#InstFPToSI *ir.InstUIToFP // https://pkg.go.dev/github.com/llir/llvm/ir#InstUIToFP *ir.InstSIToFP // https://pkg.go.dev/github.com/llir/llvm/ir#InstSIToFP *ir.InstPtrToInt // https://pkg.go.dev/github.com/llir/llvm/ir#InstPtrToInt *ir.InstIntToPtr // https://pkg.go.dev/github.com/llir/llvm/ir#InstIntToPtr *ir.InstBitCast // https://pkg.go.dev/github.com/llir/llvm/ir#InstBitCast *ir.InstAddrSpaceCast // https://pkg.go.dev/github.com/llir/llvm/ir#InstAddrSpaceCast
Other instructions ¶
https://llvm.org/docs/LangRef.html#other-operations
*ir.InstICmp // https://pkg.go.dev/github.com/llir/llvm/ir#InstICmp *ir.InstFCmp // https://pkg.go.dev/github.com/llir/llvm/ir#InstFCmp *ir.InstPhi // https://pkg.go.dev/github.com/llir/llvm/ir#InstPhi *ir.InstSelect // https://pkg.go.dev/github.com/llir/llvm/ir#InstSelect *ir.InstFreeze // https://pkg.go.dev/github.com/llir/llvm/ir#InstFreeze *ir.InstCall // https://pkg.go.dev/github.com/llir/llvm/ir#InstCall *ir.InstVAArg // https://pkg.go.dev/github.com/llir/llvm/ir#InstVAArg *ir.InstLandingPad // https://pkg.go.dev/github.com/llir/llvm/ir#InstLandingPad *ir.InstCatchPad // https://pkg.go.dev/github.com/llir/llvm/ir#InstCatchPad *ir.InstCleanupPad // https://pkg.go.dev/github.com/llir/llvm/ir#InstCleanupPad
type LLStringer ¶
type LLStringer interface { // LLString returns the LLVM syntax representation of the value. LLString() string }
LLStringer is implemented by any value that has a LLString method, which defines the LLVM syntax for that value.
type LocalIdent ¶
LocalIdent is a local identifier.
func NewLocalIdent ¶
func NewLocalIdent(ident string) LocalIdent
NewLocalIdent returns a new local identifier based on the given string. An unnamed local ID is used if ident is an integer, and a local name otherwise.
func (LocalIdent) Ident ¶
func (i LocalIdent) Ident() string
Ident returns the identifier associated with the local identifier.
func (LocalIdent) IsUnnamed ¶
func (i LocalIdent) IsUnnamed() bool
IsUnnamed reports whether the local identifier is unnamed.
func (LocalIdent) Name ¶
func (i LocalIdent) Name() string
Name returns the name of the local identifier.
If unnamed, the local ID is returned. To distinguish numeric names from unnamed IDs, numeric names are quoted.
func (*LocalIdent) SetID ¶
func (i *LocalIdent) SetID(id int64)
SetID sets the ID of the local identifier.
func (*LocalIdent) SetName ¶
func (i *LocalIdent) SetName(name string)
SetName sets the name of the local identifier.
type Metadata ¶
type Metadata []*metadata.Attachment
Metadata is a list of metadata attachments.
func (Metadata) MDAttachments ¶
func (mds Metadata) MDAttachments() []*metadata.Attachment
MDAttachments returns the metadata attachments of the value.
type Module ¶
type Module struct { // Type definitions. TypeDefs []types.Type // Global variable declarations and definitions. Globals []*Global // Function declarations and definitions. Funcs []*Func // (optional) Source filename; or empty if not present. SourceFilename string // (optional) Data layout; or empty if not present. DataLayout string // (optional) Target triple; or empty if not present. TargetTriple string // (optional) Module-level inline assembly. ModuleAsms []string // (optional) Comdat definitions. ComdatDefs []*ComdatDef // (optional) Aliases. Aliases []*Alias // (optional) IFuncs. IFuncs []*IFunc // (optional) Attribute group definitions. AttrGroupDefs []*AttrGroupDef // (optional) Named metadata definitions. NamedMetadataDefs map[string]*metadata.NamedDef // (optional) Metadata definitions. MetadataDefs []metadata.Definition // (optional) Use-list order directives. UseListOrders []*UseListOrder // (optional) Basic block specific use-list order directives. UseListOrderBBs []*UseListOrderBB // contains filtered or unexported fields }
Module is an LLVM IR module, which consists of top-level declarations and definitions.
func (*Module) AssignGlobalIDs ¶ added in v0.3.3
AssignGlobalIDs assigns IDs to unnamed global variables.
func (*Module) AssignMetadataIDs ¶
AssignMetadataIDs assigns metadata IDs to the unnamed metadata definitions of the module.
func (*Module) NewAlias ¶
NewAlias appends a new alias to the module based on the given alias name and aliasee.
func (*Module) NewFunc ¶
NewFunc appends a new function to the module based on the given function name, return type and function parameters.
The Parent field of the function is set to m.
func (*Module) NewGlobal ¶
NewGlobal appends a new global variable declaration to the module based on the given global variable name and content type.
func (*Module) NewGlobalDef ¶
NewGlobalDef appends a new global variable definition to the module based on the given global variable name and initial value.
func (*Module) NewIFunc ¶
NewIFunc appends a new indirect function to the module based on the given IFunc name and resolver.
func (*Module) NewTypeDef ¶
NewTypeDef appends a new type definition to the module based on the given type name and underlying type.
type OperandBundle ¶
OperandBundle is a tagged set of SSA values associated with a call-site.
func NewOperandBundle ¶
func NewOperandBundle(tag string, inputs ...value.Value) *OperandBundle
NewOperandBundle returns a new operand bundle based on the given tag and input values.
func (*OperandBundle) String ¶
func (o *OperandBundle) String() string
String returns a string representation of the operand bundle.
type Param ¶
type Param struct { // (optional) Parameter name (without '%' prefix). LocalIdent // Parameter type. Typ types.Type // (optional) Parameter attributes. Attrs []ParamAttribute }
Param is an LLVM IR function parameter.
func (*Param) LLString ¶
LLString returns the LLVM syntax representation of the function parameter.
Typ=Type Attrs=ParamAttribute* Name=LocalIdent?
type ParamAttribute ¶
type ParamAttribute interface { fmt.Stringer // IsParamAttribute ensures that only parameter attributes can be assigned to // the ir.ParamAttribute interface. IsParamAttribute() }
ParamAttribute is a parameter attribute.
A ParamAttribute has one of the following underlying types.
ir.AttrString ir.AttrPair ir.Align ir.Dereferenceable enum.ParamAttr
type Preallocated ¶ added in v0.3.3
Preallocated is a func/param attribute.
func (Preallocated) IsFuncAttribute ¶ added in v0.3.3
func (Preallocated) IsFuncAttribute()
IsFuncAttribute ensures that only parameter attributes can be assigned to the ir.ParamAttribute interface.
func (Preallocated) IsParamAttribute ¶ added in v0.3.3
func (Preallocated) IsParamAttribute()
IsParamAttribute ensures that only parameter attributes can be assigned to the ir.ParamAttribute interface.
func (Preallocated) String ¶ added in v0.3.3
func (p Preallocated) String() string
String returns a string representation of the Preallocated attribute.
type ReturnAttribute ¶
type ReturnAttribute interface { fmt.Stringer // IsReturnAttribute ensures that only return attributes can be assigned to // the ir.ReturnAttribute interface. IsReturnAttribute() }
ReturnAttribute is a return attribute.
A ReturnAttribute has one of the following underlying types.
ir.AttrString ir.AttrPair ir.Align ir.Dereferenceable enum.ReturnAttr
type SRet ¶ added in v0.3.4
SRet is an sret parameter attribute.
func (SRet) IsParamAttribute ¶ added in v0.3.4
func (SRet) IsParamAttribute()
IsParamAttribute ensures that only parameter attributes can be assigned to the ir.ParamAttribute interface.
type TermBr ¶
type TermBr struct { // Target branch. Target value.Value // *ir.Block // Successor basic blocks of the terminator. Successors []*Block // (optional) Metadata. Metadata }
TermBr is an unconditional LLVM IR br terminator.
func (*TermBr) LLString ¶
LLString returns the LLVM syntax representation of the terminator.
'br' Target=Label Metadata=(',' MetadataAttachment)+?
type TermCallBr ¶
type TermCallBr struct { // Name of local variable associated with the result. LocalIdent // Callee function. // TODO: specify the set of underlying types of Callee. Callee value.Value // Function arguments. // // Arg has one of the following underlying types: // value.Value // TODO: add metadata value? Args []value.Value // Normal control flow return point. NormalRetTarget value.Value // *ir.Block // Other control flow return points. OtherRetTargets []value.Value // slice of *ir.Block // Type of result produced by the terminator. Typ types.Type // Successor basic blocks of the terminator. Successors []*Block // (optional) Calling convention; zero if not present. CallingConv enum.CallingConv // (optional) Return attributes. ReturnAttrs []ReturnAttribute // (optional) Address space; zero if not present. AddrSpace types.AddrSpace // (optional) Function attributes. FuncAttrs []FuncAttribute // (optional) Operand bundles. OperandBundles []*OperandBundle // (optional) Metadata. Metadata }
TermCallBr is an LLVM IR callbr terminator.
func NewCallBr ¶
func NewCallBr(callee value.Value, args []value.Value, normalRetTarget *Block, otherRetTargets ...*Block) *TermCallBr
NewCallBr returns a new callbr terminator based on the given callee, function arguments and control flow return points for normal and exceptional execution.
TODO: specify the set of underlying types of callee.
func (*TermCallBr) LLString ¶
func (term *TermCallBr) LLString() string
LLString returns the LLVM syntax representation of the terminator.
'callbr' CallingConvopt ReturnAttrs=ReturnAttribute* AddrSpaceopt Typ=Type Callee=Value '(' Args ')' FuncAttrs=FuncAttribute* OperandBundles=('[' (OperandBundle separator ',')+ ']')? 'to' NormalRetTarget=Label '[' OtherRetTargets=(Label separator ',')* ']' Metadata=(',' MetadataAttachment)+?
func (*TermCallBr) Operands ¶ added in v0.3.5
func (term *TermCallBr) Operands() []*value.Value
Operands returns a mutable list of operands of the given terminator.
func (*TermCallBr) Sig ¶
func (term *TermCallBr) Sig() *types.FuncType
Sig returns the function signature of the callee.
func (*TermCallBr) String ¶
func (term *TermCallBr) String() string
String returns the LLVM syntax representation of the terminator as a type- value pair.
func (*TermCallBr) Succs ¶
func (term *TermCallBr) Succs() []*Block
Succs returns the successor basic blocks of the terminator.
func (*TermCallBr) Type ¶
func (term *TermCallBr) Type() types.Type
Type returns the type of the terminator.
type TermCatchRet ¶
type TermCatchRet struct { // Exit catchpad. CatchPad value.Value // *ir.InstCatchPad // Target basic block to transfer control flow to. Target value.Value // *ir.Block // Successor basic blocks of the terminator. Successors []*Block // (optional) Metadata. Metadata }
TermCatchRet is an LLVM IR catchret terminator, which catches an in-flight exception from CatchPad and returns control flow to normal at Target.
func NewCatchRet ¶
func NewCatchRet(catchPad *InstCatchPad, target *Block) *TermCatchRet
NewCatchRet returns a new catchret terminator based on the given exit catchpad and target basic block.
func (*TermCatchRet) LLString ¶
func (term *TermCatchRet) LLString() string
LLString returns the LLVM syntax representation of the terminator.
'catchret' 'from' CatchPad=Value 'to' Target=Label Metadata=(',' MetadataAttachment)+?
func (*TermCatchRet) Operands ¶ added in v0.3.5
func (term *TermCatchRet) Operands() []*value.Value
Operands returns a mutable list of operands of the given terminator.
func (*TermCatchRet) Succs ¶
func (term *TermCatchRet) Succs() []*Block
Succs returns the successor basic blocks of the terminator.
type TermCatchSwitch ¶
type TermCatchSwitch struct { // Name of local variable associated with the result. LocalIdent // Parent exception pad. ParentPad value.Value // ir.ExceptionPad // Exception handlers. Handlers []value.Value // []*ir.Block // Optional default target basic block to transfer control flow to; or nil to // unwind to caller function. DefaultUnwindTarget value.Value // *ir.Block or nil // Successor basic blocks of the terminator. Successors []*Block // (optional) Metadata. Metadata }
TermCatchSwitch is an LLVM IR catchswitch terminator.
func NewCatchSwitch ¶
func NewCatchSwitch(parentPad ExceptionPad, handlers []*Block, defaultUnwindTarget *Block) *TermCatchSwitch
NewCatchSwitch returns a new catchswitch terminator based on the given parent exception pad, exception handlers and optional default unwind target. If defaultUnwindTarget is nil, catchswitch unwinds to caller function.
func (*TermCatchSwitch) LLString ¶
func (term *TermCatchSwitch) LLString() string
LLString returns the LLVM syntax representation of the terminator.
'catchswitch' 'within' ParentPad=ExceptionPad '[' Handlers=Handlers ']' 'unwind' DefaultUnwindTarget=UnwindTarget Metadata=(',' MetadataAttachment)+?
func (*TermCatchSwitch) Operands ¶ added in v0.3.5
func (term *TermCatchSwitch) Operands() []*value.Value
Operands returns a mutable list of operands of the given terminator.
func (*TermCatchSwitch) String ¶
func (term *TermCatchSwitch) String() string
String returns the LLVM syntax representation of the terminator as a type- value pair.
func (*TermCatchSwitch) Succs ¶
func (term *TermCatchSwitch) Succs() []*Block
Succs returns the successor basic blocks of the terminator.
func (*TermCatchSwitch) Type ¶
func (term *TermCatchSwitch) Type() types.Type
Type returns the type of the terminator.
type TermCleanupRet ¶
type TermCleanupRet struct { // Exit cleanuppad. CleanupPad value.Value // *ir.InstCleanupPad // Optional target basic block to transfer control flow to; or nil to unwind // to caller function. UnwindTarget value.Value // *ir.Block or nil // Successor basic blocks of the terminator. Successors []*Block // (optional) Metadata. Metadata }
TermCleanupRet is an LLVM IR cleanupret terminator, which indicates that the personality function of a cleanuppad has finished and transfers control flow to an optional target basic block or unwinds to the caller function.
func NewCleanupRet ¶
func NewCleanupRet(cleanupPad *InstCleanupPad, unwindTarget *Block) *TermCleanupRet
NewCleanupRet returns a new cleanupret terminator based on the given exit cleanuppad and optional unwind target. If unwindTarget is nil, cleanupret unwinds to caller function.
func (*TermCleanupRet) LLString ¶
func (term *TermCleanupRet) LLString() string
LLString returns the LLVM syntax representation of the terminator.
'cleanupret' 'from' CleanupPad=Value 'unwind' UnwindTarget Metadata=(',' MetadataAttachment)+?
func (*TermCleanupRet) Operands ¶ added in v0.3.5
func (term *TermCleanupRet) Operands() []*value.Value
Operands returns a mutable list of operands of the given terminator.
func (*TermCleanupRet) Succs ¶
func (term *TermCleanupRet) Succs() []*Block
Succs returns the successor basic blocks of the terminator.
type TermCondBr ¶
type TermCondBr struct { // Branching condition. Cond value.Value // True condition target branch. TargetTrue value.Value // *ir.Block // False condition target branch. TargetFalse value.Value // *ir.Block // Successor basic blocks of the terminator. Successors []*Block // (optional) Metadata. Metadata }
TermCondBr is a conditional LLVM IR br terminator.
func NewCondBr ¶
func NewCondBr(cond value.Value, targetTrue, targetFalse *Block) *TermCondBr
NewCondBr returns a new conditional br terminator based on the given branching condition and conditional target basic blocks.
func (*TermCondBr) LLString ¶
func (term *TermCondBr) LLString() string
LLString returns the LLVM syntax representation of the terminator.
'br' CondTyp=IntType Cond=Value ',' TargetTrue=Label ',' TargetFalse=Label Metadata=(',' MetadataAttachment)+?
func (*TermCondBr) Operands ¶ added in v0.3.5
func (term *TermCondBr) Operands() []*value.Value
Operands returns a mutable list of operands of the given terminator.
func (*TermCondBr) Succs ¶
func (term *TermCondBr) Succs() []*Block
Succs returns the successor basic blocks of the terminator.
type TermIndirectBr ¶
type TermIndirectBr struct { // Target address. Addr value.Value // blockaddress // Set of valid target basic blocks. ValidTargets []value.Value // slice of *ir.Block // Successor basic blocks of the terminator. Successors []*Block // (optional) Metadata. Metadata }
TermIndirectBr is an LLVM IR indirectbr terminator.
func NewIndirectBr ¶
func NewIndirectBr(addr value.Value, validTargets ...*Block) *TermIndirectBr
NewIndirectBr returns a new indirectbr terminator based on the given target address (derived from a blockaddress constant of type i8*) and set of valid target basic blocks.
func (*TermIndirectBr) LLString ¶
func (term *TermIndirectBr) LLString() string
LLString returns the LLVM syntax representation of the terminator.
'indirectbr' Addr=TypeValue ',' '[' ValidTargets=(Label separator ',')* ']' Metadata=(',' MetadataAttachment)+?
func (*TermIndirectBr) Operands ¶ added in v0.3.5
func (term *TermIndirectBr) Operands() []*value.Value
Operands returns a mutable list of operands of the given terminator.
func (*TermIndirectBr) Succs ¶
func (term *TermIndirectBr) Succs() []*Block
Succs returns the successor basic blocks of the terminator.
type TermInvoke ¶
type TermInvoke struct { // Name of local variable associated with the result. LocalIdent // Invokee (callee function). // TODO: specify the set of underlying types of Invokee. Invokee value.Value // Function arguments. // // Arg has one of the following underlying types: // value.Value // TODO: add metadata value? Args []value.Value // Normal control flow return point. NormalRetTarget value.Value // *ir.Block // Exception control flow return point. ExceptionRetTarget value.Value // *ir.Block // Type of result produced by the terminator. Typ types.Type // Successor basic blocks of the terminator. Successors []*Block // (optional) Calling convention; zero if not present. CallingConv enum.CallingConv // (optional) Return attributes. ReturnAttrs []ReturnAttribute // (optional) Address space; zero if not present. AddrSpace types.AddrSpace // (optional) Function attributes. FuncAttrs []FuncAttribute // (optional) Operand bundles. OperandBundles []*OperandBundle // (optional) Metadata. Metadata }
TermInvoke is an LLVM IR invoke terminator.
func NewInvoke ¶
func NewInvoke(invokee value.Value, args []value.Value, normalRetTarget, exceptionRetTarget *Block) *TermInvoke
NewInvoke returns a new invoke terminator based on the given invokee, function arguments and control flow return points for normal and exceptional execution.
TODO: specify the set of underlying types of invokee.
func (*TermInvoke) LLString ¶
func (term *TermInvoke) LLString() string
LLString returns the LLVM syntax representation of the terminator.
'invoke' CallingConvopt ReturnAttrs=ReturnAttribute* AddrSpaceopt Typ=Type Invokee=Value '(' Args ')' FuncAttrs=FuncAttribute* OperandBundles=('[' (OperandBundle separator ',')+ ']')? 'to' NormalRetTarget=Label 'unwind' ExceptionRetTarget=Label Metadata=(',' MetadataAttachment)+?
func (*TermInvoke) Operands ¶ added in v0.3.5
func (term *TermInvoke) Operands() []*value.Value
Operands returns a mutable list of operands of the given terminator.
func (*TermInvoke) Sig ¶
func (term *TermInvoke) Sig() *types.FuncType
Sig returns the function signature of the invokee.
func (*TermInvoke) String ¶
func (term *TermInvoke) String() string
String returns the LLVM syntax representation of the terminator as a type- value pair.
func (*TermInvoke) Succs ¶
func (term *TermInvoke) Succs() []*Block
Succs returns the successor basic blocks of the terminator.
func (*TermInvoke) Type ¶
func (term *TermInvoke) Type() types.Type
Type returns the type of the terminator.
type TermResume ¶
type TermResume struct { // Exception argument to propagate. X value.Value // (optional) Metadata. Metadata }
TermResume is an LLVM IR resume terminator.
func NewResume ¶
func NewResume(x value.Value) *TermResume
NewResume returns a new resume terminator based on the given exception argument to propagate.
func (*TermResume) LLString ¶
func (term *TermResume) LLString() string
LLString returns the LLVM syntax representation of the terminator.
'resume' X=TypeValue Metadata=(',' MetadataAttachment)+?
func (*TermResume) Operands ¶ added in v0.3.5
func (term *TermResume) Operands() []*value.Value
Operands returns a mutable list of operands of the given terminator.
func (*TermResume) Succs ¶
func (term *TermResume) Succs() []*Block
Succs returns the successor basic blocks of the terminator.
type TermRet ¶
type TermRet struct { // Return value; or nil if void return. X value.Value // (optional) Metadata. Metadata }
TermRet is an LLVM IR ret terminator.
func NewRet ¶
NewRet returns a new ret terminator based on the given return value. A nil return value indicates a void return.
func (*TermRet) LLString ¶
LLString returns the LLVM syntax representation of the terminator.
Void return instruction.
'ret' XTyp=VoidType Metadata=(',' MetadataAttachment)+?
Value return instruction.
'ret' XTyp=ConcreteType X=Value Metadata=(',' MetadataAttachment)+?
type TermSwitch ¶
type TermSwitch struct { // Control variable. X value.Value // Default target branch. TargetDefault value.Value // *ir.Block // Switch cases. Cases []*Case // Successor basic blocks of the terminator. Successors []*Block // (optional) Metadata. Metadata }
TermSwitch is an LLVM IR switch terminator.
func NewSwitch ¶
func NewSwitch(x value.Value, targetDefault *Block, cases ...*Case) *TermSwitch
NewSwitch returns a new switch terminator based on the given control variable, default target basic block and switch cases.
func (*TermSwitch) LLString ¶
func (term *TermSwitch) LLString() string
LLString returns the LLVM syntax representation of the terminator.
'switch' X=TypeValue ',' Default=Label '[' Cases=Case* ']' Metadata=(',' MetadataAttachment)+?
func (*TermSwitch) Operands ¶ added in v0.3.5
func (term *TermSwitch) Operands() []*value.Value
Operands returns a mutable list of operands of the given terminator.
func (*TermSwitch) Succs ¶
func (term *TermSwitch) Succs() []*Block
Succs returns the successor basic blocks of the terminator.
type TermUnreachable ¶
type TermUnreachable struct { // (optional) Metadata. Metadata }
TermUnreachable is an LLVM IR unreachable terminator.
func NewUnreachable ¶
func NewUnreachable() *TermUnreachable
NewUnreachable returns a new unreachable terminator.
func (*TermUnreachable) LLString ¶
func (term *TermUnreachable) LLString() string
LLString returns the LLVM syntax representation of the terminator.
'unreachable' Metadata=(',' MetadataAttachment)+?
func (*TermUnreachable) Operands ¶ added in v0.3.5
func (term *TermUnreachable) Operands() []*value.Value
Operands returns a mutable list of operands of the given terminator.
func (*TermUnreachable) Succs ¶
func (term *TermUnreachable) Succs() []*Block
Succs returns the successor basic blocks of the terminator.
type Terminator ¶
type Terminator interface { LLStringer // Succs returns the successor basic blocks of the terminator. Succs() []*Block // Terminator implements the value.User interface. value.User }
Terminator is an LLVM IR terminator instruction (a control flow instruction).
A Terminator has one of the following underlying types.
Terminators ¶
https://llvm.org/docs/LangRef.html#terminator-instructions
*ir.TermRet // https://pkg.go.dev/github.com/llir/llvm/ir#TermRet *ir.TermBr // https://pkg.go.dev/github.com/llir/llvm/ir#TermBr *ir.TermCondBr // https://pkg.go.dev/github.com/llir/llvm/ir#TermCondBr *ir.TermSwitch // https://pkg.go.dev/github.com/llir/llvm/ir#TermSwitch *ir.TermIndirectBr // https://pkg.go.dev/github.com/llir/llvm/ir#TermIndirectBr *ir.TermInvoke // https://pkg.go.dev/github.com/llir/llvm/ir#TermInvoke *ir.TermCallBr // https://pkg.go.dev/github.com/llir/llvm/ir#TermCallBr *ir.TermResume // https://pkg.go.dev/github.com/llir/llvm/ir#TermResume *ir.TermCatchSwitch // https://pkg.go.dev/github.com/llir/llvm/ir#TermCatchSwitch *ir.TermCatchRet // https://pkg.go.dev/github.com/llir/llvm/ir#TermCatchRet *ir.TermCleanupRet // https://pkg.go.dev/github.com/llir/llvm/ir#TermCleanupRet *ir.TermUnreachable // https://pkg.go.dev/github.com/llir/llvm/ir#TermUnreachable
type UseListOrder ¶
UseListOrder is a use-list order directive.
func (*UseListOrder) String ¶
func (u *UseListOrder) String() string
String returns the string representation of the use-list order directive definition.
type UseListOrderBB ¶
type UseListOrderBB struct { // Function. Func *Func // Basic block. Block *Block // Use-list order. Indices []uint64 }
UseListOrderBB is a basic block specific use-list order directive.
func (*UseListOrderBB) String ¶
func (u *UseListOrderBB) String() string
String returns the string representation of the basic block specific use- list order directive definition.
type VectorScaleRange ¶ added in v0.3.5
VectorScaleRange denotes the min/max vector scale value of a given function. If the second parameter is omitted, Min will be -1.
func (VectorScaleRange) IsFuncAttribute ¶ added in v0.3.5
func (VectorScaleRange) IsFuncAttribute()
IsFuncAttribute ensures that only parameter attributes can be assigned to the ir.ParamAttribute interface.
func (VectorScaleRange) String ¶ added in v0.3.5
func (a VectorScaleRange) String() string
String returns the string representation of the vscale_range attribute.
Source Files ¶
- alias.go
- block.go
- block_aggregate.go
- block_binary.go
- block_bitwise.go
- block_conversion.go
- block_memory.go
- block_other.go
- block_term.go
- block_unary.go
- block_vector.go
- func.go
- func_block.go
- global.go
- helper.go
- ifunc.go
- inline_asm.go
- inst_aggregate.go
- inst_binary.go
- inst_bitwise.go
- inst_conversion.go
- inst_memory.go
- inst_other.go
- inst_unary.go
- inst_vector.go
- instruction.go
- ir.go
- module.go
- module_alias.go
- module_func.go
- module_global.go
- module_ifunc.go
- module_type.go
- sumtype.go
- terminator.go
Directories ¶
Path | Synopsis |
---|---|
Package constant implements values representing immutable LLVM IR constants.
|
Package constant implements values representing immutable LLVM IR constants. |
Package enum defines enumerate types of LLVM IR.
|
Package enum defines enumerate types of LLVM IR. |
Package metadata provides access to LLVM IR metadata.
|
Package metadata provides access to LLVM IR metadata. |
Package types declares the data types of LLVM IR.
|
Package types declares the data types of LLVM IR. |
Package value provides a definition of LLVM IR values.
|
Package value provides a definition of LLVM IR values. |