ir

package

Go to main page

Versions in this module

v1

v1.22.2

Apr 24, 2024

Changes in this version

+ func IsFuncPCIntrinsic(n *CallExpr) bool

+ func LookupMethodSelector(pkg *types.Pkg, name string) (typ, meth *types.Sym, err error)

+ func ParseLinkFuncName(name string) (pkg, sym string, err error)

+ func Reassigned(name *Name) bool

type CallExpr

+ DeferAt Node

+ Fun Node

+ GoDefer bool

type Func

+ func IsIfaceOfFunc(n Node) *Func

+ func (f *Func) ClosureResultsLost() bool

+ func (f *Func) NeverReturns() bool

+ func (f *Func) SetClosureResultsLost(b bool)

+ func (f *Func) SetNeverReturns(b bool)

+ func (fn *Func) DeclareParams(setNname bool)

+ func (fn *Func) NewLocal(pos src.XPos, sym *types.Sym, typ *types.Type) *Name

type GoDeferStmt

+ DeferAt Expr

type Inline

+ HaveDcl bool

+ Properties string

+ type InterfaceSwitchStmt struct

+ Case Node

+ Descriptor *obj.LSym

+ Hash Node

+ Itab Node

+ RuntimeType Node

+ func NewInterfaceSwitchStmt(pos src.XPos, case_, itab, runtimeType, hash Node, descriptor *obj.LSym) *InterfaceSwitchStmt

+ func (n *InterfaceSwitchStmt) Format(s fmt.State, verb rune)

+ func (n *InterfaceSwitchStmt) Init() Nodes

+ func (n *InterfaceSwitchStmt) PtrInit() *Nodes

+ func (n *InterfaceSwitchStmt) SetInit(x Nodes)

type Name

+ func NewBuiltin(sym *types.Sym, op Op) *Name

+ func StaticCalleeName(n Node) *Name

type Node

+ func FuncPC(pos src.XPos, n Node, wantABI obj.ABI) Node

+ func NewOne(pos src.XPos, typ *types.Type) Node

+ func NewUintptr(pos src.XPos, v int64) Node

+ func NewZero(pos src.XPos, typ *types.Type) Node

type Nodes

+ func ToNodes[T Node](s []T) Nodes

type Op

+ const OINTERFACESWITCH

+ const OMAKEFACE

+ const OPRINTLN

type Package

+ AsmHdrDecls []*Name

+ Funcs []*Func

+ PluginExports []*Name

+ type ReassignOracle struct

+ func (ro *ReassignOracle) Init(fn *Func)

+ func (ro *ReassignOracle) Reassigned(n *Name) bool

+ func (ro *ReassignOracle) StaticValue(n Node) Node

type TypeAssertExpr

+ Descriptor *obj.LSym

v1.21.3

Jan 6, 2024

v1.21.0

Dec 26, 2023

Changes in this version

+ const ConstPrec

+ const EscHeap

+ const EscNever

+ const EscNone

+ const EscUnknown

+ var EscFmt func(n Node) string

+ var IsIntrinsicCall = func(*CallExpr) bool

+ var MaxImplicitStackVarSize = int64(64 * 1024)

+ var MaxSmallArraySize = int64(256)

+ var MaxStackVarSize = int64(10 * 1024 * 1024)

+ var OKForConst [types.NTYPE]bool

+ var OpNames = []string

+ var OpPrec = []int

+ var Pkgs struct

+ var Syms struct

+ func Any(n Node, cond func(Node) bool) bool

+ func AnyList(list Nodes, cond func(Node) bool) bool

+ func AssertValidTypeForConst(t *types.Type, v constant.Value)

+ func BigFloat(v constant.Value) *big.Float

+ func BoolVal(n Node) bool

+ func ClosureDebugRuntimeCheck(clo *ClosureExpr)

+ func ConstOverflow(v constant.Value, t *types.Type) bool

+ func ConstType(n Node) constant.Kind

+ func DeclaredBy(x, stmt Node) bool

+ func DoChildren(n Node, do func(Node) bool) bool

+ func Dump(s string, n Node)

+ func DumpAny(root interface{}, filter string, depth int)

+ func DumpList(s string, list Nodes)

+ func EditChildren(n Node, edit func(Node) Node)

+ func EditChildrenWithHidden(n Node, edit func(Node) Node)

+ func FDumpAny(w io.Writer, root interface{}, filter string, depth int)

+ func FDumpList(w io.Writer, s string, list Nodes)

+ func FinishCaptureNames(pos src.XPos, outerfn, fn *Func)

+ func FuncName(f *Func) string

+ func FuncSymName(s *types.Sym) string

+ func HasNamedResults(fn *Func) bool

+ func HasUniquePos(n Node) bool

+ func InitLSym(f *Func, hasBody bool)

+ func Int64Val(n Node) int64

+ func IntVal(t *types.Type, v constant.Value) int64

+ func IsAddressable(n Node) bool

+ func IsAutoTmp(n Node) bool

+ func IsBlank(n Node) bool

+ func IsConst(n Node, ct constant.Kind) bool

+ func IsConstNode(n Node) bool

+ func IsEqOrHashFunc(f *Func) bool

+ func IsMethod(n Node) bool

+ func IsNil(n Node) bool

+ func IsReflectHeaderDataField(l Node) bool

+ func IsSmallIntConst(n Node) bool

+ func IsSynthetic(n Node) bool

+ func IsTrivialClosure(clo *ClosureExpr) bool

+ func IsZero(n Node) bool

+ func Line(n Node) string

+ func LinkFuncName(f *Func) string

+ func MarkFunc(n *Name)

+ func MayBeShared(n Node) bool

+ func MethodExprFunc(n Node) *types.Field

+ func MethodSym(recv *types.Type, msym *types.Sym) *types.Sym

+ func MethodSymSuffix(recv *types.Type, msym *types.Sym, suffix string) *types.Sym

+ func NameClosure(clo *ClosureExpr, outerfn *Func)

+ func PkgFuncName(f *Func) string

+ func SameSafeExpr(l Node, r Node) bool

+ func SameSource(n1, n2 Node) bool

+ func SetPos(n Node) src.XPos

+ func ShouldAsanCheckPtr(fn *Func) bool

+ func ShouldCheckPtr(fn *Func, level int) bool

+ func StmtWithInit(op Op) bool

+ func StringVal(n Node) string

+ func Uint64Val(n Node) uint64

+ func Uses(x Node, v *Name) bool

+ func ValidTypeForConst(t *types.Type, v constant.Value) bool

+ func Visit(n Node, visit func(Node))

+ func VisitFuncAndClosures(fn *Func, visit func(n Node))

+ func VisitFuncsBottomUp(list []Node, analyze func(list []*Func, recursive bool))

+ func VisitList(list Nodes, visit func(Node))

+ func WithFunc(curfn *Func, do func())

+ type AddStringExpr struct

+ List Nodes

+ Prealloc *Name

+ func NewAddStringExpr(pos src.XPos, list []Node) *AddStringExpr

+ func (n *AddStringExpr) Bounded() bool

+ func (n *AddStringExpr) Format(s fmt.State, verb rune)

+ func (n *AddStringExpr) Init() Nodes

+ func (n *AddStringExpr) MarkNonNil()

+ func (n *AddStringExpr) NonNil() bool

+ func (n *AddStringExpr) PtrInit() *Nodes

+ func (n *AddStringExpr) SetBounded(b bool)

+ func (n *AddStringExpr) SetInit(x Nodes)

+ func (n *AddStringExpr) SetTransient(b bool)

+ func (n *AddStringExpr) SetType(x *types.Type)

+ func (n *AddStringExpr) Transient() bool

+ func (n *AddStringExpr) Type() *types.Type

+ type AddrExpr struct

+ Prealloc *Name

+ X Node

+ func NewAddrExpr(pos src.XPos, x Node) *AddrExpr

+ func (n *AddrExpr) Bounded() bool

+ func (n *AddrExpr) Format(s fmt.State, verb rune)

+ func (n *AddrExpr) Implicit() bool

+ func (n *AddrExpr) Init() Nodes

+ func (n *AddrExpr) MarkNonNil()

+ func (n *AddrExpr) NonNil() bool

