gc

package standard library
go1.10.5 Latest Latest
Warning

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

 Go to latest Published: Nov 2, 2018 License: BSD-3-Clause Imports: 41 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	EscFuncUnknown = 0 + iota
	EscFuncPlanned
	EscFuncStarted
	EscFuncTagged
)
View Source 
const (
	EscUnknown        = iota
	EscNone           // Does not escape to heap, result, or parameters.
	EscReturn         // Is returned or reachable from returned.
	EscHeap           // Reachable from the heap
	EscNever          // By construction will not escape.
	EscBits           = 3
	EscMask           = (1 << EscBits) - 1
	EscContentEscapes = 1 << EscBits // value obtained by indirect of parameter escapes to heap
	EscReturnBits     = EscBits + 1
)

Escape constants are numbered in order of increasing "escapiness" to help make inferences be monotonic. With the exception of EscNever which is sticky, eX < eY means that eY is more exposed than eX, and hence replaces it in a conservative analysis.

View Source 
const (
	FErr = iota
	FDbg
	FTypeId
	FTypeIdName // same as FTypeId, but use package name instead of prefix
)

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

View Source 
const (
	// Func pragmas.
	Nointerface    syntax.Pragma = 1 << iota
	Noescape                     // func parameters don't escape
	Norace                       // func must not have race detector annotations
	Nosplit                      // func should not execute on separate stack
	Noinline                     // func should not be inlined
	CgoUnsafeArgs                // treat a pointer to one arg as a pointer to them all
	UintptrEscapes               // pointers converted to uintptr escape

	// Runtime-only func pragmas.
	// See ../../../../runtime/README.md for detailed descriptions.
	Systemstack        // func must run on system stack
	Nowritebarrier     // emit compiler error instead of write barrier
	Nowritebarrierrec  // error on write barrier in this or recursive callees
	Yeswritebarrierrec // cancels Nowritebarrierrec in this function and callees

	// Runtime-only type pragmas
	NotInHeap // values of this type must not be heap allocated
)
View Source 
const (
	// Maximum size in bits for Mpints before signalling
	// overflow and also mantissa precision for Mpflts.
	Mpprec = 512
	// Turn on for constant arithmetic debugging output.
	Mpdebug = false
)
View Source 
const (
	H0 = 2166136261
	Hp = 16777619
)

FNV-1 hash function constants.

View Source 
const (
	BUCKETSIZE = 8
	MAXKEYSIZE = 128
	MAXVALSIZE = 128
)

Builds a type representing a Bucket structure for the given map type. This type is not visible to users - we include only enough information to generate a correct GC program for it. Make sure this stays in sync with ../../../../runtime/hashmap.go!

View Source 
const (
	InitNotStarted = iota
	InitDone
	InitPending
)

Static initialization ordering state. These values are stored in two bits in Node.flags.

View Source 
const (
	Etop      = 1 << iota // evaluated at statement level
	Erv                   // evaluated in value context
	Etype                 // evaluated in type context
	Ecall                 // call-only expressions are ok
	Efnstruct             // multivalue function returns are ok
	Easgn                 // assigning to expression
	Ecomplit              // type in composite literal
)
View Source 
const (
	Txxx = types.Txxx

	TINT8    = types.TINT8
	TUINT8   = types.TUINT8
	TINT16   = types.TINT16
	TUINT16  = types.TUINT16
	TINT32   = types.TINT32
	TUINT32  = types.TUINT32
	TINT64   = types.TINT64
	TUINT64  = types.TUINT64
	TINT     = types.TINT
	TUINT    = types.TUINT
	TUINTPTR = types.TUINTPTR

	TCOMPLEX64  = types.TCOMPLEX64
	TCOMPLEX128 = types.TCOMPLEX128

	TFLOAT32 = types.TFLOAT32
	TFLOAT64 = types.TFLOAT64

	TBOOL = types.TBOOL

	TPTR32 = types.TPTR32
	TPTR64 = types.TPTR64

	TFUNC      = types.TFUNC
	TSLICE     = types.TSLICE
	TARRAY     = types.TARRAY
	TSTRUCT    = types.TSTRUCT
	TCHAN      = types.TCHAN
	TMAP       = types.TMAP
	TINTER     = types.TINTER
	TFORW      = types.TFORW
	TANY       = types.TANY
	TSTRING    = types.TSTRING
	TUNSAFEPTR = types.TUNSAFEPTR

	// pseudo-types for literals
	TIDEAL = types.TIDEAL
	TNIL   = types.TNIL
	TBLANK = types.TBLANK

	// pseudo-types for frame layout
	TFUNCARGS = types.TFUNCARGS
	TCHANARGS = types.TCHANARGS

	// pseudo-types for import/export
	TDDDFIELD = types.TDDDFIELD // wrapper: contained type is a ... field

	NTYPE = types.NTYPE
)

convenience constants

View Source 
const ArhdrSize = 60

architecture-independent object file output

View Source 
const (
	BADWIDTH = types.BADWIDTH
)
View Source 
const MinLevel = -2

There appear to be some loops in the escape graph, causing arbitrary recursion into deeper and deeper levels. Cut this off safely by making minLevel sticky: once you get that deep, you cannot go down any further but you also cannot go up any further. This is a conservative fix. Making minLevel smaller (more negative) would handle more complex chains of indirections followed by address-of operations, at the cost of repeating the traversal once for each additional allowed level when a loop is encountered. Using -2 suffices to pass all the tests we have written so far, which we assume matches the level of complexity we want the escape analysis code to handle.

View Source 
const NOTALOOPDEPTH = -1

Variables

View Source 
var (
	Newproc,
	Deferproc,
	Deferreturn,
	Duffcopy,
	Duffzero,

	Udiv *obj.LSym

	// GO386=387
	ControlWord64trunc,
	ControlWord32 *obj.LSym
)
View Source 
var (
	Debug_append       int
	Debug_asm          bool
	Debug_closure      int
	Debug_compilelater int

	Debug_panic        int
	Debug_slice        int
	Debug_vlog         bool
	Debug_wb           int
	Debug_eagerwb      int
	Debug_pctab        string
	Debug_locationlist int
	Debug_typecheckinl int
	Debug_gendwarfinl  int
	Debug_softfloat    int
)
View Source 
var Ctxt *obj.Link
View Source 
var Debug [256]int
View Source 
var Debug_checknil int
View Source 
var (
	Debug_export int // if set, print debugging information about export data
)
View Source 
var Debug_gcprog int // set by -d gcprog
View Source 
var Debug_typeassert int
View Source 
var Nacl bool
View Source 
var Runtimepkg *types.Pkg // fake package runtime
View Source 
var Widthptr int
View Source 
var Widthreg int

