Go编译器简介

type token uint

//go:generate stringer -type token -linecomment tokens.go

const (
    _    token = iota
    _EOF       // EOF

    // names and literals
    _Name    // name
    _Literal // literal

    // operators and operations
    // _Operator is excluding '*' (_Star)
    _Operator // op
    _AssignOp // op=
    _IncOp    // opop
    _Assign   // =
    _Define   // :=
    _Arrow    // <-
    _Star     // *

    // delimiters
    _Lparen    // (
    _Lbrack    // [
    _Lbrace    // {
    _Rparen    // )
    _Rbrack    // ]
    _Rbrace    // }
    _Comma     // ,
    _Semi      // ;
    _Colon     // :
    _Dot       // .
    _DotDotDot // ...

    // keywords
    _Break       // break
    _Case        // case
    _Chan        // chan
    _Const       // const
    _Continue    // continue
    _Default     // default
    _Defer       // defer
    _Else        // else
    _Fallthrough // fallthrough
    _For         // for
    _Func        // func
    _Go          // go
    _Goto        // goto
    _If          // if
    _Import      // import
    _Interface   // interface
    _Map         // map
    _Package     // package
    _Range       // range
    _Return      // return
    _Select      // select
    _Struct      // struct
    _Switch      // switch
    _Type        // type
    _Var         // var

    // empty line comment to exclude it from .String
    tokenCount //
)

//go:generate stringer -type=Op -trimprefix=O node.go

type Op uint8