+ func (n *AddrExpr) PtrInit() *Nodes

+ func (n *AddrExpr) SetBounded(b bool)

+ func (n *AddrExpr) SetImplicit(b bool)

+ func (n *AddrExpr) SetInit(x Nodes)

+ func (n *AddrExpr) SetOp(op Op)

+ func (n *AddrExpr) SetTransient(b bool)

+ func (n *AddrExpr) SetType(x *types.Type)

+ func (n *AddrExpr) Transient() bool

+ func (n *AddrExpr) Type() *types.Type

+ type AssignListStmt struct

+ Def bool

+ Lhs Nodes

+ Rhs Nodes

+ func NewAssignListStmt(pos src.XPos, op Op, lhs, rhs []Node) *AssignListStmt

+ func (n *AssignListStmt) Format(s fmt.State, verb rune)

+ func (n *AssignListStmt) Init() Nodes

+ func (n *AssignListStmt) PtrInit() *Nodes

+ func (n *AssignListStmt) SetInit(x Nodes)

+ func (n *AssignListStmt) SetOp(op Op)

+ type AssignOpStmt struct

+ AsOp Op

+ IncDec bool

+ X Node

+ Y Node

+ func NewAssignOpStmt(pos src.XPos, asOp Op, x, y Node) *AssignOpStmt

+ func (n *AssignOpStmt) Format(s fmt.State, verb rune)

+ func (n *AssignOpStmt) Init() Nodes

+ func (n *AssignOpStmt) PtrInit() *Nodes

+ func (n *AssignOpStmt) SetInit(x Nodes)

+ type AssignStmt struct

+ Def bool

+ X Node

+ Y Node

+ func NewAssignStmt(pos src.XPos, x, y Node) *AssignStmt

+ func (n *AssignStmt) Format(s fmt.State, verb rune)

+ func (n *AssignStmt) Init() Nodes

+ func (n *AssignStmt) PtrInit() *Nodes

+ func (n *AssignStmt) SetInit(x Nodes)

+ func (n *AssignStmt) SetOp(op Op)

+ type BasicLit struct

+ func (n *BasicLit) Bounded() bool

+ func (n *BasicLit) Format(s fmt.State, verb rune)

+ func (n *BasicLit) Init() Nodes

+ func (n *BasicLit) MarkNonNil()

+ func (n *BasicLit) NonNil() bool

+ func (n *BasicLit) PtrInit() *Nodes

+ func (n *BasicLit) SetBounded(b bool)

+ func (n *BasicLit) SetInit(x Nodes)

+ func (n *BasicLit) SetTransient(b bool)

+ func (n *BasicLit) SetType(x *types.Type)

+ func (n *BasicLit) SetVal(val constant.Value)

+ func (n *BasicLit) Transient() bool

+ func (n *BasicLit) Type() *types.Type

+ func (n *BasicLit) Val() constant.Value

+ type BinaryExpr struct

+ RType Node

+ X Node

+ Y Node

+ func NewBinaryExpr(pos src.XPos, op Op, x, y Node) *BinaryExpr

+ func (n *BinaryExpr) Bounded() bool

+ func (n *BinaryExpr) Format(s fmt.State, verb rune)

+ func (n *BinaryExpr) Init() Nodes

+ func (n *BinaryExpr) MarkNonNil()

+ func (n *BinaryExpr) NonNil() bool

+ func (n *BinaryExpr) PtrInit() *Nodes

+ func (n *BinaryExpr) SetBounded(b bool)

+ func (n *BinaryExpr) SetInit(x Nodes)

+ func (n *BinaryExpr) SetOp(op Op)

+ func (n *BinaryExpr) SetTransient(b bool)

+ func (n *BinaryExpr) SetType(x *types.Type)

+ func (n *BinaryExpr) Transient() bool

+ func (n *BinaryExpr) Type() *types.Type

+ type BlockStmt struct

+ List Nodes

+ func NewBlockStmt(pos src.XPos, list []Node) *BlockStmt

+ func (n *BlockStmt) Format(s fmt.State, verb rune)

+ func (n *BlockStmt) Init() Nodes

+ func (n *BlockStmt) PtrInit() *Nodes

+ func (n *BlockStmt) SetInit(x Nodes)

+ type BranchStmt struct

+ Label *types.Sym

+ func NewBranchStmt(pos src.XPos, op Op, label *types.Sym) *BranchStmt

+ func (n *BranchStmt) Format(s fmt.State, verb rune)

+ func (n *BranchStmt) Init() Nodes

+ func (n *BranchStmt) PtrInit() *Nodes

+ func (n *BranchStmt) SetInit(x Nodes)

+ func (n *BranchStmt) SetOp(op Op)

+ func (n *BranchStmt) Sym() *types.Sym

+ type CallExpr struct

+ Args Nodes

+ IsDDD bool

+ KeepAlive []*Name

+ NoInline bool

+ RType Node

+ X Node

+ func NewCallExpr(pos src.XPos, op Op, fun Node, args []Node) *CallExpr

+ func (n *CallExpr) Bounded() bool

+ func (n *CallExpr) Format(s fmt.State, verb rune)

+ func (n *CallExpr) Init() Nodes

+ func (n *CallExpr) MarkNonNil()

+ func (n *CallExpr) NonNil() bool

+ func (n *CallExpr) Orig() Node

+ func (n *CallExpr) PtrInit() *Nodes

+ func (n *CallExpr) SetBounded(b bool)

+ func (n *CallExpr) SetInit(x Nodes)

+ func (n *CallExpr) SetOp(op Op)

+ func (n *CallExpr) SetOrig(o Node)

+ func (n *CallExpr) SetTransient(b bool)

+ func (n *CallExpr) SetType(x *types.Type)

+ func (n *CallExpr) Transient() bool

+ func (n *CallExpr) Type() *types.Type

+ type CaseClause struct

+ Body Nodes

+ List Nodes

+ RTypes Nodes

+ Var *Name

+ func NewCaseStmt(pos src.XPos, list, body []Node) *CaseClause

+ func (n *CaseClause) Format(s fmt.State, verb rune)

+ func (n *CaseClause) Init() Nodes

+ func (n *CaseClause) PtrInit() *Nodes

+ func (n *CaseClause) SetInit(x Nodes)

+ type Class uint8

+ const PAUTO

+ const PAUTOHEAP

+ const PEXTERN

+ const PFUNC

+ const PPARAM

+ const PPARAMOUT

+ const PTYPEPARAM

+ const Pxxx

+ func (i Class) String() string

+ type ClosureExpr struct

+ Func *Func

+ IsGoWrap bool

+ Prealloc *Name

+ func (n *ClosureExpr) Bounded() bool

+ func (n *ClosureExpr) Format(s fmt.State, verb rune)

+ func (n *ClosureExpr) Init() Nodes

+ func (n *ClosureExpr) MarkNonNil()

+ func (n *ClosureExpr) NonNil() bool

+ func (n *ClosureExpr) PtrInit() *Nodes

+ func (n *ClosureExpr) SetBounded(b bool)

+ func (n *ClosureExpr) SetInit(x Nodes)

+ func (n *ClosureExpr) SetTransient(b bool)

+ func (n *ClosureExpr) SetType(x *types.Type)

+ func (n *ClosureExpr) Transient() bool

+ func (n *ClosureExpr) Type() *types.Type

+ type CommClause struct

+ Body Nodes

+ Comm Node

+ func NewCommStmt(pos src.XPos, comm Node, body []Node) *CommClause

+ func (n *CommClause) Format(s fmt.State, verb rune)

+ func (n *CommClause) Init() Nodes

+ func (n *CommClause) PtrInit() *Nodes

+ func (n *CommClause) SetInit(x Nodes)

+ type CompLitExpr struct

+ Len int64

+ List Nodes

+ Prealloc *Name

+ RType Node

+ func NewCompLitExpr(pos src.XPos, op Op, typ *types.Type, list []Node) *CompLitExpr

+ func (n *CompLitExpr) Bounded() bool

+ func (n *CompLitExpr) Format(s fmt.State, verb rune)

+ func (n *CompLitExpr) Implicit() bool

+ func (n *CompLitExpr) Init() Nodes