Functions

func AddAux added in go1.7 

func AddAux(a *obj.Addr, v *ssa.Value)

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

func AddAux2 added in go1.7 

func AddAux2(a *obj.Addr, v *ssa.Value, offset int64)

func AddrAuto added in go1.8 

func AddrAuto(a *obj.Addr, v *ssa.Value)

func Addrconst added in go1.8 

func Addrconst(a *obj.Addr, v int64)

func AuxOffset added in go1.8 

func AuxOffset(v *ssa.Value) (offset int64)

func CheckLoweredGetClosurePtr added in go1.8 

func CheckLoweredGetClosurePtr(v *ssa.Value)

CheckLoweredGetClosurePtr checks that v is the first instruction in the function's entry block. The output of LoweredGetClosurePtr is generally hardwired to the correct register. That register contains the closure pointer on closure entry.

func CheckLoweredPhi added in go1.8 

func CheckLoweredPhi(v *ssa.Value)

CheckLoweredPhi checks that regalloc and stackalloc correctly handled phi values. Called during ssaGenValue.

func Dump 

func Dump(s string, n *Node)

func Exit 

func Exit(code int)

func Fatalf added in go1.6 

func Fatalf(fmt_ string, args ...interface{})

func Import added in go1.6 

func Import(imp *types.Pkg, in *bufio.Reader)

Import populates imp from the serialized package data read from in.

func IncomparableField added in go1.9 

func IncomparableField(t *types.Type) *types.Field

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

func IsAlias added in go1.9 

func IsAlias(sym *types.Sym) bool

func IsComparable added in go1.9 

func IsComparable(t *types.Type) bool

IsComparable reports whether t is a comparable type.

func IsRegularMemory added in go1.9 

func IsRegularMemory(t *types.Type) bool

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

func Isconst 

func Isconst(n *Node, ct Ctype) bool

func Main 

func Main(archInit func(*Arch))

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.

func Patch 

func Patch(p *obj.Prog, to *obj.Prog)

func Rnd 

func Rnd(o int64, r int64) int64

func Warn 

func Warn(fmt_ string, args ...interface{})

func Warnl 

func Warnl(line src.XPos, fmt_ string, args ...interface{})

Types

type AlgKind added in go1.7 

type AlgKind int

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

const (
	// These values are known by runtime.
	ANOEQ AlgKind = iota
	AMEM0
	AMEM8
	AMEM16
	AMEM32
	AMEM64
	AMEM128
	ASTRING
	AINTER
	ANILINTER
	AFLOAT32
	AFLOAT64
	ACPLX64
	ACPLX128

	// Type can be compared/hashed as regular memory.
	AMEM AlgKind = 100

	// Type needs special comparison/hashing functions.
	ASPECIAL AlgKind = -1
)

type Arch 

type Arch struct {
	LinkArch *obj.LinkArch

	REGSP     int
	MAXWIDTH  int64
	Use387    bool // should 386 backend use 387 FP instructions instead of sse2.
	SoftFloat bool

	PadFrame  func(int64) int64
	ZeroRange func(*Progs, *obj.Prog, int64, int64, *uint32) *obj.Prog
	Ginsnop   func(*Progs)

	// SSAMarkMoves marks any MOVXconst ops that need to avoid clobbering flags.
	SSAMarkMoves func(*SSAGenState, *ssa.Block)

	// SSAGenValue emits Prog(s) for the Value.
	SSAGenValue func(*SSAGenState, *ssa.Value)

	// SSAGenBlock emits end-of-block Progs. SSAGenValue should be called
	// for all values in the block before SSAGenBlock.
	SSAGenBlock func(s *SSAGenState, b, next *ssa.Block)

	// ZeroAuto emits code to zero the given auto stack variable.
	// ZeroAuto must not use any non-temporary registers.
	// ZeroAuto will only be called for variables which contain a pointer.
	ZeroAuto func(*Progs, *Node)
}

type BlockEffects added in go1.9 

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

BlockEffects summarizes the liveness effects on an SSA block.

type Branch added in go1.7 

type Branch struct {
	P *obj.Prog  // branch instruction
	B *ssa.Block // target
}

Branch is an unresolved branch.

type Class added in go1.6 

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 // no class; used during ssa conversion to indicate pseudo-variables
	PEXTERN                // global variable
	PAUTO                  // local variables
	PAUTOHEAP              // local variable or parameter moved to heap
	PPARAM                 // input arguments
	PPARAMOUT              // output results
	PFUNC                  // global function

	PDISCARD // discard during parse of duplicate import

)

func (Class) String added in go1.9 

func (i Class) String() string

type Ctype added in go1.6 

type Ctype uint8

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

const (
	CTxxx Ctype = iota

	CTINT
	CTRUNE
	CTFLT
	CTCPLX
	CTSTR
	CTBOOL
	CTNIL
)

type Dlist 

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

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

type Error 

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

type EscState 

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

type EscStep added in go1.7 

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

An EscStep documents one step in the path from memory that is heap allocated to the (alleged) reason for the heap allocation.

type FloatingEQNEJump added in go1.7 

type FloatingEQNEJump struct {
	Jump  obj.As
	Index int
}

type FmtFlag added in go1.7 

type FmtFlag int

A FmtFlag value is a set of flags (or 0). They control how the Xconv functions format their values. See the respective function's documentation for details. 

const (
	FmtLeft     FmtFlag = 1 << iota // '-'
	FmtSharp                        // '#'
	FmtSign                         // '+'
	FmtUnsigned                     // internal use only (historic: u flag)
	FmtShort                        // verb == 'S'       (historic: h flag)
	FmtLong                         // verb == 'L'       (historic: l flag)
	FmtComma                        // '.' (== hasPrec)  (historic: , flag)
	FmtByte                         // '0'               (historic: hh flag)
)

type Func 

