Go: cmd/compile/internal/gc Index | Files

package gc

import "cmd/compile/internal/gc"

Index

Package Files

alg.go align.go bexport.go bimport.go bitset.go builtin.go bv.go class_string.go closure.go const.go dcl.go esc.go export.go fmt.go gen.go go.go gsubr.go init.go inl.go lex.go main.go mpfloat.go mpint.go noder.go norace.go obj.go opnames.go order.go pgen.go phi.go plive.go pprof.go racewalk.go range.go reflect.go scope.go select.go sinit.go ssa.go subr.go swt.go syntax.go timings.go trace.go typecheck.go types.go types_acc.go universe.go unsafe.go util.go walk.go

Constants

const (
    WORDBITS  = 32
    WORDMASK  = WORDBITS - 1
    WORDSHIFT = 5
)
const (
    EscFuncUnknown = 0 + iota
    EscFuncPlanned
    EscFuncStarted
    EscFuncTagged
)
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.

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

const (
    BADWIDTH        = types.BADWIDTH
    MaxStackVarSize = 10 * 1024 * 1024
)
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
)
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
)
const (
    H0  = 2166136261
    Hp  = 16777619
)

FNV-1 hash function constants.

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!

const (
    InitNotStarted = iota
    InitDone
    InitPending
)

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

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 (after processing)
    OXFALL    // fallthrough (before processing)
    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   // List = Left.(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.

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

const (
    ArhdrSize = 60
)

architecture-independent object file output

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.

const NOTALOOPDEPTH = -1

Variables

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

    Udiv *obj.LSym

    // GO386=387
    ControlWord64trunc,
    ControlWord32 *obj.LSym
)
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_pctab string
)
var Ctxt *obj.Link
var Debug [256]int
var Debug_checknil int
var (
    Debug_export int // if set, print debugging information about export data
)
var Debug_gcprog int // set by -d gcprog
var Debug_typeassert int
var Nacl bool
var Runtimepkg *types.Pkg // fake package runtime
var Widthptr int
var Widthreg int

func AddAux Uses

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 Uses

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

func AddrAuto Uses

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

func Addrconst Uses

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

func AuxOffset Uses

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

func CheckLoweredGetClosurePtr Uses

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 Uses

func CheckLoweredPhi(v *ssa.Value)

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

func Dump Uses

func Dump(s string, n *Node)

func Exit Uses

func Exit(code int)

func Fatalf Uses

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

func Import Uses

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

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

func IncomparableField Uses

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

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

func IsAlias Uses

func IsAlias(sym *types.Sym) bool

func IsComparable Uses

func IsComparable(t *types.Type) bool

IsComparable reports whether t is a comparable type.

func IsRegularMemory Uses

func IsRegularMemory(t *types.Type) bool

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

func Isconst Uses

func Isconst(n *Node, ct Ctype) bool

func Main Uses

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 Uses

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

func Rnd Uses

func Rnd(o int64, r int64) int64

func Sysfunc Uses

func Sysfunc(name string) *obj.LSym

func Warn Uses

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

func Warnl Uses

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

type AlgKind Uses

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 Uses

type Arch struct {
    LinkArch *obj.LinkArch

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

    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 Uses

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

BlockEffects summarizes the liveness effects on an SSA block.

type Branch Uses

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

Branch is an unresolved branch.

type Class Uses

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

)

go:generate stringer -type=Class

func (Class) String Uses

func (i Class) String() string

type Ctype Uses

type Ctype int8

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

const (
    CTxxx Ctype = iota

    CTINT
    CTRUNE
    CTFLT
    CTCPLX
    CTSTR
    CTBOOL
    CTNIL
)

type Dlist Uses

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 Uses

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

type EscState Uses

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

type EscStep Uses

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 Uses

type FloatingEQNEJump struct {
    Jump  obj.As
    Index int
}

type FmtFlag Uses

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 Uses

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{}
    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

    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 Uses

func (f *Func) Dupok() bool

func (*Func) HasDefer Uses

func (f *Func) HasDefer() bool

func (*Func) IsHiddenClosure Uses

func (f *Func) IsHiddenClosure() bool

