ir

package
v1.23.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 14, 2024 License: MIT Imports: 7 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	EscUnknown = iota
	EscNone
	EscHeap
	EscNever
)
View Source 
const (
	// Maximum size in bits for big.Ints before signaling
	// overflow and also mantissa precision for big.Floats.
	ConstPrec = 512
)

Variables

View Source 
var (
	// MaxStackVarSize is the maximum size variable which we will allocate on the stack.
	// This limit is for explicit variable declarations like "var x T" or "x := ...".
	// Note: the flag smallframes can update this value.
	MaxStackVarSize = int64(10 * 1024 * 1024)

	// MaxImplicitStackVarSize is the maximum size of implicit variables that we will allocate on the stack.
	//   p := new(T)          allocating T on the stack
	//   p := &T{}            allocating T on the stack
	//   s := make([]T, n)    allocating [n]T on the stack
	//   s := []byte("...")   allocating [n]byte on the stack
	// Note: the flag smallframes can update this value.
	MaxImplicitStackVarSize = int64(64 * 1024)

	// MaxSmallArraySize is the maximum size of an array which is considered small.
	// Small arrays will be initialized directly with a sequence of constant stores.
	// Large arrays will be initialized by copying from a static temp.
	// 256 bytes was chosen to minimize generated code + statictmp size.
	MaxSmallArraySize = int64(256)
)
View Source 
var EscFmt func(n Node) string

EscFmt is set by the escape analysis code to add escape analysis details to the node print.

View Source 
var IsIntrinsicCall = func(*CallExpr) bool { return false }

IsIntrinsicCall reports whether the compiler back end will treat the call as an intrinsic operation.

View Source 
var OKForConst [types.NTYPE]bool
View Source 
var OpNames = []string{
	OADDR:             "&",
	OADD:              "+",
	OADDSTR:           "+",
	OANDAND:           "&&",
	OANDNOT:           "&^",
	OAND:              "&",
	OAPPEND:           "append",
	OAS:               "=",
	OAS2:              "=",
	OBREAK:            "break",
	OCALL:             "function call",
	OCAP:              "cap",
	OCASE:             "case",
	OCLEAR:            "clear",
	OCLOSE:            "close",
	OCOMPLEX:          "complex",
	OBITNOT:           "^",
	OCONTINUE:         "continue",
	OCOPY:             "copy",
	ODELETE:           "delete",
	ODEFER:            "defer",
	ODIV:              "/",
	OEQ:               "==",
	OFALL:             "fallthrough",
	OFOR:              "for",
	OGE:               ">=",
	OGOTO:             "goto",
	OGT:               ">",
	OIF:               "if",
	OIMAG:             "imag",
	OINLMARK:          "inlmark",
	ODEREF:            "*",
	OLEN:              "len",
	OLE:               "<=",
	OLSH:              "<<",
	OLT:               "<",
	OMAKE:             "make",
	ONEG:              "-",
	OMAX:              "max",
	OMIN:              "min",
	OMOD:              "%",
	OMUL:              "*",
	ONEW:              "new",
	ONE:               "!=",
	ONOT:              "!",
	OOROR:             "||",
	OOR:               "|",
	OPANIC:            "panic",
	OPLUS:             "+",
	OPRINTLN:          "println",
	OPRINT:            "print",
	ORANGE:            "range",
	OREAL:             "real",
	ORECV:             "<-",
	ORECOVER:          "recover",
	ORETURN:           "return",
	ORSH:              ">>",
	OSELECT:           "select",
	OSEND:             "<-",
	OSUB:              "-",
	OSWITCH:           "switch",
	OUNSAFEADD:        "unsafe.Add",
	OUNSAFESLICE:      "unsafe.Slice",
	OUNSAFESLICEDATA:  "unsafe.SliceData",
	OUNSAFESTRING:     "unsafe.String",
	OUNSAFESTRINGDATA: "unsafe.StringData",
	OXOR:              "^",
}
View Source 
var OpPrec = []int{}/* 116 elements not displayed */
View Source 
var Pkgs struct {
	Go       *types.Pkg
	Itab     *types.Pkg
	Runtime  *types.Pkg
	Coverage *types.Pkg
}

Pkgs holds known packages.

View Source 
var Syms symsStruct

Syms holds known symbols.

Functions

func Any 

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

Any looks for a non-nil node x in the IR tree rooted at n for which cond(x) returns true. Any considers nodes in a depth-first, preorder traversal. When Any finds a node x such that cond(x) is true, Any ends the traversal and returns true immediately. Otherwise Any returns false after completing the entire traversal.

func AnyList 

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

AnyList calls Any(x, cond) for each node x in the list, in order. If any call returns true, AnyList stops and returns true. Otherwise, AnyList returns false after calling Any(x, cond) for every x in the list.

func AssertValidTypeForConst 

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

func BigFloat 

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

func BoolVal 

func BoolVal(n Node) bool

BoolVal returns n as a bool. n must be a boolean constant.

func ClosureDebugRuntimeCheck 

func ClosureDebugRuntimeCheck(clo *ClosureExpr)

ClosureDebugRuntimeCheck applies boilerplate checks for debug flags and compiling runtime.

func ConstOverflow 

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

ConstOverflow reports whether constant value v is too large to represent with type t.

func ConstType 

func ConstType(n Node) constant.Kind

func DeclaredBy 

func DeclaredBy(x, stmt Node) bool

DeclaredBy reports whether expression x refers (directly) to a variable that was declared by the given statement.

func DoChildren 

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

DoChildren calls do(x) on each of n's non-nil child nodes x. If any call returns true, DoChildren stops and returns true. Otherwise, DoChildren returns false.

Note that DoChildren(n, do) only calls do(x) for n's immediate children. If x's children should be processed, then do(x) must call DoChildren(x, do).

DoChildren allows constructing general traversals of the IR graph that can stop early if needed. The most general usage is: 

var do func(ir.Node) bool
do = func(x ir.Node) bool {
	... processing BEFORE visiting children ...
	if ... should visit children ... {
		ir.DoChildren(x, do)
		... processing AFTER visiting children ...
	}
	if ... should stop parent DoChildren call from visiting siblings ... {
		return true
	}
	return false
}
do(root)

Since DoChildren does not return true itself, if the do function never wants to stop the traversal, it can assume that DoChildren itself will always return false, simplifying to: 

var do func(ir.Node) bool
do = func(x ir.Node) bool {
	... processing BEFORE visiting children ...
	if ... should visit children ... {
		ir.DoChildren(x, do)
	}
	... processing AFTER visiting children ...
	return false
}
do(root)

The Visit function illustrates a further simplification of the pattern, only processing before visiting children and never stopping: 

func Visit(n ir.Node, visit func(ir.Node)) {
	if n == nil {
		return
	}
	var do func(ir.Node) bool
	do = func(x ir.Node) bool {
		visit(x)
		return ir.DoChildren(x, do)
	}
	do(n)
}

The Any function illustrates a different simplification of the pattern, visiting each node and then its children, recursively, until finding a node x for which cond(x) returns true, at which point the entire traversal stops and returns true. 

func Any(n ir.Node, cond(ir.Node) bool) bool {
	if n == nil {
		return false
	}
	var do func(ir.Node) bool
	do = func(x ir.Node) bool {
		return cond(x) || ir.DoChildren(x, do)
	}
	return do(n)
}

Visit and Any are presented above as examples of how to use DoChildren effectively, but of course, usage that fits within the simplifications captured by Visit or Any will be best served by directly calling the ones provided by this package.

func DoChildrenWithHidden added in v1.23.0 

func DoChildrenWithHidden(n Node, do func(Node) bool) bool

DoChildrenWithHidden is like DoChildren, but also visits Node-typed fields tagged with `mknode:"-"`.

TODO(mdempsky): Remove the `mknode:"-"` tags so this function can go away.

func Dump 

func Dump(s string, n Node)

Dump prints the message s followed by a debug dump of n.

func DumpAny 

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

DumpAny is like FDumpAny but prints to stderr.

func DumpList 

func DumpList(s string, list Nodes)

DumpList prints the message s followed by a debug dump of each node in the list.

func EditChildren 

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

EditChildren edits the child nodes of n, replacing each child x with edit(x).

Note that EditChildren(n, edit) only calls edit(x) for n's immediate children. If x's children should be processed, then edit(x) must call EditChildren(x, edit).

EditChildren allows constructing general editing passes of the IR graph. The most general usage is: 

var edit func(ir.Node) ir.Node
edit = func(x ir.Node) ir.Node {
	... processing BEFORE editing children ...
	if ... should edit children ... {
		EditChildren(x, edit)
		... processing AFTER editing children ...
	}
	... return x ...
}
n = edit(n)

EditChildren edits the node in place. To edit a copy, call Copy first. As an example, a simple deep copy implementation would be: 

func deepCopy(n ir.Node) ir.Node {
	var edit func(ir.Node) ir.Node
	edit = func(x ir.Node) ir.Node {
		x = ir.Copy(x)
		ir.EditChildren(x, edit)
		return x
	}
	return edit(n)
}

Of course, in this case it is better to call ir.DeepCopy than to build one anew.