type Func struct {
	Shortname *types.Sym
	Enter     Nodes // for example, allocate and initialize memory for escaping parameters
	Exit      Nodes
	Cvars     Nodes   // closure params
	Dcl       []*Node // autodcl for this func/closure
	Inldcl    Nodes   // copy of dcl for use in inlining

	// 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

	Closgen    int
	Outerfunc  *Node // outer function (for closure)
	FieldTrack map[*types.Sym]struct{}
	DebugInfo  *ssa.FuncDebug
	Ntype      *Node // signature
	Top        int   // top context (Ecall, Eproc, etc)
	Closure    *Node // OCLOSURE <-> ODCLFUNC
	Nname      *Node

	Inl     Nodes // copy of the body for use in inlining
	InlCost int32
	Depth   int32

	Label int32 // largest auto-generated label in this function

	Endlineno src.XPos
	WBPos     src.XPos // position of first write barrier; see SetWBPos

	Pragma syntax.Pragma // go:xxx function annotations
	// contains filtered or unexported fields
}

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

func (*Func) Dupok 

func (f *Func) Dupok() bool

func (*Func) ExportInline added in go1.10 

func (f *Func) ExportInline() bool

func (*Func) HasDefer added in go1.9 

func (f *Func) HasDefer() bool

func (*Func) InlinabilityChecked added in go1.10 

func (f *Func) InlinabilityChecked() bool

func (*Func) IsHiddenClosure added in go1.8 

func (f *Func) IsHiddenClosure() bool

func (*Func) Needctxt 

func (f *Func) Needctxt() bool

func (*Func) NilCheckDisabled added in go1.9 

func (f *Func) NilCheckDisabled() bool

func (*Func) NoFramePointer added in go1.8 

func (f *Func) NoFramePointer() bool

func (*Func) ReflectMethod added in go1.7 

func (f *Func) ReflectMethod() bool

func (*Func) SetDupok added in go1.9 

func (f *Func) SetDupok(b bool)

func (*Func) SetExportInline added in go1.10 

func (f *Func) SetExportInline(b bool)

func (*Func) SetHasDefer added in go1.9 

func (f *Func) SetHasDefer(b bool)

func (*Func) SetInlinabilityChecked added in go1.10 

func (f *Func) SetInlinabilityChecked(b bool)

func (*Func) SetIsHiddenClosure added in go1.9 

func (f *Func) SetIsHiddenClosure(b bool)

func (*Func) SetNeedctxt added in go1.9 

func (f *Func) SetNeedctxt(b bool)

func (*Func) SetNilCheckDisabled added in go1.9 

func (f *Func) SetNilCheckDisabled(b bool)

func (*Func) SetNoFramePointer added in go1.9 

func (f *Func) SetNoFramePointer(b bool)

func (*Func) SetReflectMethod added in go1.9 

func (f *Func) SetReflectMethod(b bool)

func (*Func) SetWrapper added in go1.9 

func (f *Func) SetWrapper(b bool)

func (*Func) Wrapper 

func (f *Func) Wrapper() bool

type GCProg 

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

type InitEntry 

type InitEntry struct {
	Xoffset int64 // struct, array only
	Expr    *Node // bytes of run-time computed expressions
}

type InitPlan 

type InitPlan struct {
	E []InitEntry
}

type Level 

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

A Level encodes the reference state and context applied to (stack, heap) allocated memory.

value is the overall sum of *(1) and &(-1) operations encountered along a path from a destination (sink, return value) to a source (allocation, parameter).

suffixValue is the maximum-copy-started-suffix-level applied to a sink. For example: sink = x.left.left --> level=2, x is dereferenced twice and does not escape to sink. sink = &Node{x} --> level=-1, x is accessible from sink via one "address of" sink = &Node{&Node{x}} --> level=-2, x is accessible from sink via two "address of" sink = &Node{&Node{x.left}} --> level=-1, but x is NOT accessible from sink because it was indirected and then copied. (The copy operations are sometimes implicit in the source code; in this case, value of x.left was copied into a field of a newly allocated Node)

There's one of these for each Node, and the integer values rarely exceed even what can be stored in 4 bits, never mind 8.

type Liveness 

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

A collection of global state used by liveness analysis.

type Mark added in go1.9 

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 Mpcplx 

type Mpcplx struct {
	Real Mpflt
	Imag Mpflt
}

Mpcplx represents a complex constant.

type Mpflt 

type Mpflt struct {
	Val big.Float
}

Mpflt represents a floating-point constant.

func (*Mpflt) Add added in go1.7 

func (a *Mpflt) Add(b *Mpflt)

func (*Mpflt) AddFloat64 added in go1.7 

func (a *Mpflt) AddFloat64(c float64)

func (*Mpflt) Cmp added in go1.7 

func (a *Mpflt) Cmp(b *Mpflt) int

func (*Mpflt) CmpFloat64 added in go1.7 

func (a *Mpflt) CmpFloat64(c float64) int

func (*Mpflt) Float32 added in go1.7 

func (a *Mpflt) Float32() float64

func (*Mpflt) Float64 added in go1.7 

func (a *Mpflt) Float64() float64

func (*Mpflt) Mul added in go1.7 

func (a *Mpflt) Mul(b *Mpflt)

func (*Mpflt) MulFloat64 added in go1.7 

func (a *Mpflt) MulFloat64(c float64)

func (*Mpflt) Neg added in go1.7 

func (a *Mpflt) Neg()

func (*Mpflt) Quo added in go1.7 

func (a *Mpflt) Quo(b *Mpflt)

func (*Mpflt) Set added in go1.7 

func (a *Mpflt) Set(b *Mpflt)

func (*Mpflt) SetFloat64 added in go1.7 

func (a *Mpflt) SetFloat64(c float64)

func (*Mpflt) SetInt added in go1.7 

func (a *Mpflt) SetInt(b *Mpint)

func (*Mpflt) SetString added in go1.7 

func (a *Mpflt) SetString(as string)

func (*Mpflt) String 

func (f *Mpflt) String() string

func (*Mpflt) Sub added in go1.7 

func (a *Mpflt) Sub(b *Mpflt)

type Mpint 

type Mpint struct {
	Val  big.Int
	Ovf  bool // set if Val overflowed compiler limit (sticky)
	Rune bool // set if syntax indicates default type rune
}

Mpint represents an integer constant.

func (*Mpint) Add added in go1.7 

func (a *Mpint) Add(b *Mpint)

func (*Mpint) And added in go1.7 

func (a *Mpint) And(b *Mpint)

func (*Mpint) AndNot added in go1.7 

func (a *Mpint) AndNot(b *Mpint)

func (*Mpint) Cmp added in go1.7 

func (a *Mpint) Cmp(b *Mpint) int