func (*Func) Needctxt Uses

func (f *Func) Needctxt() bool

func (*Func) NilCheckDisabled Uses

func (f *Func) NilCheckDisabled() bool

func (*Func) NoFramePointer Uses

func (f *Func) NoFramePointer() bool

func (*Func) ReflectMethod Uses

func (f *Func) ReflectMethod() bool

func (*Func) SetDupok Uses

func (f *Func) SetDupok(b bool)

func (*Func) SetHasDefer Uses

func (f *Func) SetHasDefer(b bool)

func (*Func) SetIsHiddenClosure Uses

func (f *Func) SetIsHiddenClosure(b bool)

func (*Func) SetNeedctxt Uses

func (f *Func) SetNeedctxt(b bool)

func (*Func) SetNilCheckDisabled Uses

func (f *Func) SetNilCheckDisabled(b bool)

func (*Func) SetNoFramePointer Uses

func (f *Func) SetNoFramePointer(b bool)

func (*Func) SetReflectMethod Uses

func (f *Func) SetReflectMethod(b bool)

func (*Func) SetWrapper Uses

func (f *Func) SetWrapper(b bool)

func (*Func) Wrapper Uses

func (f *Func) Wrapper() bool

type GCProg Uses

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

type InitEntry Uses

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

type InitPlan Uses

type InitPlan struct {
    E []InitEntry
}

type Level Uses

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 Uses

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

A collection of global state used by liveness analysis.

type Mark Uses

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 Uses

type Mpcplx struct {
    Real Mpflt
    Imag Mpflt
}

Mpcplx represents a complex constant.

type Mpflt Uses

type Mpflt struct {
    Val big.Float
}

Mpflt represents a floating-point constant.

func (*Mpflt) Add Uses

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

func (*Mpflt) AddFloat64 Uses

func (a *Mpflt) AddFloat64(c float64)

func (*Mpflt) Cmp Uses

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

func (*Mpflt) CmpFloat64 Uses

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

func (*Mpflt) Float32 Uses

func (a *Mpflt) Float32() float64

func (*Mpflt) Float64 Uses

func (a *Mpflt) Float64() float64

func (*Mpflt) Mul Uses

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

func (*Mpflt) MulFloat64 Uses

func (a *Mpflt) MulFloat64(c float64)

func (*Mpflt) Neg Uses

func (a *Mpflt) Neg()

func (*Mpflt) Quo Uses

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

func (*Mpflt) Set Uses

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

func (*Mpflt) SetFloat64 Uses

func (a *Mpflt) SetFloat64(c float64)

func (*Mpflt) SetInt Uses

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

func (*Mpflt) SetString Uses

func (a *Mpflt) SetString(as string)

func (*Mpflt) String Uses

func (f *Mpflt) String() string

func (*Mpflt) Sub Uses

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

type Mpint Uses

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 Uses

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

func (*Mpint) And Uses

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

func (*Mpint) AndNot Uses

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

func (*Mpint) Cmp Uses

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

func (*Mpint) CmpInt64 Uses

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

func (*Mpint) Int64 Uses

func (a *Mpint) Int64() int64

func (*Mpint) Lsh Uses

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

func (*Mpint) Mul Uses

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

func (*Mpint) Neg Uses

func (a *Mpint) Neg()

func (*Mpint) Or Uses

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

func (*Mpint) Quo Uses

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

func (*Mpint) Rem Uses

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

func (*Mpint) Rsh Uses

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

func (*Mpint) Set Uses

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

func (*Mpint) SetFloat Uses

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

func (*Mpint) SetInt64 Uses

func (a *Mpint) SetInt64(c int64)

func (*Mpint) SetOverflow Uses

func (a *Mpint) SetOverflow()

func (*Mpint) SetString Uses

func (a *Mpint) SetString(as string)

func (*Mpint) String Uses

func (x *Mpint) String() string

func (*Mpint) Sub Uses

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

func (*Mpint) Xor Uses

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

type Name Uses

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 Uses

func (n *Name) AutoTemp() bool

func (*Name) Byval Uses

func (n *Name) Byval() bool

func (*Name) Captured Uses

