ir

package

Go to main page

Versions in this module

v1

v1.22.2

Apr 24, 2024

v1.22.1

Apr 24, 2024

v1.22.0

Feb 13, 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.6

Jan 9, 2024

v1.21.5

Jan 6, 2024

v1.21.4

Jan 6, 2024

v1.21.3

Jan 6, 2024

v1.21.2

Jan 6, 2024

v1.21.1

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