+ func (n *CompLitExpr) MarkNonNil()

+ func (n *CompLitExpr) NonNil() bool

+ func (n *CompLitExpr) Orig() Node

+ func (n *CompLitExpr) PtrInit() *Nodes

+ func (n *CompLitExpr) SetBounded(b bool)

+ func (n *CompLitExpr) SetImplicit(b bool)

+ func (n *CompLitExpr) SetInit(x Nodes)

+ func (n *CompLitExpr) SetOp(op Op)

+ func (n *CompLitExpr) SetOrig(o Node)

+ func (n *CompLitExpr) SetTransient(b bool)

+ func (n *CompLitExpr) SetType(x *types.Type)

+ func (n *CompLitExpr) Transient() bool

+ func (n *CompLitExpr) Type() *types.Type

+ type ConstExpr struct

+ func (n *ConstExpr) Bounded() bool

+ func (n *ConstExpr) Format(s fmt.State, verb rune)

+ func (n *ConstExpr) Init() Nodes

+ func (n *ConstExpr) MarkNonNil()

+ func (n *ConstExpr) NonNil() bool

+ func (n *ConstExpr) Orig() Node

+ func (n *ConstExpr) PtrInit() *Nodes

+ func (n *ConstExpr) SetBounded(b bool)

+ func (n *ConstExpr) SetInit(x Nodes)

+ func (n *ConstExpr) SetOrig(o Node)

+ func (n *ConstExpr) SetTransient(b bool)

+ func (n *ConstExpr) SetType(x *types.Type)

+ func (n *ConstExpr) Sym() *types.Sym

+ func (n *ConstExpr) Transient() bool

+ func (n *ConstExpr) Type() *types.Type

+ func (n *ConstExpr) Val() constant.Value

+ type ConvExpr struct

+ ElemElemRType Node

+ ElemRType Node

+ SrcRType Node

+ TypeWord Node

+ X Node

+ func NewConvExpr(pos src.XPos, op Op, typ *types.Type, x Node) *ConvExpr

+ func (n *ConvExpr) Bounded() bool

+ func (n *ConvExpr) CheckPtr() bool

+ func (n *ConvExpr) Format(s fmt.State, verb rune)

+ func (n *ConvExpr) Implicit() bool

+ func (n *ConvExpr) Init() Nodes

+ func (n *ConvExpr) MarkNonNil()

+ func (n *ConvExpr) NonNil() bool

+ func (n *ConvExpr) PtrInit() *Nodes

+ func (n *ConvExpr) SetBounded(b bool)

+ func (n *ConvExpr) SetCheckPtr(b bool)

+ func (n *ConvExpr) SetImplicit(b bool)

+ func (n *ConvExpr) SetInit(x Nodes)

+ func (n *ConvExpr) SetOp(op Op)

+ func (n *ConvExpr) SetTransient(b bool)

+ func (n *ConvExpr) SetType(x *types.Type)

+ func (n *ConvExpr) Transient() bool

+ func (n *ConvExpr) Type() *types.Type

+ type Decl struct

+ X *Name

+ func NewDecl(pos src.XPos, op Op, x *Name) *Decl

+ func (n *Decl) Esc() uint16

+ func (n *Decl) Format(s fmt.State, verb rune)

+ func (n *Decl) Init() Nodes

+ func (n *Decl) MarkNonNil()

+ func (n *Decl) Name() *Name

+ func (n *Decl) NonNil() bool

+ func (n *Decl) Op() Op

+ func (n *Decl) Pos() src.XPos

+ func (n *Decl) SetEsc(x uint16)

+ func (n *Decl) SetPos(x src.XPos)

+ func (n *Decl) SetType(*types.Type)

+ func (n *Decl) SetTypecheck(x uint8)

+ func (n *Decl) SetVal(v constant.Value)

+ func (n *Decl) SetWalked(x bool)

+ func (n *Decl) Sym() *types.Sym

+ func (n *Decl) Type() *types.Type

+ func (n *Decl) Typecheck() uint8

+ func (n *Decl) Val() constant.Value

+ func (n *Decl) Walked() bool

+ type DynamicType struct

+ ITab Node

+ RType Node

+ func NewDynamicType(pos src.XPos, rtype Node) *DynamicType

+ func (n *DynamicType) Bounded() bool

+ func (n *DynamicType) Format(s fmt.State, verb rune)

+ func (n *DynamicType) Init() Nodes

+ func (n *DynamicType) MarkNonNil()

+ func (n *DynamicType) NonNil() bool

+ func (n *DynamicType) PtrInit() *Nodes

+ func (n *DynamicType) SetBounded(b bool)

+ func (n *DynamicType) SetInit(x Nodes)

+ func (n *DynamicType) SetTransient(b bool)

+ func (n *DynamicType) SetType(x *types.Type)

+ func (n *DynamicType) Transient() bool

+ func (n *DynamicType) Type() *types.Type

+ type DynamicTypeAssertExpr struct

+ ITab Node

+ RType Node

+ SrcRType Node

+ X Node

+ func NewDynamicTypeAssertExpr(pos src.XPos, op Op, x, rtype Node) *DynamicTypeAssertExpr

+ func (n *DynamicTypeAssertExpr) Bounded() bool

+ func (n *DynamicTypeAssertExpr) Format(s fmt.State, verb rune)

+ func (n *DynamicTypeAssertExpr) Init() Nodes

+ func (n *DynamicTypeAssertExpr) MarkNonNil()

+ func (n *DynamicTypeAssertExpr) NonNil() bool

+ func (n *DynamicTypeAssertExpr) PtrInit() *Nodes

+ func (n *DynamicTypeAssertExpr) SetBounded(b bool)

+ func (n *DynamicTypeAssertExpr) SetInit(x Nodes)

+ func (n *DynamicTypeAssertExpr) SetOp(op Op)

+ func (n *DynamicTypeAssertExpr) SetTransient(b bool)

+ func (n *DynamicTypeAssertExpr) SetType(x *types.Type)

+ func (n *DynamicTypeAssertExpr) Transient() bool

+ func (n *DynamicTypeAssertExpr) Type() *types.Type

+ type Embed struct

+ Patterns []string

+ Pos src.XPos

+ type Expr interface

+ type Field struct

+ IsDDD bool

+ Pos src.XPos

+ Sym *types.Sym

+ Type *types.Type

+ func NewField(pos src.XPos, sym *types.Sym, typ *types.Type) *Field

+ func (f *Field) String() string

+ type ForStmt struct

+ Body Nodes

+ Cond Node

+ DistinctVars bool

+ Label *types.Sym

+ Post Node

+ func NewForStmt(pos src.XPos, init Node, cond, post Node, body []Node, distinctVars bool) *ForStmt

+ func (n *ForStmt) Format(s fmt.State, verb rune)

+ func (n *ForStmt) Init() Nodes

+ func (n *ForStmt) PtrInit() *Nodes

+ func (n *ForStmt) SetInit(x Nodes)

+ type Func struct

+ ABI obj.ABI

+ ABIRefs obj.ABISet

+ Body Nodes

+ Closgen int32

+ ClosureVars []*Name

+ Closures []*Func

+ Dcl []*Name

+ DebugInfo interface{}

+ Endlineno src.XPos

+ Enter Nodes

+ Exit Nodes

+ FieldTrack map[*obj.LSym]struct{}

+ Inl *Inline

+ LSym *obj.LSym

+ Label int32

+ Marks []Mark

+ NWBRCalls *[]SymAndPos

+ Nname *Name

+ NumDefers int32

+ NumReturns int32

+ OClosure *ClosureExpr

+ Parents []ScopeID

+ Pragma PragmaFlag

+ WBPos src.XPos

+ WasmImport *WasmImport

+ WrappedFunc *Func

+ var CurFunc *Func

+ func NewClosureFunc(pos src.XPos, hidden bool) *Func

+ func NewFunc(pos src.XPos) *Func

+ func (f *Func) ABIWrapper() bool

+ func (f *Func) ClosureCalled() bool

+ func (f *Func) Dupok() bool

+ func (f *Func) ExportInline() bool

+ func (f *Func) HasDefer() bool

+ func (f *Func) InlinabilityChecked() bool

