// Copyright 2013 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ir // This file implements the CREATE phase of IR construction. // See builder.go for explanation. import ( "fmt" "go/ast" "go/token" "go/types" "go/version" "os" "sync" "honnef.co/go/tools/go/types/typeutil" ) // measured on the standard library and rounded up to powers of two, // on average there are 8 blocks and 16 instructions per block in a // function. const avgBlocks = 8 const avgInstructionsPerBlock = 16 // NewProgram returns a new IR Program. // // mode controls diagnostics and checking during IR construction. func NewProgram(fset *token.FileSet, mode BuilderMode) *Program { prog := &Program{ Fset: fset, imported: make(map[string]*Package), packages: make(map[*types.Package]*Package), mode: mode, } h := typeutil.MakeHasher() // protected by methodsMu, in effect prog.methodSets.SetHasher(h) prog.canon.SetHasher(h) return prog } // memberFromObject populates package pkg with a member for the // typechecker object obj. // // For objects from Go source code, syntax is the associated syntax tree // (for funcs and vars only) and goversion defines the appropriate // interpretation; they will be used during the build phase. func memberFromObject(pkg *Package, obj types.Object, syntax ast.Node, goversion string) { name := obj.Name() switch obj := obj.(type) { case *types.Builtin: if pkg.Pkg != types.Unsafe { panic("unexpected builtin object: " + obj.String()) } case *types.TypeName: if name != "_" { pkg.Members[name] = &Type{ object: obj, pkg: pkg, } } case *types.Const: c := &NamedConst{ object: obj, Value: NewConst(obj.Val(), obj.Type(), syntax), pkg: pkg, } pkg.values[obj] = c.Value if name != "_" { pkg.Members[name] = c } case *types.Var: g := &Global{ Pkg: pkg, name: name, object: obj, typ: types.NewPointer(obj.Type()), // address } pkg.values[obj] = g if name != "_" { pkg.Members[name] = g } case *types.Func: sig := obj.Type().(*types.Signature) if sig.Recv() == nil && name == "init" { pkg.ninit++ name = fmt.Sprintf("init#%d", pkg.ninit) } fn := &Function{ name: name, object: obj, Signature: sig, Pkg: pkg, Prog: pkg.Prog, goversion: goversion, } fn.source = syntax fn.initHTML(pkg.printFunc) if syntax == nil { fn.Synthetic = SyntheticLoadedFromExportData } else { // Note: we initialize fn.Blocks in // (*builder).buildFunction and not here because Blocks // being nil is used to indicate that building of the // function hasn't started yet. fn.functionBody = &functionBody{ scratchInstructions: make([]Instruction, avgBlocks*avgInstructionsPerBlock), } } pkg.values[obj] = fn pkg.Functions = append(pkg.Functions, fn) if name != "_" && sig.Recv() == nil { pkg.Members[name] = fn // package-level function } default: // (incl. *types.Package) panic("unexpected Object type: " + obj.String()) } } // membersFromDecl populates package pkg with members for each // typechecker object (var, func, const or type) associated with the // specified decl. func membersFromDecl(pkg *Package, decl ast.Decl, goversion string) { switch decl := decl.(type) { case *ast.GenDecl: // import, const, type or var switch decl.Tok { case token.CONST: for _, spec := range decl.Specs { for _, id := range spec.(*ast.ValueSpec).Names { memberFromObject(pkg, pkg.info.Defs[id], nil, "") } } case token.VAR: for _, spec := range decl.Specs { for _, rhs := range spec.(*ast.ValueSpec).Values { pkg.initVersion[rhs] = goversion } for _, id := range spec.(*ast.ValueSpec).Names { memberFromObject(pkg, pkg.info.Defs[id], spec, goversion) } } case token.TYPE: for _, spec := range decl.Specs { id := spec.(*ast.TypeSpec).Name memberFromObject(pkg, pkg.info.Defs[id], nil, "") } } case *ast.FuncDecl: id := decl.Name obj, ok := pkg.info.Defs[id] if !ok { panic(fmt.Sprintf("couldn't find object for id %q at %s", id.Name, pkg.Prog.Fset.PositionFor(id.Pos(), false))) } if obj == nil { panic(fmt.Sprintf("found nil object for id %q at %s", id.Name, pkg.Prog.Fset.PositionFor(id.Pos(), false))) } memberFromObject(pkg, obj, decl, goversion) } } // CreatePackage constructs and returns an IR Package from the // specified type-checked, error-free file ASTs, and populates its // Members mapping. // // importable determines whether this package should be returned by a // subsequent call to ImportedPackage(pkg.Path()). // // The real work of building IR form for each function is not done // until a subsequent call to Package.Build(). func (prog *Program) CreatePackage(pkg *types.Package, files []*ast.File, info *types.Info, importable bool) *Package { p := &Package{ Prog: prog, Members: make(map[string]Member), values: make(map[types.Object]Value), Pkg: pkg, // transient values (CREATE and BUILD phases) info: info, files: files, printFunc: prog.PrintFunc, initVersion: make(map[ast.Expr]string), } // Add init() function. p.init = &Function{ name: "init", Signature: new(types.Signature), Synthetic: SyntheticPackageInitializer, Pkg: p, Prog: prog, functionBody: new(functionBody), goversion: "", // See Package.build for details. } p.init.initHTML(prog.PrintFunc) p.Members[p.init.name] = p.init p.Functions = append(p.Functions, p.init) // CREATE phase. // Allocate all package members: vars, funcs, consts and types. if len(files) > 0 { // Go source package. for _, file := range files { goversion := version.Lang(p.info.FileVersions[file]) for _, decl := range file.Decls { membersFromDecl(p, decl, goversion) } } } else { // GC-compiled binary package (or "unsafe") // No code. // No position information. scope := p.Pkg.Scope() for _, name := range scope.Names() { obj := scope.Lookup(name) memberFromObject(p, obj, nil, "") if obj, ok := obj.(*types.TypeName); ok { if named, ok := obj.Type().(*types.Named); ok { for i, n := 0, named.NumMethods(); i < n; i++ { memberFromObject(p, named.Method(i), nil, "") } } } } } // Add initializer guard variable. initguard := &Global{ Pkg: p, name: "init$guard", typ: types.NewPointer(tBool), } p.Members[initguard.Name()] = initguard if prog.mode&GlobalDebug != 0 { p.SetDebugMode(true) } if prog.mode&PrintPackages != 0 { printMu.Lock() p.WriteTo(os.Stdout) printMu.Unlock() } if importable { prog.imported[p.Pkg.Path()] = p } prog.packages[p.Pkg] = p return p } // printMu serializes printing of Packages/Functions to stdout. var printMu sync.Mutex // AllPackages returns a new slice containing all packages in the // program prog in unspecified order. func (prog *Program) AllPackages() []*Package { pkgs := make([]*Package, 0, len(prog.packages)) for _, pkg := range prog.packages { pkgs = append(pkgs, pkg) } return pkgs } // ImportedPackage returns the importable Package whose PkgPath // is path, or nil if no such Package has been created. // // A parameter to CreatePackage determines whether a package should be // considered importable. For example, no import declaration can resolve // to the ad-hoc main package created by 'go build foo.go'. // // TODO(adonovan): rethink this function and the "importable" concept; // most packages are importable. This function assumes that all // types.Package.Path values are unique within the ir.Program, which is // false---yet this function remains very convenient. // Clients should use (*Program).Package instead where possible. // IR doesn't really need a string-keyed map of packages. func (prog *Program) ImportedPackage(path string) *Package { return prog.imported[path] } func (prog *Program) SetNoReturn(fn func(*types.Func) bool) { prog.noReturn = fn }