func (*Mpint) CmpInt64 added in go1.7 

func (a *Mpint) CmpInt64(c int64) int

func (*Mpint) Int64 added in go1.7 

func (a *Mpint) Int64() int64

func (*Mpint) Lsh added in go1.7 

func (a *Mpint) Lsh(b *Mpint)

func (*Mpint) Mul added in go1.7 

func (a *Mpint) Mul(b *Mpint)

func (*Mpint) Neg added in go1.7 

func (a *Mpint) Neg()

func (*Mpint) Or added in go1.7 

func (a *Mpint) Or(b *Mpint)

func (*Mpint) Quo added in go1.7 

func (a *Mpint) Quo(b *Mpint)

func (*Mpint) Rem added in go1.7 

func (a *Mpint) Rem(b *Mpint)

func (*Mpint) Rsh added in go1.7 

func (a *Mpint) Rsh(b *Mpint)

func (*Mpint) Set added in go1.7 

func (a *Mpint) Set(b *Mpint)

func (*Mpint) SetFloat added in go1.7 

func (a *Mpint) SetFloat(b *Mpflt) bool

func (*Mpint) SetInt64 added in go1.7 

func (a *Mpint) SetInt64(c int64)

func (*Mpint) SetOverflow added in go1.7 

func (a *Mpint) SetOverflow()

func (*Mpint) SetString added in go1.7 

func (a *Mpint) SetString(as string)

func (*Mpint) String 

func (x *Mpint) String() string

func (*Mpint) Sub added in go1.7 

func (a *Mpint) Sub(b *Mpint)

func (*Mpint) Xor added in go1.7 

func (a *Mpint) Xor(b *Mpint)

type Name 

type Name struct {
	Pack      *Node      // real package for import . names
	Pkg       *types.Pkg // pkg for OPACK nodes
	Defn      *Node      // initializing assignment
	Curfn     *Node      // function for local variables
	Param     *Param     // additional fields for ONAME, OTYPE
	Decldepth int32      // declaration loop depth, increased for every loop or label
	Vargen    int32      // unique name for ONAME within a function.  Function outputs are numbered starting at one.
	Funcdepth int32
	// contains filtered or unexported fields
}

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

func (*Name) AutoTemp added in go1.8 

func (n *Name) AutoTemp() bool

func (*Name) Byval 

func (n *Name) Byval() bool

func (*Name) Captured 

func (n *Name) Captured() bool

func (*Name) Keepalive added in go1.6 

func (n *Name) Keepalive() bool

func (*Name) Needzero 

func (n *Name) Needzero() bool

func (*Name) Readonly 

func (n *Name) Readonly() bool

func (*Name) SetAutoTemp added in go1.9 

func (n *Name) SetAutoTemp(b bool)

func (*Name) SetByval added in go1.9 

func (n *Name) SetByval(b bool)

func (*Name) SetCaptured added in go1.9 

func (n *Name) SetCaptured(b bool)

func (*Name) SetKeepalive added in go1.9 

func (n *Name) SetKeepalive(b bool)

func (*Name) SetNeedzero added in go1.9 

func (n *Name) SetNeedzero(b bool)

func (*Name) SetReadonly added in go1.9 

func (n *Name) SetReadonly(b bool)

func (*Name) SetUsed added in go1.9 

func (n *Name) SetUsed(b bool)

func (*Name) Used added in go1.9 

func (n *Name) Used() bool

type NilVal 

type NilVal struct{}

type Node 

type Node struct {
	// Tree structure.
	// Generic recursive walks should follow these fields.
	Left  *Node
	Right *Node
	Ninit Nodes
	Nbody Nodes
	List  Nodes
	Rlist Nodes

	// most nodes
	Type *types.Type
	Orig *Node // original form, for printing, and tracking copies of ONAMEs

	// func
	Func *Func

	// ONAME, OTYPE, OPACK, OLABEL, some OLITERAL
	Name *Name

	Sym *types.Sym  // various
	E   interface{} // Opt or Val, see methods below

	// Various. Usually an offset into a struct. For example:
	// - ONAME nodes that refer to local variables use it to identify their stack frame position.
	// - ODOT, ODOTPTR, and OINDREGSP use it to indicate offset relative to their base address.
	// - OSTRUCTKEY uses it to store the named field's offset.
	// - Named OLITERALs use it to to store their ambient iota value.
	// Possibly still more uses. If you find any, document them.
	Xoffset int64

	Pos src.XPos

	Esc uint16 // EscXXX

	Op    Op
	Etype types.EType // op for OASOP, etype for OTYPE, exclam for export, 6g saved reg, ChanDir for OTCHAN, for OINDEXMAP 1=LHS,0=RHS
	// contains filtered or unexported fields
}

A Node is a single node in the syntax tree. Actually the syntax tree is a syntax DAG, because there is only one node with Op=ONAME for a given instance of a variable x. The same is true for Op=OTYPE and Op=OLITERAL. See Node.mayBeShared. 

var Curfn *Node

func AutoVar added in go1.7 

func AutoVar(v *ssa.Value) (*Node, int64)

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

func (*Node) Addable 

func (n *Node) Addable() bool

func (*Node) Addrtaken 

func (n *Node) Addrtaken() bool

func (*Node) Assigned 

func (n *Node) Assigned() bool

func (*Node) Bool 

func (n *Node) Bool() bool

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

func (*Node) Bounded 

func (n *Node) Bounded() bool

func (*Node) CanInt64 added in go1.10.5 

func (n *Node) CanInt64() bool

CanInt64 reports whether it is safe to call Int64() on n.

func (*Node) Class 

func (n *Node) Class() Class

func (*Node) Colas 

func (n *Node) Colas() bool

func (*Node) Diag 

func (n *Node) Diag() bool

func (*Node) Embedded 

func (n *Node) Embedded() bool

func (*Node) Format added in go1.8 

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

func (*Node) HasBreak added in go1.7 

func (n *Node) HasBreak() bool

func (*Node) HasCall added in go1.9 

func (n *Node) HasCall() bool

func (*Node) HasOpt added in go1.9 

func (n *Node) HasOpt() bool

func (*Node) HasVal added in go1.9 

func (n *Node) HasVal() bool

func (*Node) Implicit 

func (n *Node) Implicit() bool

func (*Node) Initorder 

func (n *Node) Initorder() uint8

func (*Node) InlFormal added in go1.10 

func (n *Node) InlFormal() bool