+ func (f *Func) InstrumentBody() bool

+ func (f *Func) IsDeadcodeClosure() bool

+ func (f *Func) IsHiddenClosure() bool

+ func (f *Func) IsPackageInit() bool

+ func (f *Func) Linksym() *obj.LSym

+ func (f *Func) LinksymABI(abi obj.ABI) *obj.LSym

+ func (f *Func) Needctxt() bool

+ func (f *Func) NilCheckDisabled() bool

+ func (f *Func) OpenCodedDeferDisallowed() bool

+ func (f *Func) ReflectMethod() bool

+ func (f *Func) SetABIWrapper(b bool)

+ func (f *Func) SetClosureCalled(b bool)

+ func (f *Func) SetDupok(b bool)

+ func (f *Func) SetExportInline(b bool)

+ func (f *Func) SetHasDefer(b bool)

+ func (f *Func) SetInlinabilityChecked(b bool)

+ func (f *Func) SetInstrumentBody(b bool)

+ func (f *Func) SetIsDeadcodeClosure(b bool)

+ func (f *Func) SetIsHiddenClosure(b bool)

+ func (f *Func) SetIsPackageInit(b bool)

+ func (f *Func) SetNeedctxt(b bool)

+ func (f *Func) SetNilCheckDisabled(b bool)

+ func (f *Func) SetOpenCodedDeferDisallowed(b bool)

+ func (f *Func) SetReflectMethod(b bool)

+ func (f *Func) SetWBPos(pos src.XPos)

+ func (f *Func) SetWrapper(b bool)

+ func (f *Func) Sym() *types.Sym

+ func (f *Func) Type() *types.Type

+ func (f *Func) Wrapper() bool

+ func (n *Func) Esc() uint16

+ func (n *Func) Format(s fmt.State, verb rune)

+ func (n *Func) Init() Nodes

+ func (n *Func) MarkNonNil()

+ func (n *Func) Name() *Name

+ func (n *Func) NonNil() bool

+ func (n *Func) Op() Op

+ func (n *Func) Pos() src.XPos

+ func (n *Func) SetEsc(x uint16)

+ func (n *Func) SetPos(x src.XPos)

+ func (n *Func) SetType(*types.Type)

+ func (n *Func) SetTypecheck(x uint8)

+ func (n *Func) SetVal(v constant.Value)

+ func (n *Func) SetWalked(x bool)

+ func (n *Func) Typecheck() uint8

+ func (n *Func) Val() constant.Value

+ func (n *Func) Walked() bool

+ type GoDeferStmt struct

+ Call Node

+ func NewGoDeferStmt(pos src.XPos, op Op, call Node) *GoDeferStmt

+ func (n *GoDeferStmt) Format(s fmt.State, verb rune)

+ func (n *GoDeferStmt) Init() Nodes

+ func (n *GoDeferStmt) PtrInit() *Nodes

+ func (n *GoDeferStmt) SetInit(x Nodes)

+ type Ident struct

+ func NewIdent(pos src.XPos, sym *types.Sym) *Ident

+ func (n *Ident) Bounded() bool

+ func (n *Ident) Format(s fmt.State, verb rune)

+ func (n *Ident) Init() Nodes

+ func (n *Ident) MarkNonNil()

+ func (n *Ident) NonNil() bool

+ func (n *Ident) PtrInit() *Nodes

+ func (n *Ident) SetBounded(b bool)

+ func (n *Ident) SetInit(x Nodes)

+ func (n *Ident) SetTransient(b bool)

+ func (n *Ident) SetType(x *types.Type)

+ func (n *Ident) Sym() *types.Sym

+ func (n *Ident) Transient() bool

+ func (n *Ident) Type() *types.Type

+ type IfStmt struct

+ Body Nodes

+ Cond Node

+ Else Nodes

+ Likely bool

+ func NewIfStmt(pos src.XPos, cond Node, body, els []Node) *IfStmt

+ func (n *IfStmt) Format(s fmt.State, verb rune)

+ func (n *IfStmt) Init() Nodes

+ func (n *IfStmt) PtrInit() *Nodes

+ func (n *IfStmt) SetInit(x Nodes)

+ type IndexExpr struct

+ Assigned bool

+ Index Node

+ RType Node

+ X Node

+ func NewIndexExpr(pos src.XPos, x, index Node) *IndexExpr

+ func (n *IndexExpr) Bounded() bool

+ func (n *IndexExpr) Format(s fmt.State, verb rune)

+ func (n *IndexExpr) Init() Nodes

+ func (n *IndexExpr) MarkNonNil()

+ func (n *IndexExpr) NonNil() bool

+ func (n *IndexExpr) PtrInit() *Nodes

+ func (n *IndexExpr) SetBounded(b bool)

+ func (n *IndexExpr) SetInit(x Nodes)

+ func (n *IndexExpr) SetOp(op Op)

+ func (n *IndexExpr) SetTransient(b bool)

+ func (n *IndexExpr) SetType(x *types.Type)

+ func (n *IndexExpr) Transient() bool

+ func (n *IndexExpr) Type() *types.Type

+ type InitNode interface

+ PtrInit func() *Nodes

+ SetInit func(x Nodes)

+ type Inline struct

+ Body []Node

+ CanDelayResults bool

+ Cost int32

+ Dcl []*Name

+ type InlineMarkStmt struct

+ Index int64

+ func NewInlineMarkStmt(pos src.XPos, index int64) *InlineMarkStmt

+ func (n *InlineMarkStmt) Format(s fmt.State, verb rune)

+ func (n *InlineMarkStmt) Init() Nodes

+ func (n *InlineMarkStmt) Offset() int64

+ func (n *InlineMarkStmt) PtrInit() *Nodes

+ func (n *InlineMarkStmt) SetInit(x Nodes)

+ func (n *InlineMarkStmt) SetOffset(x int64)

+ type InlinedCallExpr struct

+ Body Nodes

+ ReturnVars Nodes

+ func NewInlinedCallExpr(pos src.XPos, body, retvars []Node) *InlinedCallExpr

+ func (n *InlinedCallExpr) Bounded() bool

+ func (n *InlinedCallExpr) Format(s fmt.State, verb rune)

+ func (n *InlinedCallExpr) Init() Nodes

+ func (n *InlinedCallExpr) MarkNonNil()

+ func (n *InlinedCallExpr) NonNil() bool

+ func (n *InlinedCallExpr) PtrInit() *Nodes

+ func (n *InlinedCallExpr) SetBounded(b bool)

+ func (n *InlinedCallExpr) SetInit(x Nodes)

+ func (n *InlinedCallExpr) SetTransient(b bool)

+ func (n *InlinedCallExpr) SetType(x *types.Type)

+ func (n *InlinedCallExpr) SingleResult() Node

+ func (n *InlinedCallExpr) Transient() bool

+ func (n *InlinedCallExpr) Type() *types.Type

+ type InstExpr struct

+ Targs []Ntype

+ X Node

+ func NewInstExpr(pos src.XPos, op Op, x Node, targs []Ntype) *InstExpr

+ func (n *InstExpr) Bounded() bool

+ func (n *InstExpr) Format(s fmt.State, verb rune)

+ func (n *InstExpr) Implicit() bool

+ func (n *InstExpr) Init() Nodes

+ func (n *InstExpr) MarkNonNil()

+ func (n *InstExpr) NonNil() bool

+ func (n *InstExpr) PtrInit() *Nodes

+ func (n *InstExpr) SetBounded(b bool)

+ func (n *InstExpr) SetImplicit(b bool)

+ func (n *InstExpr) SetInit(x Nodes)

+ func (n *InstExpr) SetTransient(b bool)

+ func (n *InstExpr) SetType(x *types.Type)

+ func (n *InstExpr) Transient() bool

+ func (n *InstExpr) Type() *types.Type

+ type JumpTableStmt struct

+ Cases []constant.Value

+ Idx Node

+ Targets []*types.Sym

+ func NewJumpTableStmt(pos src.XPos, idx Node) *JumpTableStmt

+ func (n *JumpTableStmt) Format(s fmt.State, verb rune)

+ func (n *JumpTableStmt) Init() Nodes

+ func (n *JumpTableStmt) PtrInit() *Nodes