// Node ops.
const (
    OXXX Op = iota

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

    // expressions
    OADD          // X + Y
    OSUB          // X - Y
    OOR           // X | Y
    OXOR          // X ^ Y
    OADDSTR       // +{List} (string addition, list elements are strings)
    OADDR         // &X
    OANDAND       // X && Y
    OAPPEND       // append(Args); after walk, X may contain elem type descriptor
    OBYTES2STR    // Type(X) (Type is string, X is a []byte)
    OBYTES2STRTMP // Type(X) (Type is string, X is a []byte, ephemeral)
    ORUNES2STR    // Type(X) (Type is string, X is a []rune)
    OSTR2BYTES    // Type(X) (Type is []byte, X is a string)
    OSTR2BYTESTMP // Type(X) (Type is []byte, X is a string, ephemeral)
    OSTR2RUNES    // Type(X) (Type is []rune, X is a string)
    OSLICE2ARR    // Type(X) (Type is [N]T, X is a []T)
    OSLICE2ARRPTR // Type(X) (Type is *[N]T, X is a []T)
    // X = Y or (if Def=true) X := Y
    // If Def, then Init includes a DCL node for X.
    OAS
    // Lhs = Rhs (x, y, z = a, b, c) or (if Def=true) Lhs := Rhs
    // If Def, then Init includes DCL nodes for Lhs
    OAS2
    OAS2DOTTYPE // Lhs = Rhs (x, ok = I.(int))
    OAS2FUNC    // Lhs = Rhs (x, y = f())
    OAS2MAPR    // Lhs = Rhs (x, ok = m["foo"])
    OAS2RECV    // Lhs = Rhs (x, ok = <-c)
    OASOP       // X AsOp= Y (x += y)
    OCALL       // X(Args) (function call, method call or type conversion)

    // OCALLFUNC, OCALLMETH, and OCALLINTER have the same structure.
    // Prior to walk, they are: X(Args), where Args is all regular arguments.
    // After walk, if any argument whose evaluation might requires temporary variable,
    // that temporary variable will be pushed to Init, Args will contains an updated
    // set of arguments.
    OCALLFUNC  // X(Args) (function call f(args))
    OCALLMETH  // X(Args) (direct method call x.Method(args))
    OCALLINTER // X(Args) (interface method call x.Method(args))
    OCAP       // cap(X)
    OCLOSE     // close(X)
    OCLOSURE   // func Type { Func.Closure.Body } (func literal)
    OCOMPLIT   // Type{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), Len is slice length.
    OPTRLIT    // &X (X is composite literal)
    OCONV      // Type(X) (type conversion)
    OCONVIFACE // Type(X) (type conversion, to interface)
    OCONVIDATA // Builds a data word to store X in an interface. Equivalent to IDATA(CONVIFACE(X)). Is an ir.ConvExpr.
    OCONVNOP   // Type(X) (type conversion, no effect)
    OCOPY      // copy(X, Y)
    ODCL       // var X (declares X of type X.Type)

    // Used during parsing but don't last.
    ODCLFUNC  // func f() or func (r) f()
    ODCLCONST // const pi = 3.14
    ODCLTYPE  // type Int int or type Int = int

    ODELETE        // delete(Args)
    ODOT           // X.Sel (X is of struct type)
    ODOTPTR        // X.Sel (X is of pointer to struct type)
    ODOTMETH       // X.Sel (X is non-interface, Sel is method name)
    ODOTINTER      // X.Sel (X is interface, Sel is method name)
    OXDOT          // X.Sel (before rewrite to one of the preceding)
    ODOTTYPE       // X.Ntype or X.Type (.Ntype during parsing, .Type once resolved); after walk, Itab contains address of interface type descriptor and Itab.X contains address of concrete type descriptor
    ODOTTYPE2      // X.Ntype or X.Type (.Ntype during parsing, .Type once resolved; on rhs of OAS2DOTTYPE); after walk, Itab contains address of interface type descriptor
    OEQ            // X == Y
    ONE            // X != Y
    OLT            // X < Y
    OLE            // X <= Y
    OGE            // X >= Y
    OGT            // X > Y
    ODEREF         // *X
    OINDEX         // X[Index] (index of array or slice)
    OINDEXMAP      // X[Index] (index of map)
    OKEY           // Key:Value (key:value in struct/array/map literal)
    OSTRUCTKEY     // Field:Value (key:value in struct literal, after type checking)
    OLEN           // len(X)
    OMAKE          // make(Args) (before type checking converts to one of the following)
    OMAKECHAN      // make(Type[, Len]) (type is chan)
    OMAKEMAP       // make(Type[, Len]) (type is map)
    OMAKESLICE     // make(Type[, Len[, Cap]]) (type is slice)
    OMAKESLICECOPY // makeslicecopy(Type, Len, Cap) (type is slice; Len is length and Cap is the copied from slice)
    // OMAKESLICECOPY is created by the order pass and corresponds to:
    //  s = make(Type, Len); copy(s, Cap)
    //
    // Bounded can be set on the node when Len == len(Cap) is known at compile time.
    //
    // This node is created so the walk pass can optimize this pattern which would
    // otherwise be hard to detect after the order pass.
    OMUL              // X * Y
    ODIV              // X / Y
    OMOD              // X % Y
    OLSH              // X << Y
    ORSH              // X >> Y
    OAND              // X & Y
    OANDNOT           // X &^ Y
    ONEW              // new(X); corresponds to calls to new in source code
    ONOT              // !X
    OBITNOT           // ^X
    OPLUS             // +X
    ONEG              // -X
    OOROR             // X || Y
    OPANIC            // panic(X)
    OPRINT            // print(List)
    OPRINTN           // println(List)
    OPAREN            // (X)
    OSEND             // Chan <- Value
    OSLICE            // X[Low : High] (X is untypechecked or slice)
    OSLICEARR         // X[Low : High] (X is pointer to array)
    OSLICESTR         // X[Low : High] (X is string)
    OSLICE3           // X[Low : High : Max] (X is untypedchecked or slice)
    OSLICE3ARR        // X[Low : High : Max] (X is pointer to array)
    OSLICEHEADER      // sliceheader{Ptr, Len, Cap} (Ptr is unsafe.Pointer, Len is length, Cap is capacity)
    OSTRINGHEADER     // stringheader{Ptr, Len} (Ptr is unsafe.Pointer, Len is length)
    ORECOVER          // recover()
    ORECOVERFP        // recover(Args) w/ explicit FP argument
    ORECV             // <-X
    ORUNESTR          // Type(X) (Type is string, X is rune)
    OSELRECV2         // like OAS2: Lhs = Rhs where len(Lhs)=2, len(Rhs)=1, Rhs[0].Op = ORECV (appears as .Var of OCASE)
    OREAL             // real(X)
    OIMAG             // imag(X)
    OCOMPLEX          // complex(X, Y)
    OALIGNOF          // unsafe.Alignof(X)
    OOFFSETOF         // unsafe.Offsetof(X)
    OSIZEOF           // unsafe.Sizeof(X)
    OUNSAFEADD        // unsafe.Add(X, Y)
    OUNSAFESLICE      // unsafe.Slice(X, Y)
    OUNSAFESLICEDATA  // unsafe.SliceData(X)
    OUNSAFESTRING     // unsafe.String(X, Y)
    OUNSAFESTRINGDATA // unsafe.StringData(X)
    OMETHEXPR         // X(Args) (method expression T.Method(args), first argument is the method receiver)
    OMETHVALUE        // X.Sel   (method expression t.Method, not called)

    // statements
    OBLOCK // { List } (block of code)
    OBREAK // break [Label]
    // OCASE:  case List: Body (List==nil means default)
    //   For OTYPESW, List is a OTYPE node for the specified type (or OLITERAL
    //   for nil) or an ODYNAMICTYPE indicating a runtime type for generics.
    //   If a type-switch variable is specified, Var is an
    //   ONAME for the version of the type-switch variable with the specified
    //   type.
    OCASE
    OCONTINUE // continue [Label]
    ODEFER    // defer Call
    OFALL     // fallthrough
    OFOR      // for Init; Cond; Post { Body }
    OGOTO     // goto Label
    OIF       // if Init; Cond { Then } else { Else }
    OLABEL    // Label:
    OGO       // go Call
    ORANGE    // for Key, Value = range X { Body }
    ORETURN   // return Results
    OSELECT   // select { Cases }
    OSWITCH   // switch Init; Expr { Cases }
    // OTYPESW:  X := Y.(type) (appears as .Tag of OSWITCH)
    //   X is nil if there is no type-switch variable
    OTYPESW
    OFUNCINST // instantiation of a generic function

    // misc
    // intermediate representation of an inlined call.  Uses Init (assignments
    // for the captured variables, parameters, retvars, & INLMARK op),
    // Body (body of the inlined function), and ReturnVars (list of
    // return values)
    OINLCALL       // 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 X
    OSPTR          // base pointer of a slice or string.
    OCFUNC         // reference to c function pointer (not go func value)
    OCHECKNIL      // emit code to ensure pointer/interface not nil
    ORESULT        // result of a function call; Xoffset is stack offset
    OINLMARK       // start of an inlined body, with file/line of caller. Xoffset is an index into the inline tree.
    OLINKSYMOFFSET // offset within a name
    OJUMPTABLE     // A jump table structure for implementing dense expression switches

    // opcodes for generics
    ODYNAMICDOTTYPE  // x = i.(T) where T is a type parameter (or derived from a type parameter)
    ODYNAMICDOTTYPE2 // x, ok = i.(T) where T is a type parameter (or derived from a type parameter)
    ODYNAMICTYPE     // a type node for type switches (represents a dynamic target type for a type switch)

    // arch-specific opcodes
    OTAILCALL    // tail call to another function
    OGETG        // runtime.getg() (read g pointer)
    OGETCALLERPC // runtime.getcallerpc() (continuation PC in caller frame)
    OGETCALLERSP // runtime.getcallersp() (stack pointer in caller frame)

    OEND
)