func (*Node) InlLocal added in go1.10 

func (n *Node) InlLocal() bool

func (*Node) Int64 added in go1.7 

func (n *Node) Int64() int64

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

func (*Node) Iota added in go1.8 

func (n *Node) Iota() int64

func (*Node) IsAutoTmp added in go1.8 

func (n *Node) IsAutoTmp() 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 (*Node) IsClosureVar added in go1.9 

func (n *Node) IsClosureVar() bool

func (*Node) IsMethod added in go1.8 

func (n *Node) IsMethod() bool

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

func (*Node) IsOutputParamHeapAddr added in go1.7 

func (n *Node) IsOutputParamHeapAddr() bool

func (*Node) Isddd 

func (n *Node) Isddd() bool

func (*Node) Likely 

func (n *Node) Likely() bool

func (*Node) Line 

func (n *Node) Line() 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 (*Node) NoInline added in go1.9 

func (n *Node) NoInline() bool

func (*Node) Noescape 

func (n *Node) Noescape() bool

func (*Node) NonNil added in go1.7 

func (n *Node) NonNil() bool

func (*Node) Opt 

func (n *Node) Opt() interface{}

Opt returns the optimizer data for the node.

func (*Node) SetAddable added in go1.9 

func (n *Node) SetAddable(b bool)

func (*Node) SetAddrtaken added in go1.9 

func (n *Node) SetAddrtaken(b bool)

func (*Node) SetAssigned added in go1.9 

func (n *Node) SetAssigned(b bool)

func (*Node) SetBounded added in go1.9 

func (n *Node) SetBounded(b bool)

func (*Node) SetClass added in go1.9 

func (n *Node) SetClass(b Class)

func (*Node) SetColas added in go1.9 

func (n *Node) SetColas(b bool)

func (*Node) SetDiag added in go1.9 

func (n *Node) SetDiag(b bool)

func (*Node) SetEmbedded added in go1.9 

func (n *Node) SetEmbedded(b bool)

func (*Node) SetHasBreak added in go1.7 

func (n *Node) SetHasBreak(b bool)

func (*Node) SetHasCall added in go1.9 

func (n *Node) SetHasCall(b bool)

func (*Node) SetHasOpt added in go1.9 

func (n *Node) SetHasOpt(b bool)

func (*Node) SetHasVal added in go1.9 

func (n *Node) SetHasVal(b bool)

func (*Node) SetImplicit added in go1.9 

func (n *Node) SetImplicit(b bool)

func (*Node) SetInitorder added in go1.9 

func (n *Node) SetInitorder(b uint8)

func (*Node) SetInlFormal added in go1.10 

func (n *Node) SetInlFormal(b bool)

func (*Node) SetInlLocal added in go1.10 

func (n *Node) SetInlLocal(b bool)

func (*Node) SetIota added in go1.8 

func (n *Node) SetIota(x int64)

func (*Node) SetIsClosureVar added in go1.9 

func (n *Node) SetIsClosureVar(b bool)

func (*Node) SetIsOutputParamHeapAddr added in go1.9 

func (n *Node) SetIsOutputParamHeapAddr(b bool)

func (*Node) SetIsddd added in go1.9 

func (n *Node) SetIsddd(b bool)

func (*Node) SetLikely added in go1.9 

func (n *Node) SetLikely(b bool)

func (*Node) SetNoInline added in go1.9 

func (n *Node) SetNoInline(b bool)

func (*Node) SetNoescape added in go1.9 

func (n *Node) SetNoescape(b bool)

func (*Node) SetNonNil added in go1.9 

func (n *Node) SetNonNil(b bool)

func (*Node) SetOpt 

func (n *Node) SetOpt(x interface{})

SetOpt sets the optimizer data for the node, which must not have been used with SetVal. SetOpt(nil) is ignored for Vals to simplify call sites that are clearing Opts.

func (*Node) SetSliceBounds added in go1.7 

func (n *Node) SetSliceBounds(low, high, max *Node)

SetSliceBounds sets n's slice bounds, where n is a slice expression. n must be a slice expression. If max is non-nil, n must be a full slice expression.

func (*Node) SetTypecheck added in go1.9 

func (n *Node) SetTypecheck(b uint8)

func (*Node) SetVal 

func (n *Node) SetVal(v Val)

SetVal sets the Val for the node, which must not have been used with SetOpt.

func (*Node) SetWalkdef added in go1.9 

func (n *Node) SetWalkdef(b uint8)

func (*Node) SliceBounds added in go1.7 

func (n *Node) SliceBounds() (low, high, max *Node)

SliceBounds returns n's slice bounds: low, high, and max in expr[low:high:max]. n must be a slice expression. max is nil if n is a simple slice expression.

func (*Node) StorageClass added in go1.10 

func (n *Node) StorageClass() ssa.StorageClass

func (*Node) String 

func (n *Node) String() string

func (*Node) Typ added in go1.7 

func (n *Node) Typ() *types.Type

func (*Node) Typecheck 

func (n *Node) Typecheck() uint8

func (*Node) Val 

func (n *Node) Val() Val

Val returns the Val for the node.

func (*Node) Walkdef 

func (n *Node) Walkdef() uint8

type NodeEscState 

type NodeEscState struct {
	Curfn             *Node
	Flowsrc           []EscStep // flow(this, src)
	Retval            Nodes     // on OCALLxxx, list of dummy return values
	Loopdepth         int32     // -1: global, 0: return variables, 1:function top level, increased inside function for every loop or label to mark scopes
	Level             Level
	Walkgen           uint32
	Maxextraloopdepth int32
}

type Nodes added in go1.7 

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

Nodes is a pointer to a slice of *Node. For fields that are not used in most nodes, this is used instead of a slice to save space.

func (Nodes) Addr added in go1.7 

func (n Nodes) Addr(i int) **Node

Addr returns the address of the i'th element of Nodes. It panics if n does not have at least i+1 elements.

func (*Nodes) Append added in go1.7 

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

Append appends entries to Nodes.

func (*Nodes) AppendNodes added in go1.7 

func (n *Nodes) AppendNodes(n2 *Nodes)

AppendNodes appends the contents of *n2 to n, then clears n2.

func (Nodes) First added in go1.7 

func (n Nodes) First() *Node

First returns the first element of Nodes (same as n.Index(0)). It panics if n has no elements.

func (Nodes) Format added in go1.8 

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

func (Nodes) Index added in go1.7 