+ func (n *JumpTableStmt) SetInit(x Nodes)

+ type KeyExpr struct

+ Key Node

+ Value Node

+ func NewKeyExpr(pos src.XPos, key, value Node) *KeyExpr

+ func (n *KeyExpr) Bounded() bool

+ func (n *KeyExpr) Format(s fmt.State, verb rune)

+ func (n *KeyExpr) Init() Nodes

+ func (n *KeyExpr) MarkNonNil()

+ func (n *KeyExpr) NonNil() bool

+ func (n *KeyExpr) PtrInit() *Nodes

+ func (n *KeyExpr) SetBounded(b bool)

+ func (n *KeyExpr) SetInit(x Nodes)

+ func (n *KeyExpr) SetTransient(b bool)

+ func (n *KeyExpr) SetType(x *types.Type)

+ func (n *KeyExpr) Transient() bool

+ func (n *KeyExpr) Type() *types.Type

+ type LabelStmt struct

+ Label *types.Sym

+ func NewLabelStmt(pos src.XPos, label *types.Sym) *LabelStmt

+ func (n *LabelStmt) Format(s fmt.State, verb rune)

+ func (n *LabelStmt) Init() Nodes

+ func (n *LabelStmt) PtrInit() *Nodes

+ func (n *LabelStmt) SetInit(x Nodes)

+ func (n *LabelStmt) Sym() *types.Sym

+ type LinksymOffsetExpr struct

+ Linksym *obj.LSym

+ Offset_ int64

+ func NewLinksymExpr(pos src.XPos, lsym *obj.LSym, typ *types.Type) *LinksymOffsetExpr

+ func NewLinksymOffsetExpr(pos src.XPos, lsym *obj.LSym, offset int64, typ *types.Type) *LinksymOffsetExpr

+ func NewNameOffsetExpr(pos src.XPos, name *Name, offset int64, typ *types.Type) *LinksymOffsetExpr

+ func (n *LinksymOffsetExpr) Bounded() bool

+ func (n *LinksymOffsetExpr) Format(s fmt.State, verb rune)

+ func (n *LinksymOffsetExpr) Init() Nodes

+ func (n *LinksymOffsetExpr) MarkNonNil()

+ func (n *LinksymOffsetExpr) NonNil() bool

+ func (n *LinksymOffsetExpr) PtrInit() *Nodes

+ func (n *LinksymOffsetExpr) SetBounded(b bool)

+ func (n *LinksymOffsetExpr) SetInit(x Nodes)

+ func (n *LinksymOffsetExpr) SetTransient(b bool)

+ func (n *LinksymOffsetExpr) SetType(x *types.Type)

+ func (n *LinksymOffsetExpr) Transient() bool

+ func (n *LinksymOffsetExpr) Type() *types.Type

+ type LogicalExpr struct

+ X Node

+ Y Node

+ func NewLogicalExpr(pos src.XPos, op Op, x, y Node) *LogicalExpr

+ func (n *LogicalExpr) Bounded() bool

+ func (n *LogicalExpr) Format(s fmt.State, verb rune)

+ func (n *LogicalExpr) Init() Nodes

+ func (n *LogicalExpr) MarkNonNil()

+ func (n *LogicalExpr) NonNil() bool

+ func (n *LogicalExpr) PtrInit() *Nodes

+ func (n *LogicalExpr) SetBounded(b bool)

+ func (n *LogicalExpr) SetInit(x Nodes)

+ func (n *LogicalExpr) SetOp(op Op)

+ func (n *LogicalExpr) SetTransient(b bool)

+ func (n *LogicalExpr) SetType(x *types.Type)

+ func (n *LogicalExpr) Transient() bool

+ func (n *LogicalExpr) Type() *types.Type

+ type MakeExpr struct

+ Cap Node

+ Len Node

+ RType Node

+ func NewMakeExpr(pos src.XPos, op Op, len, cap Node) *MakeExpr

+ func (n *MakeExpr) Bounded() bool

+ func (n *MakeExpr) Format(s fmt.State, verb rune)

+ func (n *MakeExpr) Init() Nodes

+ func (n *MakeExpr) MarkNonNil()

+ func (n *MakeExpr) NonNil() bool

+ func (n *MakeExpr) PtrInit() *Nodes

+ func (n *MakeExpr) SetBounded(b bool)

+ func (n *MakeExpr) SetInit(x Nodes)

+ func (n *MakeExpr) SetOp(op Op)

+ func (n *MakeExpr) SetTransient(b bool)

+ func (n *MakeExpr) SetType(x *types.Type)

+ func (n *MakeExpr) Transient() bool

+ func (n *MakeExpr) Type() *types.Type

+ type Mark struct

+ Pos src.XPos

+ Scope ScopeID

+ type Name struct

+ BuiltinOp Op

+ Class Class

+ Curfn *Func

+ Defn Node

+ DictIndex uint16

+ Embed *[]Embed

+ Func *Func

+ Heapaddr *Name

+ Innermost *Name

+ Offset_ int64

+ Opt interface{}

+ Outer *Name

+ func CaptureName(pos src.XPos, fn *Func, n *Name) *Name

+ func MethodExprName(n Node) *Name

+ func NewClosureVar(pos src.XPos, fn *Func, n *Name) *Name

+ func NewConstAt(pos src.XPos, sym *types.Sym, typ *types.Type, val constant.Value) *Name

+ func NewDeclNameAt(pos src.XPos, op Op, sym *types.Sym) *Name

+ func NewHiddenParam(pos src.XPos, fn *Func, sym *types.Sym, typ *types.Type) *Name

+ func NewNameAt(pos src.XPos, sym *types.Sym) *Name

+ func (*Name) CanBeAnSSAAux()

+ func (*Name) CanBeAnSSASym()

+ func (*Name) CanBeNtype()

+ func (n *Name) Addrtaken() bool

+ func (n *Name) Alias() bool

+ func (n *Name) AutoTemp() bool

+ func (n *Name) Bounded() bool

+ func (n *Name) Byval() bool

+ func (n *Name) Canonical() *Name

+ func (n *Name) CoverageAuxVar() bool

+ func (n *Name) CoverageCounter() bool

+ func (n *Name) Format(s fmt.State, verb rune)

+ func (n *Name) FrameOffset() int64

+ func (n *Name) Init() Nodes

+ func (n *Name) InlFormal() bool

+ func (n *Name) InlLocal() bool

+ func (n *Name) IsClosureVar() bool

+ func (n *Name) IsOutputParamHeapAddr() bool

+ func (n *Name) IsOutputParamInRegisters() bool

+ func (n *Name) Libfuzzer8BitCounter() bool

+ func (n *Name) Linksym() *obj.LSym

+ func (n *Name) LinksymABI(abi obj.ABI) *obj.LSym

+ func (n *Name) MarkNonNil()

+ func (n *Name) MarkReadonly()

+ func (n *Name) Name() *Name

+ func (n *Name) Needzero() bool

+ func (n *Name) NonNil() bool

+ func (n *Name) Offset() int64

+ func (n *Name) OnStack() bool

+ func (n *Name) OpenDeferSlot() bool

+ func (n *Name) Pragma() PragmaFlag

+ func (n *Name) PtrInit() *Nodes

+ func (n *Name) Readonly() bool

+ func (n *Name) RecordFrameOffset(offset int64)

+ func (n *Name) SetAddrtaken(b bool)

+ func (n *Name) SetAlias(alias bool)

+ func (n *Name) SetAutoTemp(b bool)

+ func (n *Name) SetBounded(b bool)

+ func (n *Name) SetByval(b bool)

+ func (n *Name) SetCoverageAuxVar(b bool)

+ func (n *Name) SetCoverageCounter(b bool)

+ func (n *Name) SetFrameOffset(x int64)

+ func (n *Name) SetFunc(x *Func)

+ func (n *Name) SetInit(x Nodes)

+ func (n *Name) SetInlFormal(b bool)

+ func (n *Name) SetInlLocal(b bool)

+ func (n *Name) SetIsClosureVar(b bool)

+ func (n *Name) SetIsOutputParamHeapAddr(b bool)

+ func (n *Name) SetIsOutputParamInRegisters(b bool)

