AddAux adds the offset in the aux fields (AuxInt and Aux) of v to a.

AutoVar returns a *Node and int64 representing the auto variable and offset within it where v should be spilled.

CheckLoweredGetClosurePtr checks that v is the first instruction in the function's entry block.

CheckLoweredPhi checks that regalloc and stackalloc correctly handled phi values.

IncomparableField returns an incomparable Field of struct Type t, if any.

IsComparable reports whether t is a comparable type.

IsRegularMemory reports whether t can be compared/hashed as regular memory.

Main parses flags and Go source files specified in the command-line arguments, type-checks the parsed Go package, compiles functions to machine code, and finally writes the compiled package definition to disk.

ParseLeaks parses a binary string representing an EscLeaks.

Type can be compared/hashed as regular memory.

These values are known by runtime.

architecture-independent object file output.

Type needs special comparison/hashing functions.

Builds a type representing a Bucket structure for the given map type.

treat a pointer to one arg as a pointer to them all.

Reachable from the heap.

By construction will not escape.

Does not escape to heap, result, or parameters.

*types.Sym, *types.Type, and *Node types use the flags below to set the format mode.

*types.Sym, *types.Type, and *Node types use the flags below to set the format mode.

'0' (historic: hh flag).

'.' (== hasPrec) (historic: , flag).

'-'.

verb == 'L' (historic: l flag).

'#'.

verb == 'S' (historic: h flag).

'+'.

internal use only (historic: u flag).

*types.Sym, *types.Type, and *Node types use the flags below to set the format mode.

same as FTypeId, but use package name instead of prefix.

FNV-1 hash function constants.

FNV-1 hash function constants.

Static initialization phase.

Static initialization phase.

Static initialization phase.

Builds a type representing a Bucket structure for the given map type.

Builds a type representing a Bucket structure for the given map type.

Turn on for constant arithmetic debugging output.

Maximum size in bits for Mpints before signalling overflow and also mantissa precision for Mpflts.

func should not be instrumented by checkptr.

func parameters don't escape.

func should not be inlined.

Func pragmas.

func must not have race detector annotations.

func should not execute on separate stack.

values of this type must not be heap allocated.

emit compiler error instead of write barrier.

error on write barrier in this or recursive callees.

convenience constants.

Left + Right.

&Left.

+{List} (string addition, list elements are strings).

unsafe.Alignof(Left).

Left & Right.

Left && Right.

Left &^ Right.

append(List); after walk, Left may contain elem type descriptor.

Type{List} (composite literal, Type is array).

Left = Right or (if Colas=true) Left := Right.

List = Rlist (x, y, z = a, b, c).

List = Right (x, ok = I.(int)).

List = Right (x, y = f()).

List = Right (x, ok = m["foo"]).

List = Right (x, ok = <-c).

Left Etype= Right (x += y).

^Left.

{ List } (block of code).

break [Sym].

Type(Left) (Type is string, Left is a []byte).

Type(Left) (Type is string, Left is a []byte, ephemeral).

Left(List) (function call, method call or type conversion).

Left(List/Rlist) (function call f(args)).

Left(List/Rlist) (interface method call x.Method(args)).

Left(List/Rlist) (direct method call x.Method(args)).

Left.Right (method expression x.Method, not called).

cap(Left).

case List: Nbody (List==nil means default).

reference to c function pointer (not go func value).

emit code to ensure pointer/interface not nil.

close(Left).

func Type { Body } (func literal).

variable reference at beginning of closure function.

complex(Left, Right) or complex(List[0]) where List[0] is a 2-result function call.

Right{List} (composite literal, not yet lowered to specific form).

continue [Sym].

Type(Left) (type conversion).

Type(Left) (type conversion, to interface).

Type(Left) (type conversion, no effect).

copy(Left, Right).

var Left (declares Left of type Left.Type).

const pi = 3.14.

struct field, interface field, or func/method argument/return value.

func f() or func (r) f().

type Int int or type Int = int.

func f(args ...int) or f(l...) or var a = [...]int{0, 1, 2}.

func f(args ...int), introduced by escape analysis.

defer Left (Left must be call).

delete(Left, Right).

*Left.

Left / Right.

Left.Sym (Left is of struct type).

Left.Sym (Left is interface, Right is method name).

Left.Sym (Left is non-interface, Right is method name).

Left.Sym (Left is of pointer to struct type).

Left.Right or Left.Type (.Right during parsing, .Type once resolved); after walk, .Right contains address of interface type descriptor and .Right.Right contains address of concrete type descriptor.

Left.Right or Left.Type (.Right during parsing, .Type once resolved; on rhs of OAS2DOTTYPE); after walk, .Right contains address of interface type descriptor.

itable and data words of an empty-interface value.

no-op (empty statement).

Node ops.

Left == Right.

fallthrough.

for Ninit; Left; Right { Nbody }.

OFORUNTIL is like OFOR, but the test (Left) is applied after the body: Ninit top: { Nbody } // Execute the body at least once cont: Right if Left { // And then test the loop condition List // Before looping to top, execute List goto top } OFORUNTIL is created by walk.

Left >= Right.

runtime.getg() (read g pointer).

go Left (Left must be call).

goto Sym.

Left > Right.

data word of an interface value in Left.

if Ninit; Left { Nbody } else { Rlist }.

imag(Left).

Left[Right] (index of array or slice).

Left[Right] (index of map).

intermediary representation of an inlined call.