func (n Nodes) Index(i int) *Node

Index returns the i'th element of Nodes. It panics if n does not have at least i+1 elements.

func (Nodes) Len added in go1.7 

func (n Nodes) Len() int

Len returns the number of entries in Nodes.

func (*Nodes) MoveNodes added in go1.7 

func (n *Nodes) MoveNodes(n2 *Nodes)

MoveNodes sets n to the contents of n2, then clears n2.

func (*Nodes) Prepend added in go1.8 

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) Second added in go1.7 

func (n Nodes) Second() *Node

Second returns the second element of Nodes (same as n.Index(1)). It panics if n has fewer than two elements.

func (*Nodes) Set added in go1.7 

func (n *Nodes) Set(s []*Node)

Set sets n to a slice. This takes ownership of the slice.

func (*Nodes) Set1 added in go1.7 

func (n *Nodes) Set1(n1 *Node)

Set1 sets n to a slice containing a single node.

func (*Nodes) Set2 added in go1.8 

func (n *Nodes) Set2(n1, n2 *Node)

Set2 sets n to a slice containing two nodes.

func (*Nodes) Set3 added in go1.9 

func (n *Nodes) Set3(n1, n2, n3 *Node)

Set3 sets n to a slice containing three nodes.

func (Nodes) SetFirst added in go1.9 

func (n Nodes) SetFirst(node *Node)

SetFirst sets the first element of Nodes to node. It panics if n does not have at least one elements.

func (Nodes) SetIndex added in go1.7 

func (n Nodes) SetIndex(i int, node *Node)

SetIndex sets the i'th element of Nodes to node. It panics if n does not have at least i+1 elements.

func (Nodes) SetSecond added in go1.9 

func (n Nodes) SetSecond(node *Node)

SetSecond sets the second element of Nodes to node. It panics if n does not have at least two elements.

func (Nodes) Slice added in go1.7 

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

Slice returns the entries in Nodes as a slice. Changes to the slice entries (as in s[i] = n) will be reflected in the Nodes.

func (Nodes) String added in go1.7 

func (n Nodes) String() string

type Op added in go1.6 

type Op uint8
const (
	OXXX Op = iota

	// names
	ONAME    // var, const or func name
	ONONAME  // unnamed arg or return value: f(int, string) (int, error) { etc }
	OTYPE    // type name
	OPACK    // import
	OLITERAL // literal

	// expressions
	OADD             // Left + Right
	OSUB             // Left - Right
	OOR              // Left | Right
	OXOR             // Left ^ Right
	OADDSTR          // +{List} (string addition, list elements are strings)
	OADDR            // &Left
	OANDAND          // Left && Right
	OAPPEND          // append(List); after walk, Left may contain elem type descriptor
	OARRAYBYTESTR    // Type(Left) (Type is string, Left is a []byte)
	OARRAYBYTESTRTMP // Type(Left) (Type is string, Left is a []byte, ephemeral)
	OARRAYRUNESTR    // Type(Left) (Type is string, Left is a []rune)
	OSTRARRAYBYTE    // Type(Left) (Type is []byte, Left is a string)
	OSTRARRAYBYTETMP // Type(Left) (Type is []byte, Left is a string, ephemeral)
	OSTRARRAYRUNE    // Type(Left) (Type is []rune, Left is a string)
	OAS              // Left = Right or (if Colas=true) Left := Right
	OAS2             // List = Rlist (x, y, z = a, b, c)
	OAS2FUNC         // List = Rlist (x, y = f())
	OAS2RECV         // List = Rlist (x, ok = <-c)
	OAS2MAPR         // List = Rlist (x, ok = m["foo"])
	OAS2DOTTYPE      // List = Rlist (x, ok = I.(int))
	OASOP            // Left Etype= Right (x += y)
	OCALL            // Left(List) (function call, method call or type conversion)
	OCALLFUNC        // Left(List) (function call f(args))
	OCALLMETH        // Left(List) (direct method call x.Method(args))
	OCALLINTER       // Left(List) (interface method call x.Method(args))
	OCALLPART        // Left.Right (method expression x.Method, not called)
	OCAP             // cap(Left)
	OCLOSE           // close(Left)
	OCLOSURE         // func Type { Body } (func literal)
	OCMPIFACE        // Left Etype Right (interface comparison, x == y or x != y)
	OCMPSTR          // Left Etype Right (string comparison, x == y, x < y, etc)
	OCOMPLIT         // Right{List} (composite literal, not yet lowered to specific form)
	OMAPLIT          // Type{List} (composite literal, Type is map)
	OSTRUCTLIT       // Type{List} (composite literal, Type is struct)
	OARRAYLIT        // Type{List} (composite literal, Type is array)
	OSLICELIT        // Type{List} (composite literal, Type is slice)
	OPTRLIT          // &Left (left is composite literal)
	OCONV            // Type(Left) (type conversion)
	OCONVIFACE       // Type(Left) (type conversion, to interface)
	OCONVNOP         // Type(Left) (type conversion, no effect)
	OCOPY            // copy(Left, Right)
	ODCL             // var Left (declares Left of type Left.Type)

	// Used during parsing but don't last.
	ODCLFUNC  // func f() or func (r) f()
	ODCLFIELD // struct field, interface field, or func/method argument/return value.
	ODCLCONST // const pi = 3.14
	ODCLTYPE  // type Int int or type Int = int

	ODELETE    // delete(Left, Right)
	ODOT       // Left.Sym (Left is of struct type)
	ODOTPTR    // Left.Sym (Left is of pointer to struct type)
	ODOTMETH   // Left.Sym (Left is non-interface, Right is method name)
	ODOTINTER  // Left.Sym (Left is interface, Right is method name)
	OXDOT      // Left.Sym (before rewrite to one of the preceding)
	ODOTTYPE   // 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
	ODOTTYPE2  // Left.Right or Left.Type (.Right during parsing, .Type once resolved; on rhs of OAS2DOTTYPE); after walk, .Right contains address of interface type descriptor
	OEQ        // Left == Right
	ONE        // Left != Right
	OLT        // Left < Right
	OLE        // Left <= Right
	OGE        // Left >= Right
	OGT        // Left > Right
	OIND       // *Left
	OINDEX     // Left[Right] (index of array or slice)
	OINDEXMAP  // Left[Right] (index of map)
	OKEY       // Left:Right (key:value in struct/array/map literal)
	OSTRUCTKEY // Sym:Left (key:value in struct literal, after type checking)
	OLEN       // len(Left)
	OMAKE      // make(List) (before type checking converts to one of the following)
	OMAKECHAN  // make(Type, Left) (type is chan)
	OMAKEMAP   // make(Type, Left) (type is map)
	OMAKESLICE // make(Type, Left, Right) (type is slice)
	OMUL       // Left * Right
	ODIV       // Left / Right
	OMOD       // Left % Right
	OLSH       // Left << Right
	ORSH       // Left >> Right
	OAND       // Left & Right
	OANDNOT    // Left &^ Right
	ONEW       // new(Left)
	ONOT       // !Left
	OCOM       // ^Left
	OPLUS      // +Left
	OMINUS     // -Left
	OOROR      // Left || Right
	OPANIC     // panic(Left)
	OPRINT     // print(List)
	OPRINTN    // println(List)
	OPAREN     // (Left)
	OSEND      // Left <- Right
	OSLICE     // Left[List[0] : List[1]] (Left is untypechecked or slice)
	OSLICEARR  // Left[List[0] : List[1]] (Left is array)
	OSLICESTR  // Left[List[0] : List[1]] (Left is string)
	OSLICE3    // Left[List[0] : List[1] : List[2]] (Left is untypedchecked or slice)
	OSLICE3ARR // Left[List[0] : List[1] : List[2]] (Left is array)
	ORECOVER   // recover()
	ORECV      // <-Left
	ORUNESTR   // Type(Left) (Type is string, Left is rune)
	OSELRECV   // Left = <-Right.Left: (appears as .Left of OCASE; Right.Op == ORECV)
	OSELRECV2  // List = <-Right.Left: (apperas as .Left of OCASE; count(List) == 2, Right.Op == ORECV)
	OIOTA      // iota
	OREAL      // real(Left)
	OIMAG      // imag(Left)
	OCOMPLEX   // complex(Left, Right)
	OALIGNOF   // unsafe.Alignof(Left)
	OOFFSETOF  // unsafe.Offsetof(Left)
	OSIZEOF    // unsafe.Sizeof(Left)

	// statements
	OBLOCK    // { List } (block of code)
	OBREAK    // break
	OCASE     // case Left or List[0]..List[1]: Nbody (select case after processing; Left==nil and List==nil means default)
	OXCASE    // case List: Nbody (select case before processing; List==nil means default)
	OCONTINUE // continue
	ODEFER    // defer Left (Left must be call)
	OEMPTY    // no-op (empty statement)
	OFALL     // fallthrough
	OFOR      // for Ninit; Left; Right { Nbody }
	OFORUNTIL // for Ninit; Left; Right { Nbody } ; test applied after executing body, not before
	OGOTO     // goto Left
	OIF       // if Ninit; Left { Nbody } else { Rlist }
	OLABEL    // Left:
	OPROC     // go Left (Left must be call)
	ORANGE    // for List = range Right { Nbody }
	ORETURN   // return List
	OSELECT   // select { List } (List is list of OXCASE or OCASE)
	OSWITCH   // switch Ninit; Left { List } (List is a list of OXCASE or OCASE)
	OTYPESW   // Left = Right.(type) (appears as .Left of OSWITCH)

	// types
	OTCHAN   // chan int
	OTMAP    // map[string]int
	OTSTRUCT // struct{}
	OTINTER  // interface{}
	OTFUNC   // func()
	OTARRAY  // []int, [8]int, [N]int or [...]int

	// misc
	ODDD        // func f(args ...int) or f(l...) or var a = [...]int{0, 1, 2}.
	ODDDARG     // func f(args ...int), introduced by escape analysis.
	OINLCALL    // intermediary representation of an inlined call.
	OEFACE      // itable and data words of an empty-interface value.
	OITAB       // itable word of an interface value.
	OIDATA      // data word of an interface value in Left
	OSPTR       // base pointer of a slice or string.
	OCLOSUREVAR // variable reference at beginning of closure function
	OCFUNC      // reference to c function pointer (not go func value)
	OCHECKNIL   // emit code to ensure pointer/interface not nil
	OVARKILL    // variable is dead
	OVARLIVE    // variable is alive
	OINDREGSP   // offset plus indirect of REGSP, such as 8(SP).

	// arch-specific opcodes
	ORETJMP // return to other function
	OGETG   // runtime.getg() (read g pointer)

	OEND
)

