[llgo] irgen: make it possible to use a custom importer

[axw]

LGTM, with a couple of minor suggestions.

irgen/compiler.go

89 ↗

(On Diff #17688)

If *Importer* is nil, the compiler will set this field automatically using MakeImporter(). If Importer is non-nil, InitMap must be non-nil also (I think?)

161 ↗

(On Diff #17688)

A brief comment may be useful here, describing the interaction with GccgoPath.

[pcc]

irgen/compiler.go

89 ↗

(On Diff #17688)

Yes, done.

161 ↗

(On Diff #17688)

Done.

llgo/trunk/irgen/compiler.go

 // This file implements the main IR generator entry point, (*Compiler).Compile.
 //
 //===----------------------------------------------------------------------===//
 
 package irgen
 
 import (
   "bytes"
-  "fmt"
   "go/ast"
   "go/token"
   "log"
   "sort"
   "strconv"
   "strings"
 
   llgobuild "llvm.org/llgo/build"
type CompilerOptions struct {
   GccgoPath string
 
   // ImportPaths is the list of additional import paths
   ImportPaths []string
 
   // SanitizerAttribute is an attribute to apply to functions to enable
   // dynamic instrumentation using a sanitizer.
   SanitizerAttribute llvm.Attribute
+
+  // Importer is the importer. If nil, the compiler will set this field
+  // automatically using MakeImporter().
+  Importer types.Importer
+
+  // InitMap is the init map used by Importer. If Importer is nil, the
+  // compiler will set this field automatically using MakeImporter().
+  // If Importer is non-nil, InitMap must be non-nil also.
+  InitMap map[*types.Package]gccgoimporter.InitData
 }
 
 type Compiler struct {
   opts       CompilerOptions
   dataLayout string
   pnacl      bool
 }
 

 func (c *compiler) addCommonFunctionAttrs(fn llvm.Value) {
   fn.AddTargetDependentFunctionAttr("disable-tail-calls", "true")
   fn.AddTargetDependentFunctionAttr("split-stack", "")
   if attr := c.SanitizerAttribute; attr != 0 {
     fn.AddFunctionAttr(attr)
   }
 }
 
+// MakeImporter sets CompilerOptions.Importer to an appropriate importer
+// for the search paths given in CompilerOptions.ImportPaths, and sets
+// CompilerOptions.InitMap to an init map belonging to that importer.
+// If CompilerOptions.GccgoPath is non-empty, the importer will also use
+// the search paths for that gccgo installation.
+func (opts *CompilerOptions) MakeImporter() error {
+  opts.InitMap = make(map[*types.Package]gccgoimporter.InitData)
+  if opts.GccgoPath == "" {
+    paths := append(append([]string{}, opts.ImportPaths...), ".")
+    opts.Importer = gccgoimporter.GetImporter(paths, opts.InitMap)
+  } else {
+    var inst gccgoimporter.GccgoInstallation
+    err := inst.InitFromDriver(opts.GccgoPath)
+    if err != nil {
+      return err
+    }
+    opts.Importer = inst.GetImporter(opts.ImportPaths, opts.InitMap)
+  }
+  return nil
+}
+
 func (compiler *compiler) compile(fset *token.FileSet, astFiles []*ast.File, importpath string) (m *Module, err error) {
   buildctx, err := llgobuild.ContextFromTriple(compiler.TargetTriple)
   if err != nil {
     return nil, err
   }
 
-  initmap := make(map[*types.Package]gccgoimporter.InitData)
-  var importer types.Importer
-  if compiler.GccgoPath == "" {
-    paths := append(append([]string{}, compiler.ImportPaths...), ".")
-    importer = gccgoimporter.GetImporter(paths, initmap)
-  } else {
-    var inst gccgoimporter.GccgoInstallation
-    err = inst.InitFromDriver(compiler.GccgoPath)
+  if compiler.Importer == nil {
+    err = compiler.MakeImporter()
     if err != nil {
       return nil, err
     }
-    importer = inst.GetImporter(compiler.ImportPaths, initmap)
   }
 
   impcfg := &loader.Config{
     Fset: fset,
     TypeChecker: types.Config{
-      Import: importer,
+      Import: compiler.Importer,
       Sizes:  compiler.llvmtypes,
     },
     Build: &buildctx.Context,
   }
   // If no import path is specified, then set the import
   // path to be the same as the package's name.
   if importpath == "" {
     importpath = astFiles[0].Name.String()
if compiler.GenerateDebug {
     defer compiler.debug.Destroy()
     defer compiler.debug.Finalize()
   }
 
   unit.translatePackage(mainPkg)
   compiler.processAnnotations(unit, mainPkginfo)
 
   if importpath == "main" {
-    if err = compiler.createInitMainFunction(mainPkg, initmap); err != nil {
-      return nil, fmt.Errorf("failed to create __go_init_main: %v", err)
-    }
+    compiler.createInitMainFunction(mainPkg)
   } else {
-    compiler.module.ExportData = compiler.buildExportData(mainPkg, initmap)
+    compiler.module.ExportData = compiler.buildExportData(mainPkg)
   }
 
   return compiler.module, nil
 }
 
 type byPriorityThenFunc []gccgoimporter.PackageInit
 
 func (a byPriorityThenFunc) Len() int      { return len(a) }
 func (a byPriorityThenFunc) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
 func (a byPriorityThenFunc) Less(i, j int) bool {
   switch {
   case a[i].Priority < a[j].Priority:
     return true
   case a[i].Priority > a[j].Priority:
     return false
   case a[i].InitFunc < a[j].InitFunc:
     return true
   default:
     return false
   }
 }
 
-func (c *compiler) buildPackageInitData(mainPkg *ssa.Package, initmap map[*types.Package]gccgoimporter.InitData) gccgoimporter.InitData {
+func (c *compiler) buildPackageInitData(mainPkg *ssa.Package) gccgoimporter.InitData {
   var inits []gccgoimporter.PackageInit
   for _, imp := range mainPkg.Object.Imports() {
-    inits = append(inits, initmap[imp].Inits...)
+    inits = append(inits, c.InitMap[imp].Inits...)
   }
   sort.Sort(byPriorityThenFunc(inits))
 
   // Deduplicate init entries. We want to preserve the entry with the highest priority.
   // Normally a package's priorities will be consistent among its dependencies, but it is
   // possible for them to be different. For example, if a standard library test augments a
   // package which is a dependency of 'regexp' (which is imported by every test main package)
   // with additional dependencies, those dependencies may cause the package under test to
func (c *compiler) buildPackageInitData(mainPkg *ssa.Package) gccgoimporter.InitData {
   if imp := mainPkg.Func("init"); imp != nil {
     impname := c.types.mc.mangleFunctionName(imp)
     uniqinits = append(uniqinits, gccgoimporter.PackageInit{mainPkg.Object.Name(), impname, ourprio})
   }
 
   return gccgoimporter.InitData{ourprio, uniqinits}
 }
 
-func (c *compiler) createInitMainFunction(mainPkg *ssa.Package, initmap map[*types.Package]gccgoimporter.InitData) error {
-  initdata := c.buildPackageInitData(mainPkg, initmap)
+func (c *compiler) createInitMainFunction(mainPkg *ssa.Package) {
+  initdata := c.buildPackageInitData(mainPkg)
 
   ftyp := llvm.FunctionType(llvm.VoidType(), nil, false)
   initMain := llvm.AddFunction(c.module.Module, "__go_init_main", ftyp)
   c.addCommonFunctionAttrs(initMain)
   entry := llvm.AddBasicBlock(initMain, "entry")
 
   builder := llvm.GlobalContext().NewBuilder()
   defer builder.Dispose()
   builder.SetInsertPointAtEnd(entry)
 
   for _, init := range initdata.Inits {
     initfn := c.module.Module.NamedFunction(init.InitFunc)
     if initfn.IsNil() {
       initfn = llvm.AddFunction(c.module.Module, init.InitFunc, ftyp)
     }
     builder.CreateCall(initfn, nil, "")
   }
 
   builder.CreateRetVoid()
-  return nil
 }
 
-func (c *compiler) buildExportData(mainPkg *ssa.Package, initmap map[*types.Package]gccgoimporter.InitData) []byte {
+func (c *compiler) buildExportData(mainPkg *ssa.Package) []byte {
   exportData := importer.ExportData(mainPkg.Object)
   b := bytes.NewBuffer(exportData)
 
-  initdata := c.buildPackageInitData(mainPkg, initmap)
+  initdata := c.buildPackageInitData(mainPkg)
   b.WriteString("v1;\npriority ")
   b.WriteString(strconv.Itoa(initdata.Priority))
   b.WriteString(";\n")
 
   if len(initdata.Inits) != 0 {
     b.WriteString("init")
     for _, init := range initdata.Inits {
       b.WriteRune(' ')