+ func (n *Name) SetLibfuzzer8BitCounter(b bool)

+ func (n *Name) SetNeedzero(b bool)

+ func (n *Name) SetOffset(x int64)

+ func (n *Name) SetOpenDeferSlot(b bool)

+ func (n *Name) SetPragma(flag PragmaFlag)

+ func (n *Name) SetSubOp(x Op)

+ func (n *Name) SetSym(x *types.Sym)

+ func (n *Name) SetTransient(b bool)

+ func (n *Name) SetType(x *types.Type)

+ func (n *Name) SetUsed(b bool)

+ func (n *Name) SetVal(v constant.Value)

+ func (n *Name) SubOp() Op

+ func (n *Name) Sym() *types.Sym

+ func (n *Name) Transient() bool

+ func (n *Name) Type() *types.Type

+ func (n *Name) Used() bool

+ func (n *Name) Val() constant.Value

+ type NameQueue struct

+ func (q *NameQueue) Empty() bool

+ func (q *NameQueue) PopLeft() *Name

+ func (q *NameQueue) PushRight(n *Name)

+ type NameSet map[*Name]struct

+ func (s *NameSet) Add(n *Name)

+ func (s NameSet) Has(n *Name) bool

+ func (s NameSet) Sorted(less func(*Name, *Name) bool) []*Name

+ type NilExpr struct

+ func NewNilExpr(pos src.XPos) *NilExpr

+ func (n *NilExpr) Bounded() bool

+ func (n *NilExpr) Format(s fmt.State, verb rune)

+ func (n *NilExpr) Init() Nodes

+ func (n *NilExpr) MarkNonNil()

+ func (n *NilExpr) NonNil() bool

+ func (n *NilExpr) PtrInit() *Nodes

+ func (n *NilExpr) SetBounded(b bool)

+ func (n *NilExpr) SetInit(x Nodes)

+ func (n *NilExpr) SetTransient(b bool)

+ func (n *NilExpr) SetType(x *types.Type)

+ func (n *NilExpr) Transient() bool

+ func (n *NilExpr) Type() *types.Type

+ type Node interface

+ Esc func() uint16

+ Format func(s fmt.State, verb rune)

+ Init func() Nodes

+ MarkNonNil func()

+ Name func() *Name

+ NonNil func() bool

+ Op func() Op

+ Pos func() src.XPos

+ SetEsc func(x uint16)

+ SetPos func(x src.XPos)

+ SetType func(t *types.Type)

+ SetTypecheck func(x uint8)

+ SetVal func(v constant.Value)

+ Sym func() *types.Sym

+ Type func() *types.Type

+ Typecheck func() uint8

+ Val func() constant.Value

+ var BlankNode Node

+ func AsNode(n types.Object) Node

+ func Copy(n Node) Node

+ func DeepCopy(pos src.XPos, n Node) Node

+ func DeepCopyList(pos src.XPos, list []Node) []Node

+ func InitExpr(init []Node, expr Node) Node

+ func NewBasicLit(pos src.XPos, val constant.Value) Node

+ func NewBool(pos src.XPos, b bool) Node

+ func NewConstExpr(val constant.Value, orig Node) Node

+ func NewInt(pos src.XPos, v int64) Node

+ func NewString(pos src.XPos, s string) Node

+ func Orig(n Node) Node

+ func OuterValue(n Node) Node

+ func ParamNames(ft *types.Type) []Node

+ func SepCopy(n Node) Node

+ func StaticValue(n Node) Node

+ func UseClosure(clo *ClosureExpr, pkg *Package) Node

+ type Nodes []Node

+ func TakeInit(n Node) Nodes

+ func (l Nodes) Format(s fmt.State, verb rune)

+ func (n *Nodes) Append(a ...Node)

+ func (n *Nodes) Prepend(a ...Node)

+ func (n *Nodes) Take() []Node

+ func (n Nodes) Copy() Nodes

+ type Ntype interface

+ CanBeNtype func()

+ func TypeNode(t *types.Type) Ntype

+ type Op uint8

+ const OADD

+ const OADDR

+ const OADDSTR

+ const OALIGNOF

+ const OAND

+ const OANDAND

+ const OANDNOT

+ const OAPPEND

+ const OARRAYLIT

+ const OAS

+ const OAS2

+ const OAS2DOTTYPE

+ const OAS2FUNC

+ const OAS2MAPR

+ const OAS2RECV

+ const OASOP

+ const OBITNOT

+ const OBLOCK

+ const OBREAK

+ const OBYTES2STR

+ const OBYTES2STRTMP

+ const OCALL

+ const OCALLFUNC

+ const OCALLINTER

+ const OCALLMETH

+ const OCAP

+ const OCASE

+ const OCFUNC

+ const OCHECKNIL

+ const OCLEAR

+ const OCLOSE

+ const OCLOSURE

+ const OCOMPLEX

+ const OCOMPLIT

+ const OCONTINUE

+ const OCONV

+ const OCONVIDATA

+ const OCONVIFACE

+ const OCONVNOP

+ const OCOPY

+ const ODCL

+ const ODCLCONST

+ const ODCLFUNC

+ const ODCLTYPE

+ const ODEFER

+ const ODELETE

+ const ODEREF

+ const ODIV

+ const ODOT

+ const ODOTINTER

+ const ODOTMETH

+ const ODOTPTR

+ const ODOTTYPE

+ const ODOTTYPE2

+ const ODYNAMICDOTTYPE

+ const ODYNAMICDOTTYPE2

+ const ODYNAMICTYPE

+ const OEFACE

+ const OEND

+ const OEQ

+ const OFALL

+ const OFOR

+ const OFUNCINST

+ const OGE

+ const OGETCALLERPC

+ const OGETCALLERSP

+ const OGETG

+ const OGO

+ const OGOTO

+ const OGT

+ const OIDATA

+ const OIF

+ const OIMAG

+ const OINDEX

+ const OINDEXMAP

+ const OINLCALL

+ const OINLMARK

+ const OITAB

+ const OJUMPTABLE

+ const OKEY

+ const OLABEL

+ const OLE

+ const OLEN

+ const OLINKSYMOFFSET

+ const OLITERAL

+ const OLSH

+ const OLT

+ const OMAKE

+ const OMAKECHAN

+ const OMAKEMAP

+ const OMAKESLICE

+ const OMAKESLICECOPY

+ const OMAPLIT

+ const OMAX

+ const OMETHEXPR

+ const OMETHVALUE

+ const OMIN

+ const OMOD

+ const OMUL

+ const ONAME

+ const ONE

+ const ONEG

+ const ONEW

+ const ONIL

+ const ONONAME

+ const ONOT

+ const OOFFSETOF

+ const OOR

+ const OOROR

+ const OPANIC

+ const OPAREN

+ const OPLUS

+ const OPRINT

+ const OPRINTN

+ const OPTRLIT

+ const ORANGE

+ const OREAL

+ const ORECOVER

+ const ORECOVERFP

+ const ORECV

+ const ORESULT

+ const ORETURN

+ const ORSH

+ const ORUNES2STR

+ const ORUNESTR

+ const OSELECT

+ const OSELRECV2

+ const OSEND

+ const OSIZEOF

+ const OSLICE

+ const OSLICE2ARR

+ const OSLICE2ARRPTR

+ const OSLICE3

+ const OSLICE3ARR

+ const OSLICEARR

+ const OSLICEHEADER

+ const OSLICELIT

+ const OSLICESTR

+ const OSPTR

+ const OSTR2BYTES

+ const OSTR2BYTESTMP

+ const OSTR2RUNES

+ const OSTRINGHEADER

+ const OSTRUCTKEY

+ const OSTRUCTLIT

+ const OSUB

+ const OSWITCH

+ const OTAILCALL

+ const OTYPE

+ const OTYPESW

+ const OUNSAFEADD

+ const OUNSAFESLICE

+ const OUNSAFESLICEDATA

+ const OUNSAFESTRING

+ const OUNSAFESTRINGDATA

+ const OXDOT

+ const OXOR

+ const OXXX

+ func (i Op) String() string

+ func (o Op) Format(s fmt.State, verb rune)

+ func (o Op) GoString() string