Node ops.

func (Op) Format added in go1.8 

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

func (Op) GoString added in go1.7 

func (o Op) GoString() string

func (Op) IsSlice3 added in go1.7 

func (o Op) IsSlice3() bool

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

func (Op) String added in go1.7 

func (i Op) String() string

type Order 

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

Order holds state during the ordering process.

type Param 

type Param struct {
	Ntype    *Node
	Heapaddr *Node // temp holding heap address of param

	// ONAME PAUTOHEAP
	Stackcopy *Node // the PPARAM/PPARAMOUT on-stack slot (moved func params only)

	// ONAME PPARAM
	Field *types.Field // TFIELD in arg struct

	// ONAME closure linkage
	// Consider:
	//
	//	func f() {
	//		x := 1 // x1
	//		func() {
	//			use(x) // x2
	//			func() {
	//				use(x) // x3
	//				--- parser is here ---
	//			}()
	//		}()
	//	}
	//
	// There is an original declaration of x and then a chain of mentions of x
	// leading into the current function. Each time x is mentioned in a new closure,
	// we create a variable representing x for use in that specific closure,
	// since the way you get to x is different in each closure.
	//
	// Let's number the specific variables as shown in the code:
	// x1 is the original x, x2 is when mentioned in the closure,
	// and x3 is when mentioned in the closure in the closure.
	//
	// We keep these linked (assume N > 1):
	//
	//   - x1.Defn = original declaration statement for x (like most variables)
	//   - x1.Innermost = current innermost closure x (in this case x3), or nil for none
	//   - x1.IsClosureVar() = false
	//
	//   - xN.Defn = x1, N > 1
	//   - xN.IsClosureVar() = true, N > 1
	//   - x2.Outer = nil
	//   - xN.Outer = x(N-1), N > 2
	//
	//
	// When we look up x in the symbol table, we always get x1.
	// Then we can use x1.Innermost (if not nil) to get the x
	// for the innermost known closure function,
	// but the first reference in a closure will find either no x1.Innermost
	// or an x1.Innermost with .Funcdepth < Funcdepth.
	// In that case, a new xN must be created, linked in with:
	//
	//     xN.Defn = x1
	//     xN.Outer = x1.Innermost
	//     x1.Innermost = xN
	//
	// When we finish the function, we'll process its closure variables
	// and find xN and pop it off the list using:
	//
	//     x1 := xN.Defn
	//     x1.Innermost = xN.Outer
	//
	// We leave xN.Innermost set so that we can still get to the original
	// variable quickly. Not shown here, but once we're
	// done parsing a function and no longer need xN.Outer for the
	// lexical x reference links as described above, closurebody
	// recomputes xN.Outer as the semantic x reference link tree,
	// even filling in x in intermediate closures that might not
	// have mentioned it along the way to inner closures that did.
	// See closurebody for details.
	//
	// During the eventual compilation, then, for closure variables we have:
	//
	//     xN.Defn = original variable
	//     xN.Outer = variable captured in next outward scope
	//                to make closure where xN appears
	//
	// Because of the sharding of pieces of the node, x.Defn means x.Name.Defn
	// and x.Innermost/Outer means x.Name.Param.Innermost/Outer.
	Innermost *Node
	Outer     *Node

	// OTYPE
	//
	// TODO: Should Func pragmas also be stored on the Name?
	Pragma syntax.Pragma
	Alias  bool // node is alias for Ntype (only used when type-checking ODCLTYPE)
}