func (n *Name) Captured() bool

func (*Name) Keepalive Uses

func (n *Name) Keepalive() bool

func (*Name) Needzero Uses

func (n *Name) Needzero() bool

func (*Name) Readonly Uses

func (n *Name) Readonly() bool

func (*Name) SetAutoTemp Uses

func (n *Name) SetAutoTemp(b bool)

func (*Name) SetByval Uses

func (n *Name) SetByval(b bool)

func (*Name) SetCaptured Uses

func (n *Name) SetCaptured(b bool)

func (*Name) SetKeepalive Uses

func (n *Name) SetKeepalive(b bool)

func (*Name) SetNeedzero Uses

func (n *Name) SetNeedzero(b bool)

func (*Name) SetReadonly Uses

func (n *Name) SetReadonly(b bool)

func (*Name) SetUsed Uses

func (n *Name) SetUsed(b bool)

func (*Name) Used Uses

func (n *Name) Used() bool

type NilVal Uses

type NilVal struct{}

type Node Uses

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.
    // - OXCASE and OXFALL use it to validate the use of fallthrough.
    // - 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 Uses

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 Uses

func (n *Node) Addable() bool

func (*Node) Addrtaken Uses

func (n *Node) Addrtaken() bool

func (*Node) Assigned Uses

func (n *Node) Assigned() bool

func (*Node) Bool Uses

func (n *Node) Bool() bool

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

func (*Node) Bounded Uses

func (n *Node) Bounded() bool

func (*Node) Class Uses

func (n *Node) Class() Class

func (*Node) Colas Uses

func (n *Node) Colas() bool

func (*Node) Diag Uses

func (n *Node) Diag() bool

func (*Node) Embedded Uses

func (n *Node) Embedded() bool

func (*Node) Format Uses

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

func (*Node) HasBreak Uses

func (n *Node) HasBreak() bool

func (*Node) HasCall Uses

func (n *Node) HasCall() bool

func (*Node) HasOpt Uses

func (n *Node) HasOpt() bool

func (*Node) HasVal Uses

func (n *Node) HasVal() bool

func (*Node) Implicit Uses

func (n *Node) Implicit() bool

func (*Node) Initorder Uses

func (n *Node) Initorder() uint8

func (*Node) Int64 Uses

func (n *Node) Int64() int64

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

func (*Node) Iota Uses

func (n *Node) Iota() int64

func (*Node) IsAutoTmp Uses

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 Uses

func (n *Node) IsClosureVar() bool

func (*Node) IsMethod Uses

func (n *Node) IsMethod() bool

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

func (*Node) IsOutputParamHeapAddr Uses

func (n *Node) IsOutputParamHeapAddr() bool

func (*Node) Isddd Uses

func (n *Node) Isddd() bool

func (*Node) Likely Uses

func (n *Node) Likely() bool

func (*Node) Line Uses

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) Local Uses

func (n *Node) Local() bool

func (*Node) NoInline Uses

func (n *Node) NoInline() bool

func (*Node) Noescape Uses

func (n *Node) Noescape() bool

func (*Node) NonNil Uses

func (n *Node) NonNil() bool

func (*Node) Opt Uses

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

Opt returns the optimizer data for the node.

func (*Node) SetAddable Uses

func (n *Node) SetAddable(b bool)

func (*Node) SetAddrtaken Uses

func (n *Node) SetAddrtaken(b bool)

func (*Node) SetAssigned Uses

func (n *Node) SetAssigned(b bool)

func (*Node) SetBounded Uses

func (n *Node) SetBounded(b bool)

func (*Node) SetClass Uses

func (n *Node) SetClass(b Class)

func (*Node) SetColas Uses

func (n *Node) SetColas(b bool)

func (*Node) SetDiag Uses

func (n *Node) SetDiag(b bool)

func (*Node) SetEmbedded Uses

func (n *Node) SetEmbedded(b bool)

func (*Node) SetHasBreak Uses

func (n *Node) SetHasBreak(b bool)

func (*Node) SetHasCall Uses

func (n *Node) SetHasCall(b bool)

func (*Node) SetHasOpt Uses

func (n *Node) SetHasOpt(b bool)