start of an inlined body, with file/line of caller.

iota.

itable word of an interface value.

Left:Right (key:value in struct/array/map literal).

Sym:.

Left <= Right.

len(Left).

literal.

Left << Right.

Left < Right.

make(List) (before type checking converts to one of the following).

make(Type, Left) (type is chan).

make(Type, Left) (type is map).

make(Type, Left, Right) (type is slice).

Type{List} (composite literal, Type is map).

Left % Right.

Left * Right.

var or func name.

Left != Right.

-Left.

new(Left); corresponds to calls to new in source code.

runtime.newobject(n.Type); introduced by walk; Left is type descriptor.

unnamed arg or return value: f(int, string) (int, error) { etc }.

!Left.

unsafe.Offsetof(Left).

Left | Right.

Left || Right.

import.

panic(Left).

(Left).

+Left.

print(List).

println(List).

&Left (left is composite literal).

for List = range Right { Nbody }.

real(Left).

recover().

<-Left.

result of a function call; Xoffset is stack offset.

return to other function.

return List.

Left >> Right.

Type(Left) (Type is string, Left is a []rune).

Type(Left) (Type is string, Left is rune).

select { List } (List is list of OCASE).

Left = <-Right.Left: (appears as .Left of OCASE; Right.Op == ORECV).

List = <-Right.Left: (appears as .Left of OCASE; count(List) == 2, Right.Op == ORECV).

Left <- Right.

unsafe.Sizeof(Left).

Left[List[0] : List[1]] (Left is untypechecked or slice).

Left[List[0] : List[1] : List[2]] (Left is untypedchecked or slice).

Left[List[0] : List[1] : List[2]] (Left is array).

Left[List[0] : List[1]] (Left is array).

sliceheader{Left, List[0], List[1]} (Left is unsafe.Pointer, List[0] is length, List[1] is capacity).

Type{List} (composite literal, Type is slice) Right.Int64() = slice length.

Left[List[0] : List[1]] (Left is string).

base pointer of a slice or string.

Type(Left) (Type is []byte, Left is a string).

Type(Left) (Type is []byte, Left is a string, ephemeral).

Type(Left) (Type is []rune, Left is a string).

Sym:Left (key:value in struct literal, after type checking).

Type{List} (composite literal, Type is struct).

Left - Right.

switch Ninit; Left { List } (List is a list of OCASE).

[]int, [8]int, [N]int or [...]int.

chan int.

func().

interface{}.

map[string]int.

struct{}.

type name.

Left = Right.(type) (appears as .Left of OSWITCH).

variable is about to be fully initialized.

variable is dead.

variable is alive.

Left.Sym (before rewrite to one of the preceding).

Left ^ Right.

Node ops.

local variables.

local variable or parameter moved to heap.

global variable.

global function.

input arguments.

output results.

no class; used during ssa conversion to indicate pseudo-variables.

func must run on system stack.

convenience constants.

convenience constants.

convenience constants.

convenience constants.

convenience constants.

convenience constants.

convenience constants.

convenience constants.

convenience constants.

convenience constants.

convenience constants.

convenience constants.

pseudo-types for frame layout.

pseudo-types for literals.

convenience constants.

convenience constants.

convenience constants.

convenience constants.

convenience constants.

convenience constants.

convenience constants.

convenience constants.

convenience constants.

convenience constants.

convenience constants.

convenience constants.

convenience constants.

convenience constants.

convenience constants.

convenience constants.

convenience constants.

convenience constants.

convenience constants.

convenience constants.

pointers converted to uintptr escape.

cancels Nowritebarrierrec in this function and callees.

GO386=387.

GO386=387.

if set, print debugging information about export data.

set by -d gcprog.

LivenessInvalid indicates an unsafe point.

fake package runtime.

Wasm.

Wasm.

Wasm.

Wasm.

Wasm.

Wasm.

BlockEffects summarizes the liveness effects on an SSA block.

Branch is an unresolved branch.

A Dlist stores a pointer to a TFIELD Type embedded within a TSTRUCT or TINTER Type.

An EscEdge represents an assignment edge between two Go variables.

An EscHole represents a context for evaluation a Go expression.

An EscLocation represents an abstract location that stores a Go variable.

Func holds Node fields used only with function-like nodes.

An InitSchedule is used to decompose assignment statements into static and dynamic initialization parts.

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

A collection of global state used by liveness analysis.

LivenessIndex stores the liveness map index for a safe-point.

LivenessMap maps from *ssa.Value to LivenessIndex.

A Mark represents a scope boundary.

Mpcplx represents a complex constant.

Mpflt represents a floating-point constant.

Mpint represents an integer constant.

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

A Node is a single node in the syntax tree.

Nodes is a pointer to a slice of *Node.

Order holds state during the ordering process.

Progs accumulates Progs for a function and converts them into machine code.

SSAGenState contains state needed during Prog generation.

Timings collects the execution times of labeled phases which are added trough a sequence of Start/Stop calls.

AlgKind describes the kind of algorithms used for comparing and hashing a Type.

The Class of a variable/function describes the "storage class" of a variable or function.

Ctype describes the constant kind of an "ideal" (untyped) constant.

An EscLeaks represents a set of assignment flows from a parameter to the heap or to any of its function's (first numEscResults) result parameters.

A FmtFlag value is a set of flags (or 0).

NodeSet is a set of Nodes.

A ScopeID represents a lexical scope within a function.