package main

import "fmt"

func main() {
    a := 1
    b := 2
    // 使用闭包
    go func() {
        fmt.Println(a, b)
    }()
    a = 99
}

// tests/inline_bench_test.go
package tests

import "testing"

func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

// 使用了函数内联
func BenchmarkMax(b *testing.B) {
    var a = 10
    for i := 0; i < b.N; i++ {
        // 进行大小计算
        max(a, i)
    }
}

//go:noinline
func maxNoInline(a, b int) int {
    if a > b {
        return a
    }
    return b
}

// 不使用函数内联
func BenchmarkNoInlineMax(b *testing.B) {
    var a = 10
    for i := 0; i < b.N; i++ {
        // 进行大小计算
        maxNoInline(a, i)
    }
}

// CanInline determines whether fn is inlineable.
// If so, CanInline saves copies of fn.Body and fn.Dcl in fn.Inl.
// fn and fn.Body will already have been typechecked.
func CanInline(fn *ir.Func, profile *pgo.Profile) {
    if fn.Nname == nil {
        base.Fatalf("CanInline no nname %+v", fn)
    }

    var reason string // reason, if any, that the function was not inlined
    if base.Flag.LowerM > 1 || logopt.Enabled() {
        defer func() {
            if reason != "" {
                if base.Flag.LowerM > 1 {
                    fmt.Printf("%v: cannot inline %v: %s\n", ir.Line(fn), fn.Nname, reason)
                }
                if logopt.Enabled() {
                    logopt.LogOpt(fn.Pos(), "cannotInlineFunction", "inline", ir.FuncName(fn), reason)
                }
            }
        }()
    }

    // If marked "go:noinline", don't inline
    if fn.Pragma&ir.Noinline != 0 {
        reason = "marked go:noinline"
        return
    }

    // If marked "go:norace" and -race compilation, don't inline.
    if base.Flag.Race && fn.Pragma&ir.Norace != 0 {
        reason = "marked go:norace with -race compilation"
        return
    }

    // If marked "go:nocheckptr" and -d checkptr compilation, don't inline.
    if base.Debug.Checkptr != 0 && fn.Pragma&ir.NoCheckPtr != 0 {
        reason = "marked go:nocheckptr"
        return
    }

    // If marked "go:cgo_unsafe_args", don't inline, since the
    // function makes assumptions about its argument frame layout.
    if fn.Pragma&ir.CgoUnsafeArgs != 0 {
        reason = "marked go:cgo_unsafe_args"
        return
    }

    // If marked as "go:uintptrkeepalive", don't inline, since the
    // keep alive information is lost during inlining.
    //
    // TODO(prattmic): This is handled on calls during escape analysis,
    // which is after inlining. Move prior to inlining so the keep-alive is
    // maintained after inlining.
    if fn.Pragma&ir.UintptrKeepAlive != 0 {
        reason = "marked as having a keep-alive uintptr argument"
        return
    }

    // If marked as "go:uintptrescapes", don't inline, since the
    // escape information is lost during inlining.
    if fn.Pragma&ir.UintptrEscapes != 0 {
        reason = "marked as having an escaping uintptr argument"
        return
    }

    // The nowritebarrierrec checker currently works at function
    // granularity, so inlining yeswritebarrierrec functions can
    // confuse it (#22342). As a workaround, disallow inlining
    // them for now.
    if fn.Pragma&ir.Yeswritebarrierrec != 0 {
        reason = "marked go:yeswritebarrierrec"
        return
    }

    // If fn has no body (is defined outside of Go), cannot inline it.
    if len(fn.Body) == 0 {
        reason = "no function body"
        return
    }

    if fn.Typecheck() == 0 {
        base.Fatalf("CanInline on non-typechecked function %v", fn)
    }

    n := fn.Nname
    if n.Func.InlinabilityChecked() {
        return
    }
    defer n.Func.SetInlinabilityChecked(true)

    cc := int32(inlineExtraCallCost)
    if base.Flag.LowerL == 4 {
        cc = 1 // this appears to yield better performance than 0.
    }

    // Update the budget for profile-guided inlining.
    budget := int32(inlineMaxBudget)
    if profile != nil {
        if n, ok := profile.WeightedCG.IRNodes[ir.PkgFuncName(fn)]; ok {
            if _, ok := candHotCalleeMap[n]; ok {
                budget = int32(inlineHotMaxBudget)
                if base.Debug.PGOInline > 0 {
                    fmt.Printf("hot-node enabled increased budget=%v for func=%v\n", budget, ir.PkgFuncName(fn))
                }
            }
        }
    }

    // At this point in the game the function we're looking at may
    // have "stale" autos, vars that still appear in the Dcl list, but
    // which no longer have any uses in the function body (due to
    // elimination by deadcode). We'd like to exclude these dead vars
    // when creating the "Inline.Dcl" field below; to accomplish this,
    // the hairyVisitor below builds up a map of used/referenced
    // locals, and we use this map to produce a pruned Inline.Dcl
    // list. See issue 25249 for more context.

    visitor := hairyVisitor{
        curFunc:       fn,
        budget:        budget,
        maxBudget:     budget,
        extraCallCost: cc,
        profile:       profile,
    }
    if visitor.tooHairy(fn) {
        reason = visitor.reason
        return
    }

    n.Func.Inl = &ir.Inline{
        Cost: budget - visitor.budget,
        Dcl:  pruneUnusedAutos(n.Defn.(*ir.Func).Dcl, &visitor),
        Body: inlcopylist(fn.Body),

        CanDelayResults: canDelayResults(fn),
    }

    if base.Flag.LowerM > 1 {
        fmt.Printf("%v: can inline %v with cost %d as: %v { %v }\n", ir.Line(fn), n, budget-visitor.budget, fn.Type(), ir.Nodes(n.Func.Inl.Body))
    } else if base.Flag.LowerM != 0 {
        fmt.Printf("%v: can inline %v\n", ir.Line(fn), n)
    }
    if logopt.Enabled() {
        logopt.LogOpt(fn.Pos(), "canInlineFunction", "inline", ir.FuncName(fn), fmt.Sprintf("cost: %d", budget-visitor.budget))
    }
}

package main

// 使用递归
func fib(i int) int {
    if i < 2 {
        return i
    }
    return fib(i-1) + fib(i-2)
}

func main() {
    i := 10
    fib(i)
}

package main

// 全局变量
var a *int

func main() {
    // 局部变量
    b := 1
    // 引用变量b地址
    a = &b
}

package main

import "fmt"

// 闭包定义后被立即调用
func todo() {
    a := 1
    func() {
        fmt.Println(a)
        a = 2
    }()
}

func main() {
    todo()
}

package main

import "fmt"

func todo() {
    a := 1
    func1(&a)
    fmt.Println("aa:", a)
}

func func1(a *int) {
    fmt.Println(*a)
    *a = 2
}

func main() {
    todo()
}

v, ok := m["foo"]

tmp, ok := runtime.mapaccess2_fast64(typeOf(m), m, "foo")
v := *tmp

package main

import "fmt"

func main() {
    fmt.Println("hello word")
}