type Progs added in go1.9 

type Progs struct {
	Text *obj.Prog // ATEXT Prog for this function
	// contains filtered or unexported fields
}

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

func (*Progs) Appendpp added in go1.9 

func (pp *Progs) Appendpp(p *obj.Prog, as obj.As, ftype obj.AddrType, freg int16, foffset int64, ttype obj.AddrType, treg int16, toffset int64) *obj.Prog

func (*Progs) Flush added in go1.9 

func (pp *Progs) Flush()

Flush converts from pp to machine code.

func (*Progs) Free added in go1.9 

func (pp *Progs) Free()

Free clears pp and any associated resources.

func (*Progs) NewProg added in go1.9 

func (pp *Progs) NewProg() *obj.Prog

func (*Progs) Prog added in go1.9 

func (pp *Progs) Prog(as obj.As) *obj.Prog

Prog adds a Prog with instruction As to pp.

type SSAGenState added in go1.7 

type SSAGenState struct {

	// Branches remembers all the branch instructions we've seen
	// and where they would like to go.
	Branches []Branch

	// 387 port: maps from SSE registers (REG_X?) to 387 registers (REG_F?)
	SSEto387 map[int16]int16
	// Some architectures require a 64-bit temporary for FP-related register shuffling. Examples include x86-387, PPC, and Sparc V8.
	ScratchFpMem *Node
	// contains filtered or unexported fields
}

SSAGenState contains state needed during Prog generation.

func (*SSAGenState) AddrScratch added in go1.8 

func (s *SSAGenState) AddrScratch(a *obj.Addr)

func (*SSAGenState) Call added in go1.9 

func (s *SSAGenState) Call(v *ssa.Value) *obj.Prog

func (*SSAGenState) DebugFriendlySetPosFrom added in go1.9 

func (s *SSAGenState) DebugFriendlySetPosFrom(v *ssa.Value)

DebugFriendlySetPos sets the position subject to heuristics that reduce "jumpy" line number churn when debugging. Spill/fill/copy instructions from the register allocator, phi functions, and instructions with a no-pos position are examples of instructions that can cause churn.

func (*SSAGenState) FPJump added in go1.9 

func (s *SSAGenState) FPJump(b, next *ssa.Block, jumps *[2][2]FloatingEQNEJump)

func (*SSAGenState) Pc added in go1.7 

func (s *SSAGenState) Pc() *obj.Prog

Pc returns the current Prog.

func (*SSAGenState) Prog added in go1.9 

func (s *SSAGenState) Prog(as obj.As) *obj.Prog

Prog appends a new Prog.

func (*SSAGenState) SetPos added in go1.9 

func (s *SSAGenState) SetPos(pos src.XPos)

SetPos sets the current source position.

type ScopeID added in go1.9 

type ScopeID int32

A ScopeID represents a lexical scope within a function.

type Sig 

type Sig struct {
	// contains filtered or unexported fields
}
type Symlink struct {
	// contains filtered or unexported fields
}

code to help generate trampoline functions for methods on embedded subtypes. these are approx the same as the corresponding adddot routines except that they expect to be called with unique tasks and they return the actual methods.

type Timings added in go1.8 

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

Timings collects the execution times of labeled phases which are added trough a sequence of Start/Stop calls. Events may be associated with each phase via AddEvent.

func (*Timings) AddEvent added in go1.8 

func (t *Timings) AddEvent(size int64, unit string)

AddEvent associates an event, i.e., a count, or an amount of data, with the most recently started or stopped phase; or the very first phase if Start or Stop hasn't been called yet. The unit specifies the unit of measurement (e.g., MB, lines, no. of funcs, etc.).

func (*Timings) Start added in go1.8 

func (t *Timings) Start(labels ...string)

Start marks the beginning of a new phase and implicitly stops the previous phase. The phase name is the colon-separated concatenation of the labels.

func (*Timings) Stop added in go1.8 

func (t *Timings) Stop(labels ...string)

Stop marks the end of a phase and implicitly starts a new phase. The labels are added to the labels of the ended phase.

func (*Timings) Write added in go1.8 

func (t *Timings) Write(w io.Writer, prefix string)

Write prints the phase times to w. The prefix is printed at the start of each line.

type Val 

type Val struct {
	// U contains one of:
	// bool     bool when n.ValCtype() == CTBOOL
	// *Mpint   int when n.ValCtype() == CTINT, rune when n.ValCtype() == CTRUNE
	// *Mpflt   float when n.ValCtype() == CTFLT
	// *Mpcplx  pair of floats when n.ValCtype() == CTCPLX
	// string   string when n.ValCtype() == CTSTR
	// *Nilval  when n.ValCtype() == CTNIL
	U interface{}
}

func (Val) Ctype 

func (v Val) Ctype() Ctype

func (Val) Format added in go1.8 

func (v Val) Format(s fmt.State, verb rune)

func (Val) Interface added in go1.8 

func (v Val) Interface() interface{}

Interface returns the constant value stored in v as an interface{}. It returns int64s for ints and runes, float64s for floats, complex128s for complex values, and nil for constant nils.

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.