+ func (o Op) IsSlice3() bool

+ func (op Op) IsCmp() bool

+ type OrigNode interface

+ Orig func() Node

+ SetOrig func(Node)

+ type Package struct

+ Asms []*Name

+ CgoPragmas [][]string

+ Decls []Node

+ Embeds []*Name

+ Exports []*Name

+ Externs []Node

+ Imports []*types.Pkg

+ Inits []*Func

+ type ParenExpr struct

+ X Node

+ func NewParenExpr(pos src.XPos, x Node) *ParenExpr

+ func (n *ParenExpr) Bounded() bool

+ func (n *ParenExpr) Format(s fmt.State, verb rune)

+ func (n *ParenExpr) Implicit() bool

+ func (n *ParenExpr) Init() Nodes

+ func (n *ParenExpr) MarkNonNil()

+ func (n *ParenExpr) NonNil() bool

+ func (n *ParenExpr) PtrInit() *Nodes

+ func (n *ParenExpr) SetBounded(b bool)

+ func (n *ParenExpr) SetImplicit(b bool)

+ func (n *ParenExpr) SetInit(x Nodes)

+ func (n *ParenExpr) SetTransient(b bool)

+ func (n *ParenExpr) SetType(x *types.Type)

+ func (n *ParenExpr) Transient() bool

+ func (n *ParenExpr) Type() *types.Type

+ type PragmaFlag uint16

+ const CgoUnsafeArgs

+ const GoBuildPragma

+ const NoCheckPtr

+ const Noescape

+ const Noinline

+ const Nointerface

+ const Norace

+ const Nosplit

+ const Nowritebarrier

+ const Nowritebarrierrec

+ const RegisterParams

+ const Systemstack

+ const UintptrEscapes

+ const UintptrKeepAlive

+ const Yeswritebarrierrec

+ type RangeStmt struct

+ Body Nodes

+ Def bool

+ DistinctVars bool

+ Key Node

+ KeySrcRType Node

+ KeyTypeWord Node

+ Label *types.Sym

+ Prealloc *Name

+ RType Node

+ Value Node

+ ValueSrcRType Node

+ ValueTypeWord Node

+ X Node

+ func NewRangeStmt(pos src.XPos, key, value, x Node, body []Node, distinctVars bool) *RangeStmt

+ func (n *RangeStmt) Format(s fmt.State, verb rune)

+ func (n *RangeStmt) Init() Nodes

+ func (n *RangeStmt) PtrInit() *Nodes

+ func (n *RangeStmt) SetInit(x Nodes)

+ type RawOrigExpr struct

+ Raw string

+ func NewRawOrigExpr(pos src.XPos, op Op, raw string) *RawOrigExpr

+ func (n *RawOrigExpr) Bounded() bool

+ func (n *RawOrigExpr) Format(s fmt.State, verb rune)

+ func (n *RawOrigExpr) Init() Nodes

+ func (n *RawOrigExpr) MarkNonNil()

+ func (n *RawOrigExpr) NonNil() bool

+ func (n *RawOrigExpr) PtrInit() *Nodes

+ func (n *RawOrigExpr) SetBounded(b bool)

+ func (n *RawOrigExpr) SetInit(x Nodes)

+ func (n *RawOrigExpr) SetTransient(b bool)

+ func (n *RawOrigExpr) SetType(x *types.Type)

+ func (n *RawOrigExpr) Transient() bool

+ func (n *RawOrigExpr) Type() *types.Type

+ type ResultExpr struct

+ Index int64

+ func NewResultExpr(pos src.XPos, typ *types.Type, index int64) *ResultExpr

+ func (n *ResultExpr) Bounded() bool

+ func (n *ResultExpr) Format(s fmt.State, verb rune)

+ func (n *ResultExpr) Init() Nodes

+ func (n *ResultExpr) MarkNonNil()

+ func (n *ResultExpr) NonNil() bool

+ func (n *ResultExpr) PtrInit() *Nodes

+ func (n *ResultExpr) SetBounded(b bool)

+ func (n *ResultExpr) SetInit(x Nodes)

+ func (n *ResultExpr) SetTransient(b bool)

+ func (n *ResultExpr) SetType(x *types.Type)

+ func (n *ResultExpr) Transient() bool

+ func (n *ResultExpr) Type() *types.Type

+ type ReturnStmt struct

+ Results Nodes

+ func NewReturnStmt(pos src.XPos, results []Node) *ReturnStmt

+ func (n *ReturnStmt) Format(s fmt.State, verb rune)

+ func (n *ReturnStmt) Init() Nodes

+ func (n *ReturnStmt) Orig() Node

+ func (n *ReturnStmt) PtrInit() *Nodes

+ func (n *ReturnStmt) SetInit(x Nodes)

+ func (n *ReturnStmt) SetOrig(o Node)

+ type ScopeID int32

+ type SelectStmt struct

+ Cases []*CommClause

+ Compiled Nodes

+ Label *types.Sym

+ func NewSelectStmt(pos src.XPos, cases []*CommClause) *SelectStmt

+ func (n *SelectStmt) Format(s fmt.State, verb rune)

+ func (n *SelectStmt) Init() Nodes

+ func (n *SelectStmt) PtrInit() *Nodes

+ func (n *SelectStmt) SetInit(x Nodes)

+ type SelectorExpr struct

+ Prealloc *Name

+ Sel *types.Sym

+ Selection *types.Field

+ X Node

+ func NewSelectorExpr(pos src.XPos, op Op, x Node, sel *types.Sym) *SelectorExpr

+ func (n *SelectorExpr) Bounded() bool

+ func (n *SelectorExpr) Format(s fmt.State, verb rune)

+ func (n *SelectorExpr) FuncName() *Name

+ func (n *SelectorExpr) Implicit() bool

+ func (n *SelectorExpr) Init() Nodes

+ func (n *SelectorExpr) MarkNonNil()

+ func (n *SelectorExpr) NonNil() bool

+ func (n *SelectorExpr) Offset() int64

+ func (n *SelectorExpr) PtrInit() *Nodes

+ func (n *SelectorExpr) SetBounded(b bool)

+ func (n *SelectorExpr) SetImplicit(b bool)

+ func (n *SelectorExpr) SetInit(x Nodes)

+ func (n *SelectorExpr) SetOp(op Op)

+ func (n *SelectorExpr) SetTransient(b bool)

+ func (n *SelectorExpr) SetType(x *types.Type)

+ func (n *SelectorExpr) Sym() *types.Sym

+ func (n *SelectorExpr) Transient() bool

+ func (n *SelectorExpr) Type() *types.Type

+ type SendStmt struct

+ Chan Node

+ Value Node

+ func NewSendStmt(pos src.XPos, ch, value Node) *SendStmt

+ func (n *SendStmt) Format(s fmt.State, verb rune)

+ func (n *SendStmt) Init() Nodes

+ func (n *SendStmt) PtrInit() *Nodes

+ func (n *SendStmt) SetInit(x Nodes)

+ type SliceExpr struct

+ High Node

+ Low Node

+ Max Node

+ X Node

+ func NewSliceExpr(pos src.XPos, op Op, x, low, high, max Node) *SliceExpr

+ func (n *SliceExpr) Bounded() bool

+ func (n *SliceExpr) Format(s fmt.State, verb rune)

+ func (n *SliceExpr) Init() Nodes

+ func (n *SliceExpr) MarkNonNil()

+ func (n *SliceExpr) NonNil() bool

+ func (n *SliceExpr) PtrInit() *Nodes

+ func (n *SliceExpr) SetBounded(b bool)

+ func (n *SliceExpr) SetInit(x Nodes)

+ func (n *SliceExpr) SetOp(op Op)

+ func (n *SliceExpr) SetTransient(b bool)

+ func (n *SliceExpr) SetType(x *types.Type)

+ func (n *SliceExpr) Transient() bool

+ func (n *SliceExpr) Type() *types.Type

+ type SliceHeaderExpr struct

+ Cap Node

+ Len Node

+ Ptr Node

+ func NewSliceHeaderExpr(pos src.XPos, typ *types.Type, ptr, len, cap Node) *SliceHeaderExpr

+ func (n *SliceHeaderExpr) Bounded() bool