func (*Node) SetHasVal Uses

func (n *Node) SetHasVal(b bool)

func (*Node) SetImplicit Uses

func (n *Node) SetImplicit(b bool)

func (*Node) SetInitorder Uses

func (n *Node) SetInitorder(b uint8)

func (*Node) SetIota Uses

func (n *Node) SetIota(x int64)

func (*Node) SetIsClosureVar Uses

func (n *Node) SetIsClosureVar(b bool)

func (*Node) SetIsOutputParamHeapAddr Uses

func (n *Node) SetIsOutputParamHeapAddr(b bool)

func (*Node) SetIsddd Uses

func (n *Node) SetIsddd(b bool)

func (*Node) SetLikely Uses

func (n *Node) SetLikely(b bool)

func (*Node) SetLocal Uses

func (n *Node) SetLocal(b bool)

func (*Node) SetNoInline Uses

func (n *Node) SetNoInline(b bool)

func (*Node) SetNoescape Uses

func (n *Node) SetNoescape(b bool)

func (*Node) SetNonNil Uses

func (n *Node) SetNonNil(b bool)

func (*Node) SetOpt Uses

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 Uses

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 Uses

func (n *Node) SetTypecheck(b uint8)

func (*Node) SetVal Uses

func (n *Node) SetVal(v Val)

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

func (*Node) SetWalkdef Uses

func (n *Node) SetWalkdef(b uint8)

func (*Node) SliceBounds Uses

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) String Uses

func (n *Node) String() string

func (*Node) Typ Uses

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

func (*Node) Typecheck Uses

func (n *Node) Typecheck() uint8

func (*Node) Val Uses

func (n *Node) Val() Val

Val returns the Val for the node.

func (*Node) Walkdef Uses

func (n *Node) Walkdef() uint8

type NodeEscState Uses

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 Uses

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 Uses

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 Uses

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

Append appends entries to Nodes.

func (*Nodes) AppendNodes Uses

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

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

func (Nodes) First Uses

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 Uses

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

func (Nodes) Index Uses

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 Uses

func (n Nodes) Len() int

Len returns the number of entries in Nodes.

func (*Nodes) MoveNodes Uses

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

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

func (*Nodes) Prepend Uses

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 Uses

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 Uses

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

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

func (*Nodes) Set1 Uses

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

Set1 sets n to a slice containing a single node.

func (*Nodes) Set2 Uses

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

Set2 sets n to a slice containing two nodes.

func (*Nodes) Set3 Uses

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

Set3 sets n to a slice containing three nodes.

func (Nodes) SetFirst Uses

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 Uses

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 Uses

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 Uses

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 Uses

func (n Nodes) String() string

type Op Uses

type Op uint8

func (Op) Format Uses

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

func (Op) GoString Uses

func (o Op) GoString() string

func (Op) IsSlice3 Uses

func (o Op) IsSlice3() bool

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

func (Op) String Uses

func (o Op) String() string

type Order Uses

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

Order holds state during the ordering process.

type Param Uses

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 Uses

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 Uses

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 Uses

func (pp *Progs) Flush()

Flush converts from pp to machine code.

func (*Progs) Free Uses

func (pp *Progs) Free()

Free clears pp and any associated resources.

func (*Progs) NewProg Uses

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

func (*Progs) Prog Uses

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

Prog adds a Prog with instruction As to pp.

type SSAGenState Uses

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 Uses

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

func (*SSAGenState) Call Uses

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

func (*SSAGenState) DebugFriendlySetPosFrom Uses

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 Uses

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

func (*SSAGenState) Pc Uses

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

Pc returns the current Prog.

func (*SSAGenState) Prog Uses

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

Prog appends a new Prog.

func (*SSAGenState) SetPos Uses

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

SetPos sets the current source position.

type ScopeID Uses

type ScopeID int32

A ScopeID represents a lexical scope within a function.

type Sig Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

func (v Val) Ctype() Ctype

func (Val) Format Uses

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

func (Val) Interface Uses

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.

Package gc imports 40 packages (graph) and is imported by 18 packages. Updated 2017-11-01. Refresh now. Tools for package owners.