func EditChildrenWithHidden 

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

EditChildrenWithHidden is like EditChildren, but also edits Node-typed fields tagged with `mknode:"-"`.

TODO(mdempsky): Remove the `mknode:"-"` tags so this function can go away.

func FDumpAny 

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

FDumpAny prints the structure of a rooted data structure to w by depth-first traversal of the data structure.

The filter parameter is a regular expression. If it is non-empty, only struct fields whose names match filter are printed.

The depth parameter controls how deep traversal recurses before it returns (higher value means greater depth). If an empty field filter is given, a good depth default value is 4. A negative depth means no depth limit, which may be fine for small data structures or if there is a non-empty filter.

In the output, Node structs are identified by their Op name rather than their type; struct fields with zero values or non-matching field names are omitted, and "…" means recursion depth has been reached or struct fields have been omitted.

func FDumpList 

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

FDumpList prints to w the message s followed by a debug dump of each node in the list.

func FuncName 

func FuncName(f *Func) string

FuncName returns the name (without the package) of the function f.

func FuncSymName 

func FuncSymName(s *types.Sym) string

func HasUniquePos 

func HasUniquePos(n Node) bool

HasUniquePos reports whether n has a unique position that can be used for reporting error messages.

It's primarily used to distinguish references to named objects, whose Pos will point back to their declaration position rather than their usage position.

func InitLSym 

func InitLSym(f *Func, hasBody bool)

InitLSym defines f's obj.LSym and initializes it based on the properties of f. This includes setting the symbol flags and ABI and creating and initializing related DWARF symbols.

InitLSym must be called exactly once per function and must be called for both functions with bodies and functions without bodies. For body-less functions, we only create the LSym; for functions with bodies call a helper to setup up / populate the LSym.

func Int64Val 

func Int64Val(n Node) int64

Int64Val returns n as an int64. n must be an integer or rune constant.

func IntVal 

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

IntVal returns v converted to int64. Note: if t is uint64, very large values will be converted to negative int64.

func IsAddressable 

func IsAddressable(n Node) bool

lvalue etc

func IsAutoTmp 

func IsAutoTmp(n Node) bool

IsAutoTmp indicates if n was created by the compiler as a temporary, based on the setting of the .AutoTemp flag in n's Name.

func IsBlank 

func IsBlank(n Node) bool

func IsConst 

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

func IsConstNode 

func IsConstNode(n Node) bool

IsConstNode reports whether n is a Go language constant (as opposed to a compile-time constant).

Expressions derived from nil, like string([]byte(nil)), while they may be known at compile time, are not Go language constants.

func IsFuncPCIntrinsic added in v1.22.0 

func IsFuncPCIntrinsic(n *CallExpr) bool

IsFuncPCIntrinsic returns whether n is a direct call of internal/abi.FuncPCABIxxx functions.

func IsMethod 

func IsMethod(n Node) bool

IsMethod reports whether n is a method. n must be a function or a method.

func IsNil 

func IsNil(n Node) bool

IsNil reports whether n represents the universal untyped zero value "nil".

func IsReflectHeaderDataField 

func IsReflectHeaderDataField(l Node) bool

IsReflectHeaderDataField reports whether l is an expression p.Data where p has type reflect.SliceHeader or reflect.StringHeader.

func IsSmallIntConst 

func IsSmallIntConst(n Node) bool

func IsSynthetic 

func IsSynthetic(n Node) bool

func IsTrivialClosure 

func IsTrivialClosure(clo *ClosureExpr) bool

IsTrivialClosure reports whether closure clo has an empty list of captured vars.

func IsZero 

func IsZero(n Node) bool

func Line 

func Line(n Node) string

Line returns n's position as a string. If n has been inlined, it uses the outermost position where n has been inlined.

func LinkFuncName 

func LinkFuncName(f *Func) string

LinkFuncName returns the name of the function f, as it will appear in the symbol table of the final linked binary.

func LookupMethodSelector added in v1.22.0 

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

LookupMethodSelector returns the types.Sym of the selector for a method named in local symbol name, as well as the types.Sym of the receiver.

TODO(prattmic): this does not attempt to handle method suffixes (wrappers).

func MayBeShared 

func MayBeShared(n Node) bool

MayBeShared reports whether n may occur in multiple places in the AST. Extra care must be taken when mutating such a node.

func MethodExprFunc 

func MethodExprFunc(n Node) *types.Field

MethodExprFunc is like MethodExprName, but returns the types.Field instead.

func MethodSym 

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

MethodSym returns the method symbol representing a method name associated with a specific receiver type.

Method symbols can be used to distinguish the same method appearing in different method sets. For example, T.M and (*T).M have distinct method symbols.

The returned symbol will be marked as a function.

func MethodSymSuffix 

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

MethodSymSuffix is like MethodSym, but allows attaching a distinguisher suffix. To avoid collisions, the suffix must not start with a letter, number, or period.

func ParseLinkFuncName added in v1.22.0 

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

ParseLinkFuncName parsers a symbol name (as returned from LinkFuncName) back to the package path and local symbol name.

func PkgFuncName 

func PkgFuncName(f *Func) string

PkgFuncName returns the name of the function referenced by f, with package prepended.

This differs from the compiler's internal convention where local functions lack a package. This is primarily useful when the ultimate consumer of this is a human looking at message.

func Reassigned added in v1.22.0 

func Reassigned(name *Name) bool

Reassigned takes an ONAME node, walks the function in which it is defined, and returns a boolean indicating whether the name has any assignments other than its declaration. NB: global variables are always considered to be re-assigned. TODO: handle initial declaration not including an assignment and followed by a single assignment? NOTE: any changes made here should also be made in the corresponding code in the ReassignOracle.Init method.

func SameSafeExpr 

func SameSafeExpr(l Node, r Node) bool

SameSafeExpr checks whether it is safe to reuse one of l and r instead of computing both. SameSafeExpr assumes that l and r are used in the same statement or expression. In order for it to be safe to reuse l or r, they must:

  • be the same expression
  • not have side-effects (no function calls, no channel ops); however, panics are ok
  • not cause inappropriate aliasing; e.g. two string to []byte conversions, must result in two distinct slices

The handling of OINDEXMAP is subtle. OINDEXMAP can occur both as an lvalue (map assignment) and an rvalue (map access). This is currently OK, since the only place SameSafeExpr gets used on an lvalue expression is for OSLICE and OAPPEND optimizations, and it is correct in those settings.

func SameSource 

func SameSource(n1, n2 Node) bool

SameSource reports whether two nodes refer to the same source element.

It exists to help incrementally migrate the compiler towards allowing the introduction of IdentExpr (#42990). Once we have IdentExpr, it will no longer be safe to directly compare Node values to tell if they refer to the same Name. Instead, code will need to explicitly get references to the underlying Name object(s), and compare those instead.

It will still be safe to compare Nodes directly for checking if two nodes are syntactically the same. The SameSource function exists to indicate code that intentionally compares Nodes for syntactic equality as opposed to code that has yet to be updated in preparation for IdentExpr.

func SetPos 

func SetPos(n Node) src.XPos

func ShouldAsanCheckPtr 

func ShouldAsanCheckPtr(fn *Func) bool

ShouldAsanCheckPtr reports whether pointer checking should be enabled for function fn when -asan is enabled.

func ShouldCheckPtr 

func ShouldCheckPtr(fn *Func, level int) bool

ShouldCheckPtr reports whether pointer checking should be enabled for function fn at a given level. See debugHelpFooter for defined levels.

func StmtWithInit 

func StmtWithInit(op Op) bool

StmtWithInit reports whether op is a statement with an explicit init list.

func StringVal 

func StringVal(n Node) string

StringVal returns the value of a literal string Node as a string. n must be a string constant.

func Uint64Val 

func Uint64Val(n Node) uint64

Uint64Val returns n as a uint64. n must be an integer or rune constant.

func Uses 

func Uses(x Node, v *Name) bool

Uses reports whether expression x is a (direct) use of the given variable.

func ValidTypeForConst 

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

func Visit 

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

Visit visits each non-nil node x in the IR tree rooted at n in a depth-first preorder traversal, calling visit on each node visited.

func VisitFuncAndClosures 

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

VisitFuncAndClosures calls visit on each non-nil node in fn.Body, including any nested closure bodies.

func VisitFuncsBottomUp 

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

VisitFuncsBottomUp invokes analyze on the ODCLFUNC nodes listed in list. It calls analyze with successive groups of functions, working from the bottom of the call graph upward. Each time analyze is called with a list of functions, every function on that list only calls other functions on the list or functions that have been passed in previous invocations of analyze. Closures appear in the same list as their outer functions. The lists are as short as possible while preserving those requirements. (In a typical program, many invocations of analyze will be passed just a single function.) The boolean argument 'recursive' passed to analyze specifies whether the functions on the list are mutually recursive. If recursive is false, the list consists of only a single function and its closures. If recursive is true, the list may still contain only a single function, if that function is itself recursive.

func VisitList 

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

VisitList calls Visit(x, visit) for each node x in the list.

func WithFunc 

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

WithFunc invokes do with CurFunc and base.Pos set to curfn and curfn.Pos(), respectively, and then restores their previous values before returning.

Types

type AddStringExpr 

type AddStringExpr struct {
	List     Nodes
	Prealloc *Name
	// contains filtered or unexported fields
}

An AddStringExpr is a string concatenation List[0] + List[1] + ... + List[len(List)-1].

func NewAddStringExpr 

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

func (*AddStringExpr) Format 

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

type AddrExpr 

type AddrExpr struct {
	X        Node
	Prealloc *Name
	// contains filtered or unexported fields
}

An AddrExpr is an address-of expression &X. It may end up being a normal address-of or an allocation of a composite literal.

func NewAddrExpr 

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

func (*AddrExpr) Format 

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

func (*AddrExpr) Implicit 

func (n *AddrExpr) Implicit() bool

func (*AddrExpr) SetImplicit 

func (n *AddrExpr) SetImplicit(b bool)

func (*AddrExpr) SetOp 

func (n *AddrExpr) SetOp(op Op)

type AssignListStmt 

type AssignListStmt struct {
	Lhs Nodes
	Def bool
	Rhs Nodes
	// contains filtered or unexported fields
}

An AssignListStmt is an assignment statement with more than one item on at least one side: Lhs = Rhs. If Def is true, the assignment is a :=.

func NewAssignListStmt 

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

func (*AssignListStmt) Format 

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

func (*AssignListStmt) SetOp 

func (n *AssignListStmt) SetOp(op Op)

type AssignOpStmt 

type AssignOpStmt struct {
	X      Node
	AsOp   Op
	Y      Node
	IncDec bool
	// contains filtered or unexported fields
}

An AssignOpStmt is an AsOp= assignment statement: X AsOp= Y.

func NewAssignOpStmt 

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

func (*AssignOpStmt) Format 

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

type AssignStmt 

type AssignStmt struct {
	X   Node
	Def bool
	Y   Node
	// contains filtered or unexported fields
}

An AssignStmt is a simple assignment statement: X = Y. If Def is true, the assignment is a :=.

func NewAssignStmt 

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

func (*AssignStmt) Format 

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

func (*AssignStmt) SetOp 

func (n *AssignStmt) SetOp(op Op)

type BasicLit 

type BasicLit struct {
	// contains filtered or unexported fields
}

A BasicLit is a literal of basic type.

func (*BasicLit) Format 

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

func (*BasicLit) SetVal 

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

func (*BasicLit) Val 

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

type BinaryExpr 

type BinaryExpr struct {
	X     Node
	Y     Node
	RType Node `mknode:"-"`
	// contains filtered or unexported fields
}

A BinaryExpr is a binary expression X Op Y, or Op(X, Y) for builtin functions that do not become calls.

func NewBinaryExpr 

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

func (*BinaryExpr) Format 

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

func (*BinaryExpr) SetOp 

func (n *BinaryExpr) SetOp(op Op)

type BlockStmt 

type BlockStmt struct {
	List Nodes
	// contains filtered or unexported fields
}

A BlockStmt is a block: { List }.

func NewBlockStmt 

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

func (*BlockStmt) Format 

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

type BranchStmt 

type BranchStmt struct {
	Label *types.Sym
	// contains filtered or unexported fields
}

A BranchStmt is a break, continue, fallthrough, or goto statement.

func NewBranchStmt 

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

func (*BranchStmt) Format 

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

func (*BranchStmt) SetOp 

func (n *BranchStmt) SetOp(op Op)

func (*BranchStmt) Sym 

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

type CallExpr 

type CallExpr struct {
	Fun       Node
	Args      Nodes
	DeferAt   Node
	RType     Node `mknode:"-"`
	KeepAlive []*Name
	IsDDD     bool
	GoDefer   bool
	NoInline  bool
	// contains filtered or unexported fields
}

A CallExpr is a function call Fun(Args).

func NewCallExpr 

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

func (*CallExpr) Format 

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

func (*CallExpr) SetOp 

func (n *CallExpr) SetOp(op Op)

type CaseClause 

type CaseClause struct {
	Var  *Name
	List Nodes

	// RTypes is a list of RType expressions, which are copied to the
	// corresponding OEQ nodes that are emitted when switch statements
	// are desugared. RTypes[i] must be non-nil if the emitted
	// comparison for List[i] will be a mixed interface/concrete
	// comparison; see reflectdata.CompareRType for details.
	//
	// Because mixed interface/concrete switch cases are rare, we allow
	// len(RTypes) < len(List). Missing entries are implicitly nil.
	RTypes Nodes

	Body Nodes
	// contains filtered or unexported fields
}

A CaseClause is a case statement in a switch or select: case List: Body.

func NewCaseStmt 

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

func (*CaseClause) Format 

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

type Class 

type Class uint8

The Class of a variable/function describes the "storage class" of a variable or function. During parsing, storage classes are called declaration contexts. 

const (
	Pxxx Class = iota
	PEXTERN
	PAUTO
	PAUTOHEAP
	PPARAM
	PPARAMOUT
	PTYPEPARAM
	PFUNC
)

func (Class) String 

func (i Class) String() string

type ClosureExpr 

type ClosureExpr struct {
	Func     *Func `mknode:"-"`
	Prealloc *Name
	IsGoWrap bool
	// contains filtered or unexported fields
}

A ClosureExpr is a function literal expression.

func (*ClosureExpr) Format 

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

type CommClause 

type CommClause struct {
	Comm Node
	Body Nodes
	// contains filtered or unexported fields
}

func NewCommStmt 

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

func (*CommClause) Format 

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

type CompLitExpr 

type CompLitExpr struct {
	List     Nodes
	RType    Node `mknode:"-"`
	Prealloc *Name
	// For OSLICELIT, Len is the backing array length.
	// For OMAPLIT, Len is the number of entries that we've removed from List and
	// generated explicit mapassign calls for. This is used to inform the map alloc hint.
	Len int64
	// contains filtered or unexported fields
}

A CompLitExpr is a composite literal Type{Vals}. Before type-checking, the type is Ntype.

func NewCompLitExpr 

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

func (*CompLitExpr) Format 

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

func (*CompLitExpr) Implicit 

func (n *CompLitExpr) Implicit() bool

func (*CompLitExpr) SetImplicit 

func (n *CompLitExpr) SetImplicit(b bool)

func (*CompLitExpr) SetOp 

func (n *CompLitExpr) SetOp(op Op)

type ConvExpr 

type ConvExpr struct {
	X Node

	// For implementing OCONVIFACE expressions.
	//
	// TypeWord is an expression yielding a *runtime._type or
	// *runtime.itab value to go in the type word of the iface/eface
	// result. See reflectdata.ConvIfaceTypeWord for further details.
	//
	// SrcRType is an expression yielding a *runtime._type value for X,
	// if it's not pointer-shaped and needs to be heap allocated.
	TypeWord Node `mknode:"-"`
	SrcRType Node `mknode:"-"`

	// For -d=checkptr instrumentation of conversions from
	// unsafe.Pointer to *Elem or *[Len]Elem.
	//
	// TODO(mdempsky): We only ever need one of these, but currently we
	// don't decide which one until walk. Longer term, it probably makes
	// sense to have a dedicated IR op for `(*[Len]Elem)(ptr)[:n:m]`
	// expressions.
	ElemRType     Node `mknode:"-"`
	ElemElemRType Node `mknode:"-"`
	// contains filtered or unexported fields
}

A ConvExpr is a conversion Type(X). It may end up being a value or a type.

func NewConvExpr 

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

func (*ConvExpr) CheckPtr 

func (n *ConvExpr) CheckPtr() bool

func (*ConvExpr) Format 

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

func (*ConvExpr) Implicit 

func (n *ConvExpr) Implicit() bool

func (*ConvExpr) SetCheckPtr 

func (n *ConvExpr) SetCheckPtr(b bool)

func (*ConvExpr) SetImplicit 

func (n *ConvExpr) SetImplicit(b bool)

func (*ConvExpr) SetOp 

func (n *ConvExpr) SetOp(op Op)

type Decl 

type Decl struct {
	X *Name
	// contains filtered or unexported fields
}

A Decl is a declaration of a const, type, or var. (A declared func is a Func.)

func NewDecl 

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

func (*Decl) Format 

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

type DynamicType 

type DynamicType struct {

	// RType is an expression that yields a *runtime._type value
	// representing the asserted type.
	//
	// BUG(mdempsky): If ITab is non-nil, RType may be nil.
	RType Node

	// ITab is an expression that yields a *runtime.itab value
	// representing the asserted type within the assertee expression's
	// original interface type.
	//
	// ITab is only used for assertions (including type switches) from
	// non-empty interface type to a concrete (i.e., non-interface)
	// type. For all other assertions, ITab is nil.
	ITab Node
	// contains filtered or unexported fields
}

A DynamicType represents a type expression whose exact type must be computed dynamically.

func NewDynamicType 

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

func (*DynamicType) Format 

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

type DynamicTypeAssertExpr 

type DynamicTypeAssertExpr struct {
	X Node

	// SrcRType is an expression that yields a *runtime._type value
	// representing X's type. It's used in failed assertion panic
	// messages.
	SrcRType Node

	// RType is an expression that yields a *runtime._type value
	// representing the asserted type.
	//
	// BUG(mdempsky): If ITab is non-nil, RType may be nil.
	RType Node

	// ITab is an expression that yields a *runtime.itab value
	// representing the asserted type within the assertee expression's
	// original interface type.
	//
	// ITab is only used for assertions from non-empty interface type to
	// a concrete (i.e., non-interface) type. For all other assertions,
	// ITab is nil.
	ITab Node
	// contains filtered or unexported fields
}

A DynamicTypeAssertExpr asserts that X is of dynamic type RType.

func NewDynamicTypeAssertExpr 

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

func (*DynamicTypeAssertExpr) Format 

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

func (*DynamicTypeAssertExpr) SetOp 

func (n *DynamicTypeAssertExpr) SetOp(op Op)

type Embed 

type Embed struct {
	Pos      src.XPos
	Patterns []string
}

type Expr 

type Expr interface {
	Node
	// contains filtered or unexported methods
}

An Expr is a Node that can appear as an expression.

type ForStmt 

type ForStmt struct {
	Label        *types.Sym
	Cond         Node
	Post         Node
	Body         Nodes
	DistinctVars bool
	// contains filtered or unexported fields
}

A ForStmt is a non-range for loop: for Init; Cond; Post { Body }

func NewForStmt 

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

func (*ForStmt) Format 

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

type Func 

type Func struct {
	Body Nodes

	Nname    *Name
	OClosure *ClosureExpr

	// ONAME nodes for all params/locals for this func/closure, does NOT
	// include closurevars until transforming closures during walk.
	// Names must be listed PPARAMs, PPARAMOUTs, then PAUTOs,
	// with PPARAMs and PPARAMOUTs in order corresponding to the function signature.
	// Anonymous and blank params are declared as ~pNN (for PPARAMs) and ~rNN (for PPARAMOUTs).
	Dcl []*Name

	// ClosureVars lists the free variables that are used within a
	// function literal, but formally declared in an enclosing
	// function. The variables in this slice are the closure function's
	// own copy of the variables, which are used within its function
	// body. They will also each have IsClosureVar set, and will have
	// Byval set if they're captured by value.
	ClosureVars []*Name

	// Enclosed functions that need to be compiled.
	// Populated during walk.
	Closures []*Func

	// Parents records the parent scope of each scope within a
	// function. The root scope (0) has no parent, so the i'th
	// scope's parent is stored at Parents[i-1].
	Parents []ScopeID

	// Marks records scope boundary changes.
	Marks []Mark

	FieldTrack map[*obj.LSym]struct{}
	DebugInfo  interface{}
	LSym       *obj.LSym

	Inl *Inline

	// RangeParent, if non-nil, is the first non-range body function containing
	// the closure for the body of a range function.
	RangeParent *Func

	Label int32

	Endlineno src.XPos
	WBPos     src.XPos

	Pragma PragmaFlag

	// ABI is a function's "definition" ABI. This is the ABI that
	// this function's generated code is expecting to be called by.
	//
	// For most functions, this will be obj.ABIInternal. It may be
	// a different ABI for functions defined in assembly or ABI wrappers.
	//
	// This is included in the export data and tracked across packages.
	ABI obj.ABI
	// ABIRefs is the set of ABIs by which this function is referenced.
	// For ABIs other than this function's definition ABI, the
	// compiler generates ABI wrapper functions. This is only tracked
	// within a package.
	ABIRefs obj.ABISet

	NumDefers  int32
	NumReturns int32

	// NWBRCalls records the LSyms of functions called by this
	// function for go:nowritebarrierrec analysis. Only filled in
	// if nowritebarrierrecCheck != nil.
	NWBRCalls *[]SymAndPos

	// For wrapper functions, WrappedFunc point to the original Func.
	// Currently only used for go/defer wrappers.
	WrappedFunc *Func

	// WasmImport is used by the //go:wasmimport directive to store info about
	// a WebAssembly function import.
	WasmImport *WasmImport
	// WasmExport is used by the //go:wasmexport directive to store info about
	// a WebAssembly function import.
	WasmExport *WasmExport
	// contains filtered or unexported fields
}

A Func corresponds to a single function in a Go program (and vice versa: each function is denoted by exactly one *Func).

There are multiple nodes that represent a Func in the IR.

The ONAME node (Func.Nname) is used for plain references to it. The ODCLFUNC node (the Func itself) is used for its declaration code. The OCLOSURE node (Func.OClosure) is used for a reference to a function literal.

An imported function will have an ONAME node which points to a Func with an empty body. A declared function or method has an ODCLFUNC (the Func itself) and an ONAME. A function literal is represented directly by an OCLOSURE, but it also has an ODCLFUNC (and a matching ONAME) representing the compiled underlying form of the closure, which accesses the captured variables using a special data structure passed in a register.

A method declaration is represented like functions, except f.Sym will be the qualified method name (e.g., "T.m").

A method expression (T.M) is represented as an OMETHEXPR node, in which n.Left and n.Right point to the type and method, respectively. Each distinct mention of a method expression in the source code constructs a fresh node.

A method value (t.M) is represented by ODOTMETH/ODOTINTER when it is called directly and by OMETHVALUE otherwise. These are like method expressions, except that for ODOTMETH/ODOTINTER, the method name is stored in Sym instead of Right. Each OMETHVALUE ends up being implemented as a new function, a bit like a closure, with its own ODCLFUNC. The OMETHVALUE uses n.Func to record the linkage to the generated ODCLFUNC, but there is no pointer from the Func back to the OMETHVALUE. 

var CurFunc *Func

func IsIfaceOfFunc added in v1.22.0 

func IsIfaceOfFunc(n Node) *Func

IsIfaceOfFunc inspects whether n is an interface conversion from a direct reference of a func. If so, it returns referenced Func; otherwise nil.

This is only usable before walk.walkConvertInterface, which converts to an OMAKEFACE.

func NewClosureFunc 

func NewClosureFunc(fpos, cpos src.XPos, why Op, typ *types.Type, outerfn *Func, pkg *Package) *Func

NewClosureFunc creates a new Func to represent a function literal with the given type.

fpos the position used for the underlying ODCLFUNC and ONAME, whereas cpos is the position used for the OCLOSURE. They're separate because in the presence of inlining, the OCLOSURE node should have an inline-adjusted position, whereas the ODCLFUNC and ONAME must not.

outerfn is the enclosing function. The returned function is appending to pkg.Funcs.

why is the reason we're generating this Func. It can be OCLOSURE (for a normal function literal) or OGO or ODEFER (for wrapping a call expression that has parameters or results).

func NewFunc 

func NewFunc(fpos, npos src.XPos, sym *types.Sym, typ *types.Type) *Func

NewFunc returns a new Func with the given name and type.

fpos is the position of the "func" token, and npos is the position of the name identifier.

TODO(mdempsky): I suspect there's no need for separate fpos and npos.

func (*Func) ABIWrapper 

func (f *Func) ABIWrapper() bool

func (*Func) ClosureResultsLost added in v1.22.0 

func (f *Func) ClosureResultsLost() bool

func (*Func) DeclareParams added in v1.22.0 

func (fn *Func) DeclareParams(setNname bool)

DeclareParams creates Names for all of the parameters in fn's signature and adds them to fn.Dcl.

If setNname is true, then it also sets types.Field.Nname for each parameter.

func (*Func) Dupok 

func (f *Func) Dupok() bool

func (*Func) Format 

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

func (*Func) HasDefer 

func (f *Func) HasDefer() bool

func (*Func) InlinabilityChecked 

func (f *Func) InlinabilityChecked() bool

func (*Func) IsClosure added in v1.23.0 

func (f *Func) IsClosure() bool

func (*Func) IsPackageInit 

func (f *Func) IsPackageInit() bool

func (*Func) Linksym 

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

func (*Func) LinksymABI 

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

func (*Func) Needctxt 

func (f *Func) Needctxt() bool

func (*Func) NeverReturns added in v1.22.0 

func (f *Func) NeverReturns() bool

func (*Func) NewLocal added in v1.22.0 

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

NewLocal returns a new function-local variable with the given name and type.

func (*Func) NilCheckDisabled 

func (f *Func) NilCheckDisabled() bool

func (*Func) OpenCodedDeferDisallowed 

func (f *Func) OpenCodedDeferDisallowed() bool

func (*Func) SetABIWrapper 

func (f *Func) SetABIWrapper(b bool)

func (*Func) SetClosureResultsLost added in v1.22.0 

func (f *Func) SetClosureResultsLost(b bool)

func (*Func) SetDupok 

func (f *Func) SetDupok(b bool)

func (*Func) SetHasDefer 

func (f *Func) SetHasDefer(b bool)

func (*Func) SetInlinabilityChecked 

func (f *Func) SetInlinabilityChecked(b bool)

func (*Func) SetIsPackageInit 

func (f *Func) SetIsPackageInit(b bool)

func (*Func) SetNeedctxt 

func (f *Func) SetNeedctxt(b bool)

func (*Func) SetNeverReturns added in v1.22.0 

func (f *Func) SetNeverReturns(b bool)

func (*Func) SetNilCheckDisabled 

func (f *Func) SetNilCheckDisabled(b bool)

func (*Func) SetOpenCodedDeferDisallowed 

func (f *Func) SetOpenCodedDeferDisallowed(b bool)

func (*Func) SetWBPos 

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

func (*Func) SetWrapper 

func (f *Func) SetWrapper(b bool)

func (*Func) Sym 

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

func (*Func) Type 

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

func (*Func) Wrapper 

func (f *Func) Wrapper() bool

type GoDeferStmt 

type GoDeferStmt struct {
	Call    Node
	DeferAt Expr
	// contains filtered or unexported fields
}

A GoDeferStmt is a go or defer statement: go Call / defer Call.

The two opcodes use a single syntax because the implementations are very similar: both are concerned with saving Call and running it in a different context (a separate goroutine or a later time).

func NewGoDeferStmt 

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

func (*GoDeferStmt) Format 

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

type Ident 

type Ident struct {
	// contains filtered or unexported fields
}

An Ident is an identifier, possibly qualified.

func NewIdent 

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

func (*Ident) Format 

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

func (*Ident) Sym 

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

type IfStmt 

type IfStmt struct {
	Cond   Node
	Body   Nodes
	Else   Nodes
	Likely bool
	// contains filtered or unexported fields
}

An IfStmt is a return statement: if Init; Cond { Body } else { Else }.

func NewIfStmt 

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

func (*IfStmt) Format 

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

type IndexExpr 

type IndexExpr struct {
	X        Node
	Index    Node
	RType    Node `mknode:"-"`
	Assigned bool
	// contains filtered or unexported fields
}

An IndexExpr is an index expression X[Index].

func NewIndexExpr 

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

func (*IndexExpr) Format 

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

func (*IndexExpr) SetOp 

func (n *IndexExpr) SetOp(op Op)

type InitNode 

type InitNode interface {
	Node
	PtrInit() *Nodes
	SetInit(x Nodes)
}

type Inline 

type Inline struct {
	Cost int32

	// Copy of Func.Dcl for use during inlining. This copy is needed
	// because the function's Dcl may change from later compiler
	// transformations. This field is also populated when a function
	// from another package is imported and inlined.
	Dcl     []*Name
	HaveDcl bool

	// Function properties, encoded as a string (these are used for
	// making inlining decisions). See cmd/compile/internal/inline/inlheur.
	Properties string

	// CanDelayResults reports whether it's safe for the inliner to delay
	// initializing the result parameters until immediately before the
	// "return" statement.
	CanDelayResults bool
}

An Inline holds fields used for function bodies that can be inlined.

type InlineMarkStmt 

type InlineMarkStmt struct {
	Index int64
	// contains filtered or unexported fields
}

An InlineMarkStmt is a marker placed just before an inlined body.

func NewInlineMarkStmt 

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

func (*InlineMarkStmt) Format 

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

func (*InlineMarkStmt) Offset 

func (n *InlineMarkStmt) Offset() int64

func (*InlineMarkStmt) SetOffset 

func (n *InlineMarkStmt) SetOffset(x int64)

type InlinedCallExpr 

type InlinedCallExpr struct {
	Body       Nodes
	ReturnVars Nodes
	// contains filtered or unexported fields
}

An InlinedCallExpr is an inlined function call.

func NewInlinedCallExpr 

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

func (*InlinedCallExpr) Format 

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

func (*InlinedCallExpr) SingleResult 

func (n *InlinedCallExpr) SingleResult() Node

type InterfaceSwitchStmt added in v1.22.0 

type InterfaceSwitchStmt struct {
	Case        Node
	Itab        Node
	RuntimeType Node
	Hash        Node
	Descriptor  *obj.LSym
	// contains filtered or unexported fields
}

An InterfaceSwitchStmt is used to implement type switches. Its semantics are: 

if RuntimeType implements Descriptor.Cases[0] {
    Case, Itab = 0, itab<RuntimeType, Descriptor.Cases[0]>
} else if RuntimeType implements Descriptor.Cases[1] {
    Case, Itab = 1, itab<RuntimeType, Descriptor.Cases[1]>
...
} else if RuntimeType implements Descriptor.Cases[N-1] {
    Case, Itab = N-1, itab<RuntimeType, Descriptor.Cases[N-1]>
} else {
    Case, Itab = len(cases), nil
}

RuntimeType must be a non-nil *runtime._type. Hash must be the hash field of RuntimeType (or its copy loaded from an itab). Descriptor must represent an abi.InterfaceSwitch global variable.

func NewInterfaceSwitchStmt added in v1.22.0 

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

func (*InterfaceSwitchStmt) Format added in v1.22.0 

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

type JumpTableStmt 

type JumpTableStmt struct {

	// Value used to index the jump table.
	// We support only integer types that
	// are at most the size of a uintptr.
	Idx Node

	// If Idx is equal to Cases[i], jump to Targets[i].
	// Cases entries must be distinct and in increasing order.
	// The length of Cases and Targets must be equal.
	Cases   []constant.Value
	Targets []*types.Sym
	// contains filtered or unexported fields
}

A JumpTableStmt is used to implement switches. Its semantics are: 

tmp := jt.Idx
if tmp == Cases[0] goto Targets[0]
if tmp == Cases[1] goto Targets[1]
...
if tmp == Cases[n] goto Targets[n]

Note that a JumpTableStmt is more like a multiway-goto than a multiway-if. In particular, the case bodies are just labels to jump to, not full Nodes lists.

func NewJumpTableStmt 

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

func (*JumpTableStmt) Format 

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

type KeyExpr 

type KeyExpr struct {
	Key   Node
	Value Node
	// contains filtered or unexported fields
}

A KeyExpr is a Key: Value composite literal key.

func NewKeyExpr 

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

func (*KeyExpr) Format 

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

type LabelStmt 

type LabelStmt struct {
	Label *types.Sym
	// contains filtered or unexported fields
}

A LabelStmt is a label statement (just the label, not including the statement it labels).

func NewLabelStmt 

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

func (*LabelStmt) Format 

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

func (*LabelStmt) Sym 

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

type LinksymOffsetExpr 

type LinksymOffsetExpr struct {
	Linksym *obj.LSym
	Offset_ int64
	// contains filtered or unexported fields
}

A LinksymOffsetExpr refers to an offset within a global variable. It is like a SelectorExpr but without the field name.

func NewLinksymExpr 

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

NewLinksymExpr is NewLinksymOffsetExpr, but with offset fixed at 0.

func NewLinksymOffsetExpr 

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

func NewNameOffsetExpr 

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

NewNameOffsetExpr is NewLinksymOffsetExpr, but taking a *Name representing a global variable instead of an *obj.LSym directly.

func (*LinksymOffsetExpr) Format 

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

type LogicalExpr 

type LogicalExpr struct {
	X Node
	Y Node
	// contains filtered or unexported fields
}

A LogicalExpr is an expression X Op Y where Op is && or ||. It is separate from BinaryExpr to make room for statements that must be executed before Y but after X.

func NewLogicalExpr 

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

func (*LogicalExpr) Format 

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

func (*LogicalExpr) SetOp 

func (n *LogicalExpr) SetOp(op Op)

type MakeExpr 

type MakeExpr struct {
	RType Node `mknode:"-"`
	Len   Node
	Cap   Node
	// contains filtered or unexported fields
}

A MakeExpr is a make expression: make(Type[, Len[, Cap]]). Op is OMAKECHAN, OMAKEMAP, OMAKESLICE, or OMAKESLICECOPY, but *not* OMAKE (that's a pre-typechecking CallExpr).

func NewMakeExpr 

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

func (*MakeExpr) Format 

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

func (*MakeExpr) SetOp 

func (n *MakeExpr) SetOp(op Op)

type Mark 

type Mark struct {
	// Pos is the position of the token that marks the scope
	// change.
	Pos src.XPos

	// Scope identifies the innermost scope to the right of Pos.
	Scope ScopeID
}

A Mark represents a scope boundary.

type Name 

type Name struct {
	BuiltinOp Op
	Class     Class

	DictIndex uint16

	Func    *Func
	Offset_ int64

	Opt   interface{}
	Embed *[]Embed

	// For a local variable (not param) or extern, the initializing assignment (OAS or OAS2).
	// For a closure var, the ONAME node of the original (outermost) captured variable.
	// For the case-local variables of a type switch, the type switch guard (OTYPESW).
	// For a range variable, the range statement (ORANGE)
	// For a recv variable in a case of a select statement, the receive assignment (OSELRECV2)
	// For the name of a function, points to corresponding Func node.
	Defn Node

	// The function, method, or closure in which local variable or param is declared.
	Curfn *Func

	Heapaddr *Name

	// Outer points to the immediately enclosing function's copy of this
	// closure variable. If not a closure variable, then Outer is nil.
	Outer *Name
	// contains filtered or unexported fields
}

Name holds Node fields used only by named nodes (ONAME, OTYPE, some OLITERAL). 

var BlankNode *Name

func MethodExprName 

func MethodExprName(n Node) *Name

MethodExprName returns the ONAME representing the method referenced by expression n, which must be a method selector, method expression, or method value.

func NewBuiltin added in v1.22.0 

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

NewBuiltin returns a new Name representing a builtin function, either predeclared or from package unsafe.

func NewClosureVar 

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

NewClosureVar returns a new closure variable for fn to refer to outer variable n.

func NewConstAt 

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

NewConstAt returns a new OLITERAL Node associated with symbol s at position pos.

func NewDeclNameAt 

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

NewDeclNameAt returns a new Name associated with symbol s at position pos. The caller is responsible for setting Curfn.

func NewHiddenParam 

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

NewHiddenParam returns a new hidden parameter for fn with the given name and type.

func NewNameAt 

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

NewNameAt returns a new ONAME Node associated with symbol s at position pos. The caller is responsible for setting Curfn.

func StaticCalleeName added in v1.22.0 

func StaticCalleeName(n Node) *Name

StaticCalleeName returns the ONAME/PFUNC for n, if known.

func (*Name) Addrtaken 

func (n *Name) Addrtaken() bool

func (*Name) Alias 

func (n *Name) Alias() bool

Alias reports whether p, which must be for an OTYPE, is a type alias.

func (*Name) AutoTemp 

func (n *Name) AutoTemp() bool

func (*Name) Byval 

func (n *Name) Byval() bool

func (*Name) CanBeAnSSAAux 

func (*Name) CanBeAnSSAAux()

func (*Name) CanBeAnSSASym 

func (*Name) CanBeAnSSASym()

func (*Name) CanBeNtype 

func (*Name) CanBeNtype()

func (*Name) Canonical 

func (n *Name) Canonical() *Name

Canonical returns the logical declaration that n represents. If n is a closure variable, then Canonical returns the original Name as it appears in the function that immediately contains the declaration. Otherwise, Canonical simply returns n itself.

func (*Name) CoverageAuxVar 

func (n *Name) CoverageAuxVar() bool

func (*Name) Format 

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

func (*Name) FrameOffset 

func (n *Name) FrameOffset() int64

func (*Name) InlFormal 

func (n *Name) InlFormal() bool

func (*Name) InlLocal 

func (n *Name) InlLocal() bool

func (*Name) IsClosureVar 

func (n *Name) IsClosureVar() bool

func (*Name) IsOutputParamHeapAddr 

func (n *Name) IsOutputParamHeapAddr() bool

func (*Name) IsOutputParamInRegisters 

func (n *Name) IsOutputParamInRegisters() bool

func (*Name) Libfuzzer8BitCounter 

func (n *Name) Libfuzzer8BitCounter() bool

func (*Name) Linksym 

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

func (*Name) LinksymABI 

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

func (*Name) MarkReadonly 

func (n *Name) MarkReadonly()

MarkReadonly indicates that n is an ONAME with readonly contents.

func (*Name) Name 

func (n *Name) Name() *Name

func (*Name) Needzero 

func (n *Name) Needzero() bool

func (*Name) NonMergeable added in v1.23.0 

func (n *Name) NonMergeable() bool

func (*Name) OnStack 

func (n *Name) OnStack() bool

OnStack reports whether variable n may reside on the stack.

func (*Name) OpenDeferSlot 

func (n *Name) OpenDeferSlot() bool

func (*Name) Pragma 

func (n *Name) Pragma() PragmaFlag

Pragma returns the PragmaFlag for p, which must be for an OTYPE.

func (*Name) Readonly 

func (n *Name) Readonly() bool

func (*Name) RecordFrameOffset 

func (n *Name) RecordFrameOffset(offset int64)

RecordFrameOffset records the frame offset for the name. It is used by package types when laying out function arguments.

func (*Name) SetAddrtaken 

func (n *Name) SetAddrtaken(b bool)

func (*Name) SetAlias 

func (n *Name) SetAlias(alias bool)

SetAlias sets whether p, which must be for an OTYPE, is a type alias.

func (*Name) SetAutoTemp 

func (n *Name) SetAutoTemp(b bool)

func (*Name) SetByval 

func (n *Name) SetByval(b bool)

func (*Name) SetCoverageAuxVar 

func (n *Name) SetCoverageAuxVar(b bool)

func (*Name) SetFrameOffset 

func (n *Name) SetFrameOffset(x int64)

func (*Name) SetFunc 

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

func (*Name) SetInlFormal 

func (n *Name) SetInlFormal(b bool)

func (*Name) SetInlLocal 

func (n *Name) SetInlLocal(b bool)

func (*Name) SetIsClosureVar 

func (n *Name) SetIsClosureVar(b bool)

func (*Name) SetIsOutputParamHeapAddr 

func (n *Name) SetIsOutputParamHeapAddr(b bool)

func (*Name) SetIsOutputParamInRegisters 

func (n *Name) SetIsOutputParamInRegisters(b bool)

func (*Name) SetLibfuzzer8BitCounter 

func (n *Name) SetLibfuzzer8BitCounter(b bool)

func (*Name) SetNeedzero 

func (n *Name) SetNeedzero(b bool)

func (*Name) SetNonMergeable added in v1.23.0 

func (n *Name) SetNonMergeable(b bool)

func (*Name) SetOpenDeferSlot 

func (n *Name) SetOpenDeferSlot(b bool)

func (*Name) SetPragma 

func (n *Name) SetPragma(flag PragmaFlag)

SetPragma sets the PragmaFlag for p, which must be for an OTYPE.

func (*Name) SetSubOp 

func (n *Name) SetSubOp(x Op)

func (*Name) SetSym 

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

func (*Name) SetUsed 

func (n *Name) SetUsed(b bool)

func (*Name) SetVal 

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

SetVal sets the constant.Value for the node.

func (*Name) SubOp 

func (n *Name) SubOp() Op

func (*Name) Sym 

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

func (*Name) Used 

func (n *Name) Used() bool

func (*Name) Val 

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

Val returns the constant.Value for the node.

type NameQueue 

type NameQueue struct {
	// contains filtered or unexported fields
}

NameQueue is a FIFO queue of *Name. The zero value of NameQueue is a ready-to-use empty queue.

func (*NameQueue) Empty 

func (q *NameQueue) Empty() bool

Empty reports whether q contains no Names.

func (*NameQueue) PopLeft 

func (q *NameQueue) PopLeft() *Name

PopLeft pops a Name from the left of the queue. It panics if q is empty.

func (*NameQueue) PushRight 

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

PushRight appends n to the right of the queue.

type NameSet 

type NameSet map[*Name]struct{}

NameSet is a set of Names.

func (*NameSet) Add 

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

Add adds n to s.

func (NameSet) Has 

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

Has reports whether s contains n.

func (NameSet) Sorted 

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

Sorted returns s sorted according to less.

type NilExpr 

type NilExpr struct {
	// contains filtered or unexported fields
}

A NilExpr represents the predefined untyped constant nil.

func NewNilExpr 

func NewNilExpr(pos src.XPos, typ *types.Type) *NilExpr

func (*NilExpr) Format 

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

type Node 

type Node interface {
	Format(s fmt.State, verb rune)

	Pos() src.XPos
	SetPos(x src.XPos)

	Op() Op
	Init() Nodes

	Type() *types.Type
	SetType(t *types.Type)
	Name() *Name
	Sym() *types.Sym
	Val() constant.Value
	SetVal(v constant.Value)

	Esc() uint16
	SetEsc(x uint16)

	Typecheck() uint8
	SetTypecheck(x uint8)
	NonNil() bool
	MarkNonNil()
	// contains filtered or unexported methods
}

A Node is the abstract interface to an IR node.

func Copy 

func Copy(n Node) Node

Copy returns a shallow copy of n.

func DeepCopy 

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

DeepCopy returns a “deep” copy of n, with its entire structure copied (except for shared nodes like ONAME, ONONAME, OLITERAL, and OTYPE). If pos.IsKnown(), it sets the source position of newly allocated Nodes to pos.

func DeepCopyList 

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

DeepCopyList returns a list of deep copies (using DeepCopy) of the nodes in list.

func FuncPC added in v1.22.0 

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

FuncPC returns a uintptr-typed expression that evaluates to the PC of a function as uintptr, as returned by internal/abi.FuncPC{ABI0,ABIInternal}.

n should be a Node of an interface type, as is passed to internal/abi.FuncPC{ABI0,ABIInternal}.

TODO(prattmic): Since n is simply an interface{} there is no assertion that it is actually a function at all. Perhaps we should emit a runtime type assertion?

func InitExpr 

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

The result of InitExpr MUST be assigned back to n, e.g. 

n.X = InitExpr(init, n.X)

func NewBasicLit 

func NewBasicLit(pos src.XPos, typ *types.Type, val constant.Value) Node

NewBasicLit returns an OLITERAL representing val with the given type.

func NewBool 

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

NewBool returns an OLITERAL representing b as an untyped boolean.

func NewConstExpr 

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

NewConstExpr returns an OLITERAL representing val, copying the position and type from orig.

func NewInt 

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

NewInt returns an OLITERAL representing v as an untyped integer.

func NewOne added in v1.22.0 

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

NewOne returns an OLITERAL representing 1 with the given type.

func NewString 

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

NewString returns an OLITERAL representing s as an untyped string.

func NewUintptr added in v1.22.0 

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

NewUintptr returns an OLITERAL representing v as a uintptr.

func NewZero added in v1.22.0 

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

NewZero returns a zero value of the given type.

func OuterValue 

func OuterValue(n Node) Node

what's the outer value that a write to n affects? outer value means containing struct or array.

func ParamNames 

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

func StaticValue 

func StaticValue(n Node) Node

StaticValue analyzes n to find the earliest expression that always evaluates to the same value as n, which might be from an enclosing function.

For example, given: 

var x int = g()
func() {
	y := x
	*p = int(y)
}

calling StaticValue on the "int(y)" expression returns the outer "g()" expression.

func TypeNode 

func TypeNode(t *types.Type) Node

TypeNode returns the Node representing the type t.

type Nodes 

type Nodes []Node

Nodes is a slice of Node.

func TakeInit 

func TakeInit(n Node) Nodes

func ToNodes added in v1.22.0 

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

ToNodes returns s as a slice of Nodes.

func (*Nodes) Append 

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

Append appends entries to Nodes.

func (Nodes) Copy 

func (n Nodes) Copy() Nodes

Copy returns a copy of the content of the slice.

func (Nodes) Format 

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

Format implements formatting for a Nodes. The valid formats are: 

%v	Go syntax, semicolon-separated
%.v	Go syntax, comma-separated
%+v	Debug syntax, as in DumpList.

func (*Nodes) Prepend 

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

Prepend prepends entries to Nodes. If a slice is passed in, this will take ownership of it.

func (*Nodes) Take 

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

Take clears n, returning its former contents.

type Op 

type Op uint8
const (
	OXXX Op = iota

	// names
	ONAME
	// Unnamed arg or return value: f(int, string) (int, error) { etc }
	// Also used for a qualified package identifier that hasn't been resolved yet.
	ONONAME
	OTYPE
	OLITERAL
	ONIL

	// expressions
	OADD
	OSUB
	OOR
	OXOR
	OADDSTR
	OADDR
	OANDAND
	OAPPEND
	OBYTES2STR
	OBYTES2STRTMP
	ORUNES2STR
	OSTR2BYTES
	OSTR2BYTESTMP
	OSTR2RUNES
	OSLICE2ARR
	OSLICE2ARRPTR
	// X = Y or (if Def=true) X := Y
	// If Def, then Init includes a DCL node for X.
	OAS
	// Lhs = Rhs (x, y, z = a, b, c) or (if Def=true) Lhs := Rhs
	// If Def, then Init includes DCL nodes for Lhs
	OAS2
	OAS2DOTTYPE
	OAS2FUNC
	OAS2MAPR
	OAS2RECV
	OASOP
	OCALL

	// OCALLFUNC, OCALLMETH, and OCALLINTER have the same structure.
	// Prior to walk, they are: X(Args), where Args is all regular arguments.
	// After walk, if any argument whose evaluation might requires temporary variable,
	// that temporary variable will be pushed to Init, Args will contain an updated
	// set of arguments.
	OCALLFUNC
	OCALLMETH
	OCALLINTER
	OCAP
	OCLEAR
	OCLOSE
	OCLOSURE
	OCOMPLIT
	OMAPLIT
	OSTRUCTLIT
	OARRAYLIT
	OSLICELIT
	OPTRLIT
	OCONV
	OCONVIFACE
	OCONVNOP
	OCOPY
	ODCL

	// Used during parsing but don't last.
	ODCLFUNC

	ODELETE
	ODOT
	ODOTPTR
	ODOTMETH
	ODOTINTER
	OXDOT
	ODOTTYPE
	ODOTTYPE2
	OEQ
	ONE
	OLT
	OLE
	OGE
	OGT
	ODEREF
	OINDEX
	OINDEXMAP
	OKEY
	OSTRUCTKEY
	OLEN
	OMAKE
	OMAKECHAN
	OMAKEMAP
	OMAKESLICE
	OMAKESLICECOPY
	// OMAKESLICECOPY is created by the order pass and corresponds to:
	//  s = make(Type, Len); copy(s, Cap)
	//
	// Bounded can be set on the node when Len == len(Cap) is known at compile time.
	//
	// This node is created so the walk pass can optimize this pattern which would
	// otherwise be hard to detect after the order pass.
	OMUL
	ODIV
	OMOD
	OLSH
	ORSH
	OAND
	OANDNOT
	ONEW
	ONOT
	OBITNOT
	OPLUS
	ONEG
	OOROR
	OPANIC
	OPRINT
	OPRINTLN
	OPAREN
	OSEND
	OSLICE
	OSLICEARR
	OSLICESTR
	OSLICE3
	OSLICE3ARR
	OSLICEHEADER
	OSTRINGHEADER
	ORECOVER
	ORECOVERFP
	ORECV
	ORUNESTR
	OSELRECV2
	OMIN
	OMAX
	OREAL
	OIMAG
	OCOMPLEX
	OUNSAFEADD
	OUNSAFESLICE
	OUNSAFESLICEDATA
	OUNSAFESTRING
	OUNSAFESTRINGDATA
	OMETHEXPR
	OMETHVALUE

	// statements
	OBLOCK
	OBREAK
	// OCASE:  case List: Body (List==nil means default)
	//   For OTYPESW, List is a OTYPE node for the specified type (or OLITERAL
	//   for nil) or an ODYNAMICTYPE indicating a runtime type for generics.
	//   If a type-switch variable is specified, Var is an
	//   ONAME for the version of the type-switch variable with the specified
	//   type.
	OCASE
	OCONTINUE
	ODEFER
	OFALL
	OFOR
	OGOTO
	OIF
	OLABEL
	OGO
	ORANGE
	ORETURN
	OSELECT
	OSWITCH
	// OTYPESW:  X := Y.(type) (appears as .Tag of OSWITCH)
	//   X is nil if there is no type-switch variable
	OTYPESW

	// misc
	// intermediate representation of an inlined call.  Uses Init (assignments
	// for the captured variables, parameters, retvars, & INLMARK op),
	// Body (body of the inlined function), and ReturnVars (list of
	// return values)
	OINLCALL
	OMAKEFACE
	OITAB
	OIDATA
	OSPTR
	OCFUNC
	OCHECKNIL
	ORESULT
	OINLMARK
	OLINKSYMOFFSET
	OJUMPTABLE
	OINTERFACESWITCH

	// opcodes for generics
	ODYNAMICDOTTYPE
	ODYNAMICDOTTYPE2
	ODYNAMICTYPE

	// arch-specific opcodes
	OTAILCALL
	OGETG
	OGETCALLERPC
	OGETCALLERSP

	OEND
)

Node ops.

func (Op) Format 

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

Format implements formatting for an Op. The valid formats are: 

%v	Go syntax ("+", "<-", "print")
%+v	Debug syntax ("ADD", "RECV", "PRINT")

func (Op) GoString 

func (o Op) GoString() string

GoString returns the Go syntax for the Op, or else its name.

func (Op) IsCmp 

func (op Op) IsCmp() bool

IsCmp reports whether op is a comparison operation (==, !=, <, <=, >, or >=).

func (Op) IsSlice3 

func (o Op) IsSlice3() bool

IsSlice3 reports whether o is a slice3 op (OSLICE3, OSLICE3ARR). o must be a slicing op.

func (Op) String 

func (i Op) String() string

type Package 

type Package struct {
	// Imports, listed in source order.
	// See golang.org/issue/31636.
	Imports []*types.Pkg

	// Init functions, listed in source order.
	Inits []*Func

	// Funcs contains all (instantiated) functions, methods, and
	// function literals to be compiled.
	Funcs []*Func

	// Externs holds constants, (non-generic) types, and variables
	// declared at package scope.
	Externs []*Name

	// AsmHdrDecls holds declared constants and struct types that should
	// be included in -asmhdr output. It's only populated when -asmhdr
	// is set.
	AsmHdrDecls []*Name

	// Cgo directives.
	CgoPragmas [][]string

	// Variables with //go:embed lines.
	Embeds []*Name

	// PluginExports holds exported functions and variables that are
	// accessible through the package plugin API. It's only populated
	// for -buildmode=plugin (i.e., compiling package main and -dynlink
	// is set).
	PluginExports []*Name
}

A Package holds information about the package being compiled.

type ParenExpr 

type ParenExpr struct {
	X Node
	// contains filtered or unexported fields
}

A ParenExpr is a parenthesized expression (X). It may end up being a value or a type.

func NewParenExpr 

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

func (*ParenExpr) Format 

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

func (*ParenExpr) Implicit 

func (n *ParenExpr) Implicit() bool

func (*ParenExpr) SetImplicit 

func (n *ParenExpr) SetImplicit(b bool)

type PragmaFlag 

type PragmaFlag uint16
const (
	// Func pragmas.
	Nointerface PragmaFlag = 1 << iota
	Noescape
	Norace
	Nosplit
	Noinline
	NoCheckPtr
	CgoUnsafeArgs
	UintptrKeepAlive
	UintptrEscapes

	// Runtime-only func pragmas.
	// See ../../../../runtime/HACKING.md for detailed descriptions.
	Systemstack
	Nowritebarrier
	Nowritebarrierrec
	Yeswritebarrierrec

	// Go command pragmas
	GoBuildPragma

	RegisterParams
)

type RangeStmt 

type RangeStmt struct {
	Label        *types.Sym
	Def          bool
	X            Node
	RType        Node `mknode:"-"`
	Key          Node
	Value        Node
	Body         Nodes
	DistinctVars bool
	Prealloc     *Name

	// When desugaring the RangeStmt during walk, the assignments to Key
	// and Value may require OCONVIFACE operations. If so, these fields
	// will be copied to their respective ConvExpr fields.
	KeyTypeWord   Node `mknode:"-"`
	KeySrcRType   Node `mknode:"-"`
	ValueTypeWord Node `mknode:"-"`
	ValueSrcRType Node `mknode:"-"`
	// contains filtered or unexported fields
}

A RangeStmt is a range loop: for Key, Value = range X { Body }

func NewRangeStmt 

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

func (*RangeStmt) Format 

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

type ReassignOracle added in v1.22.0 

type ReassignOracle struct {
	// contains filtered or unexported fields
}

A ReassignOracle efficiently answers queries about whether local variables are reassigned. This helper works by looking for function params and short variable declarations (e.g. https://go.dev/ref/spec#Short_variable_declarations) that are neither address taken nor subsequently re-assigned. It is intended to operate much like "ir.StaticValue" and "ir.Reassigned", but in a way that does just a single walk of the containing function (as opposed to a new walk on every call).

func (*ReassignOracle) Init added in v1.22.0 

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

Init initializes the oracle based on the IR in function fn, laying the groundwork for future calls to the StaticValue and Reassigned methods. If the fn's IR is subsequently modified, Init must be called again.

func (*ReassignOracle) Reassigned added in v1.22.0 

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

Reassigned method has the same semantics as the ir package function of the same name; see comments on Reassigned for more info.

func (*ReassignOracle) StaticValue added in v1.22.0 

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

StaticValue method has the same semantics as the ir package function of the same name; see comments on StaticValue.

type ResultExpr 

type ResultExpr struct {
	Index int64
	// contains filtered or unexported fields
}

A ResultExpr represents a direct access to a result.

func NewResultExpr 

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

func (*ResultExpr) Format 

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

type ReturnStmt 

type ReturnStmt struct {
	Results Nodes
	// contains filtered or unexported fields
}

A ReturnStmt is a return statement.

func NewReturnStmt 

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

func (*ReturnStmt) Format 

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

type ScopeID 

type ScopeID int32

A ScopeID represents a lexical scope within a function.

type SelectStmt 

type SelectStmt struct {
	Label *types.Sym
	Cases []*CommClause

	// TODO(rsc): Instead of recording here, replace with a block?
	Compiled Nodes
	// contains filtered or unexported fields
}

A SelectStmt is a block: { Cases }.

func NewSelectStmt 

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

func (*SelectStmt) Format 

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

type SelectorExpr 

type SelectorExpr struct {
	X Node
	// Sel is the name of the field or method being selected, without (in the
	// case of methods) any preceding type specifier. If the field/method is
	// exported, than the Sym uses the local package regardless of the package
	// of the containing type.
	Sel *types.Sym
	// The actual selected field - may not be filled in until typechecking.
	Selection *types.Field
	Prealloc  *Name
	// contains filtered or unexported fields
}

A SelectorExpr is a selector expression X.Sel.

func NewSelectorExpr 

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

func (*SelectorExpr) Format 

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

func (*SelectorExpr) FuncName 

func (n *SelectorExpr) FuncName() *Name

func (*SelectorExpr) Implicit 

func (n *SelectorExpr) Implicit() bool

func (*SelectorExpr) Offset 

func (n *SelectorExpr) Offset() int64

func (*SelectorExpr) SetImplicit 

func (n *SelectorExpr) SetImplicit(b bool)

func (*SelectorExpr) SetOp 

func (n *SelectorExpr) SetOp(op Op)

func (*SelectorExpr) Sym 

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

type SendStmt 

type SendStmt struct {
	Chan  Node
	Value Node
	// contains filtered or unexported fields
}

A SendStmt is a send statement: X <- Y.

func NewSendStmt 

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

func (*SendStmt) Format 

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

type SliceExpr 

type SliceExpr struct {
	X    Node
	Low  Node
	High Node
	Max  Node
	// contains filtered or unexported fields
}

A SliceExpr is a slice expression X[Low:High] or X[Low:High:Max].

func NewSliceExpr 

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

func (*SliceExpr) Format 

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

func (*SliceExpr) SetOp 

func (n *SliceExpr) SetOp(op Op)

type SliceHeaderExpr 

type SliceHeaderExpr struct {
	Ptr Node
	Len Node
	Cap Node
	// contains filtered or unexported fields
}

A SliceHeader expression constructs a slice header from its parts.

func NewSliceHeaderExpr 

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

func (*SliceHeaderExpr) Format 

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

type StarExpr 

type StarExpr struct {
	X Node
	// contains filtered or unexported fields
}

A StarExpr is a dereference expression *X. It may end up being a value or a type.

func NewStarExpr 

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

func (*StarExpr) Format 

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

func (*StarExpr) Implicit 

func (n *StarExpr) Implicit() bool

func (*StarExpr) SetImplicit 

func (n *StarExpr) SetImplicit(b bool)

type Stmt 

type Stmt interface {
	Node
	// contains filtered or unexported methods
}

A Stmt is a Node that can appear as a statement. This includes statement-like expressions such as f().

(It's possible it should include <-c, but that would require splitting ORECV out of UnaryExpr, which hasn't yet been necessary. Maybe instead we will introduce ExprStmt at some point.)

type StringHeaderExpr 

type StringHeaderExpr struct {
	Ptr Node
	Len Node
	// contains filtered or unexported fields
}

A StringHeaderExpr expression constructs a string header from its parts.

func NewStringHeaderExpr 

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

func (*StringHeaderExpr) Format 

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

type StructKeyExpr 

type StructKeyExpr struct {
	Field *types.Field
	Value Node
	// contains filtered or unexported fields
}

A StructKeyExpr is a Field: Value composite literal key.

func NewStructKeyExpr 

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

func (*StructKeyExpr) Format 

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

func (*StructKeyExpr) Sym 

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

type SwitchStmt 

type SwitchStmt struct {
	Tag   Node
	Cases []*CaseClause
	Label *types.Sym

	// TODO(rsc): Instead of recording here, replace with a block?
	Compiled Nodes
	// contains filtered or unexported fields
}

A SwitchStmt is a switch statement: switch Init; Tag { Cases }.

func NewSwitchStmt 

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

func (*SwitchStmt) Format 

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

type SymAndPos 

type SymAndPos struct {
	Sym *obj.LSym
	Pos src.XPos
}

type TailCallStmt 

type TailCallStmt struct {
	Call *CallExpr
	// contains filtered or unexported fields
}

A TailCallStmt is a tail call statement, which is used for back-end code generation to jump directly to another function entirely.

func NewTailCallStmt 

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

func (*TailCallStmt) Format 

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

type TypeAssertExpr 

type TypeAssertExpr struct {
	X Node

	// Runtime type information provided by walkDotType for
	// assertions from non-empty interface to concrete type.
	ITab Node `mknode:"-"`

	// An internal/abi.TypeAssert descriptor to pass to the runtime.
	Descriptor *obj.LSym
	// contains filtered or unexported fields
}

A TypeAssertionExpr is a selector expression X.(Type). Before type-checking, the type is Ntype.

func NewTypeAssertExpr 

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

func (*TypeAssertExpr) Format 

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

func (*TypeAssertExpr) SetOp 

func (n *TypeAssertExpr) SetOp(op Op)

type TypeSwitchGuard 

type TypeSwitchGuard struct {
	Tag  *Ident
	X    Node
	Used bool
	// contains filtered or unexported fields
}

A TypeSwitchGuard is the [Name :=] X.(type) in a type switch.

func NewTypeSwitchGuard 

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

func (*TypeSwitchGuard) Format 

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

type UnaryExpr 

type UnaryExpr struct {
	X Node
	// contains filtered or unexported fields
}

A UnaryExpr is a unary expression Op X, or Op(X) for a builtin function that does not end up being a call.

func NewUnaryExpr 

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

func (*UnaryExpr) Format 

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

func (*UnaryExpr) SetOp 

func (n *UnaryExpr) SetOp(op Op)

type WasmExport added in v1.23.0 

type WasmExport struct {
	Name string
}

WasmExport stores metadata associated with the //go:wasmexport pragma.

type WasmImport 

type WasmImport struct {
	Module string
	Name   string
}

WasmImport stores metadata associated with the //go:wasmimport pragma.

Notes

Bugs

  • If ITab is non-nil, RType may be nil.

  • If ITab is non-nil, RType may be nil.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.