+ func (n *SliceHeaderExpr) Format(s fmt.State, verb rune)

+ func (n *SliceHeaderExpr) Init() Nodes

+ func (n *SliceHeaderExpr) MarkNonNil()

+ func (n *SliceHeaderExpr) NonNil() bool

+ func (n *SliceHeaderExpr) PtrInit() *Nodes

+ func (n *SliceHeaderExpr) SetBounded(b bool)

+ func (n *SliceHeaderExpr) SetInit(x Nodes)

+ func (n *SliceHeaderExpr) SetTransient(b bool)

+ func (n *SliceHeaderExpr) SetType(x *types.Type)

+ func (n *SliceHeaderExpr) Transient() bool

+ func (n *SliceHeaderExpr) Type() *types.Type

+ type StarExpr struct

+ X Node

+ func NewStarExpr(pos src.XPos, x Node) *StarExpr

+ func (n *StarExpr) Bounded() bool

+ func (n *StarExpr) Format(s fmt.State, verb rune)

+ func (n *StarExpr) Implicit() bool

+ func (n *StarExpr) Init() Nodes

+ func (n *StarExpr) MarkNonNil()

+ func (n *StarExpr) NonNil() bool

+ func (n *StarExpr) PtrInit() *Nodes

+ func (n *StarExpr) SetBounded(b bool)

+ func (n *StarExpr) SetImplicit(b bool)

+ func (n *StarExpr) SetInit(x Nodes)

+ func (n *StarExpr) SetTransient(b bool)

+ func (n *StarExpr) SetType(x *types.Type)

+ func (n *StarExpr) Transient() bool

+ func (n *StarExpr) Type() *types.Type

+ type Stmt interface

+ type StringHeaderExpr struct

+ Len Node

+ Ptr Node

+ func NewStringHeaderExpr(pos src.XPos, ptr, len Node) *StringHeaderExpr

+ func (n *StringHeaderExpr) Bounded() bool

+ func (n *StringHeaderExpr) Format(s fmt.State, verb rune)

+ func (n *StringHeaderExpr) Init() Nodes

+ func (n *StringHeaderExpr) MarkNonNil()

+ func (n *StringHeaderExpr) NonNil() bool

+ func (n *StringHeaderExpr) PtrInit() *Nodes

+ func (n *StringHeaderExpr) SetBounded(b bool)

+ func (n *StringHeaderExpr) SetInit(x Nodes)

+ func (n *StringHeaderExpr) SetTransient(b bool)

+ func (n *StringHeaderExpr) SetType(x *types.Type)

+ func (n *StringHeaderExpr) Transient() bool

+ func (n *StringHeaderExpr) Type() *types.Type

+ type StructKeyExpr struct

+ Field *types.Field

+ Value Node

+ func NewStructKeyExpr(pos src.XPos, field *types.Field, value Node) *StructKeyExpr

+ func (n *StructKeyExpr) Bounded() bool

+ func (n *StructKeyExpr) Format(s fmt.State, verb rune)

+ func (n *StructKeyExpr) Init() Nodes

+ func (n *StructKeyExpr) MarkNonNil()

+ func (n *StructKeyExpr) NonNil() bool

+ func (n *StructKeyExpr) PtrInit() *Nodes

+ func (n *StructKeyExpr) SetBounded(b bool)

+ func (n *StructKeyExpr) SetInit(x Nodes)

+ func (n *StructKeyExpr) SetTransient(b bool)

+ func (n *StructKeyExpr) SetType(x *types.Type)

+ func (n *StructKeyExpr) Sym() *types.Sym

+ func (n *StructKeyExpr) Transient() bool

+ func (n *StructKeyExpr) Type() *types.Type

+ type SwitchStmt struct

+ Cases []*CaseClause

+ Compiled Nodes

+ Label *types.Sym

+ Tag Node

+ func NewSwitchStmt(pos src.XPos, tag Node, cases []*CaseClause) *SwitchStmt

+ func (n *SwitchStmt) Format(s fmt.State, verb rune)

+ func (n *SwitchStmt) Init() Nodes

+ func (n *SwitchStmt) PtrInit() *Nodes

+ func (n *SwitchStmt) SetInit(x Nodes)

+ type SymAndPos struct

+ Pos src.XPos

+ Sym *obj.LSym

+ type TailCallStmt struct

+ Call *CallExpr

+ func NewTailCallStmt(pos src.XPos, call *CallExpr) *TailCallStmt

+ func (n *TailCallStmt) Format(s fmt.State, verb rune)

+ func (n *TailCallStmt) Init() Nodes

+ func (n *TailCallStmt) PtrInit() *Nodes

+ func (n *TailCallStmt) SetInit(x Nodes)

+ type TypeAssertExpr struct

+ ITab Node

+ X Node

+ func NewTypeAssertExpr(pos src.XPos, x Node, typ *types.Type) *TypeAssertExpr

+ func (n *TypeAssertExpr) Bounded() bool

+ func (n *TypeAssertExpr) Format(s fmt.State, verb rune)

+ func (n *TypeAssertExpr) Init() Nodes

+ func (n *TypeAssertExpr) MarkNonNil()

+ func (n *TypeAssertExpr) NonNil() bool

+ func (n *TypeAssertExpr) PtrInit() *Nodes

+ func (n *TypeAssertExpr) SetBounded(b bool)

+ func (n *TypeAssertExpr) SetInit(x Nodes)

+ func (n *TypeAssertExpr) SetOp(op Op)

+ func (n *TypeAssertExpr) SetTransient(b bool)

+ func (n *TypeAssertExpr) SetType(x *types.Type)

+ func (n *TypeAssertExpr) Transient() bool

+ func (n *TypeAssertExpr) Type() *types.Type

+ type TypeSwitchGuard struct

+ Tag *Ident

+ Used bool

+ X Node

+ func NewTypeSwitchGuard(pos src.XPos, tag *Ident, x Node) *TypeSwitchGuard

+ func (n *TypeSwitchGuard) Esc() uint16

+ func (n *TypeSwitchGuard) Format(s fmt.State, verb rune)

+ func (n *TypeSwitchGuard) Init() Nodes

+ func (n *TypeSwitchGuard) MarkNonNil()

+ func (n *TypeSwitchGuard) Name() *Name

+ func (n *TypeSwitchGuard) NonNil() bool

+ func (n *TypeSwitchGuard) Op() Op

+ func (n *TypeSwitchGuard) Pos() src.XPos

+ func (n *TypeSwitchGuard) SetEsc(x uint16)

+ func (n *TypeSwitchGuard) SetPos(x src.XPos)

+ func (n *TypeSwitchGuard) SetType(*types.Type)

+ func (n *TypeSwitchGuard) SetTypecheck(x uint8)

+ func (n *TypeSwitchGuard) SetVal(v constant.Value)

+ func (n *TypeSwitchGuard) SetWalked(x bool)

+ func (n *TypeSwitchGuard) Sym() *types.Sym

+ func (n *TypeSwitchGuard) Type() *types.Type

+ func (n *TypeSwitchGuard) Typecheck() uint8

+ func (n *TypeSwitchGuard) Val() constant.Value

+ func (n *TypeSwitchGuard) Walked() bool

+ type UnaryExpr struct

+ X Node

+ func NewUnaryExpr(pos src.XPos, op Op, x Node) *UnaryExpr

+ func (n *UnaryExpr) Bounded() bool

+ func (n *UnaryExpr) Format(s fmt.State, verb rune)

+ func (n *UnaryExpr) Init() Nodes

+ func (n *UnaryExpr) MarkNonNil()

+ func (n *UnaryExpr) NonNil() bool

+ func (n *UnaryExpr) PtrInit() *Nodes

+ func (n *UnaryExpr) SetBounded(b bool)

+ func (n *UnaryExpr) SetInit(x Nodes)

+ func (n *UnaryExpr) SetOp(op Op)

+ func (n *UnaryExpr) SetTransient(b bool)

+ func (n *UnaryExpr) SetType(x *types.Type)

+ func (n *UnaryExpr) Transient() bool

+ func (n *UnaryExpr) Type() *types.Type

+ type WasmImport struct

+ Module string

+ Name string

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL