[llgo] irgen: modify the ABI to use init guards instead of priority

[pcc]

Summary

The new ABI is simpler for use cases such as dynamically loaded packages.

The calling convention for import functions is similar to what go/ssa would
produce if BareInits were cleared. However, simply clearing this flag causes
two additional issues:

1. We would need to special case the 'init$guard' variable (see discussion in https://codereview.appspot.com/78780043/).
2. The call to __go_register_gc_roots needs to appear in the right place, i.e. after the guard check. Making this check appear in the right place with non-bare inits seems unreliable at best.

So we keep BareInits set and generate the necessary code manually.

It is still possible to get the old ABI by specifying a path to a gccgo
installation.

[axw]

irgen/ssa.go

429 ↗

(On Diff #17689)

Would you mind moving this code to a separate function? defineFunction is getting a bit long.

[pcc]

irgen/ssa.go

429 ↗

(On Diff #17689)

Done.

llgo/trunk/cmd/gllgo/gllgo.go

if opts.prefix != "" {
     importPaths = append(importPaths, filepath.Join(opts.prefix, "lib"+LibDirSuffix, "go", "llgo-"+llvmVersion()))
   }
   copts := irgen.CompilerOptions{
     TargetTriple:       opts.triple,
     GenerateDebug:      opts.generateDebug,
     DebugPrefixMaps:    opts.debugPrefixMaps,
     DumpSSA:            opts.dumpSSA,
     GccgoPath:          opts.gccgoPath,
+    GccgoABI:           opts.gccgoPath != "",
     ImportPaths:        importPaths,
     SanitizerAttribute: opts.sanitizer.getAttribute(),
   }
   if opts.dumpTrace {
     copts.Logger = log.New(os.Stderr, "", 0)
   }
   return irgen.NewCompiler(copts)
 }

llgo/trunk/irgen/compiler.go

type CompilerOptions struct {
   // to stderr before generating code for it.
   DumpSSA bool
 
   // GccgoPath is the path to the gccgo binary whose libgo we read import
   // data from. If blank, the caller is expected to supply an import
   // path in ImportPaths.
   GccgoPath string
 
+  // Whether to use the gccgo ABI.
+  GccgoABI bool
+
   // 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
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) {
-  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)
 
+  if !c.GccgoABI {
+    initfn := c.module.Module.NamedFunction("main..import")
+    if !initfn.IsNil() {
+      builder.CreateCall(initfn, nil, "")
+    }
+    builder.CreateRetVoid()
+    return
+  }
+
+  initdata := c.buildPackageInitData(mainPkg)
+
   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()
 }
 
 func (c *compiler) buildExportData(mainPkg *ssa.Package) []byte {
   exportData := importer.ExportData(mainPkg.Object)
   b := bytes.NewBuffer(exportData)
 
+  b.WriteString("v1;\n")
+  if !c.GccgoABI {
+    return b.Bytes()
+  }
+
   initdata := c.buildPackageInitData(mainPkg)
-  b.WriteString("v1;\npriority ")
+  b.WriteString("priority ")
   b.WriteString(strconv.Itoa(initdata.Priority))
   b.WriteString(";\n")
 
   if len(initdata.Inits) != 0 {
     b.WriteString("init")
     for _, init := range initdata.Inits {
       b.WriteRune(' ')
       b.WriteString(init.Name)

llgo/trunk/irgen/ssa.go

if fr.GenerateDebug {
       paramIndex, ok := paramPos[local.Pos()]
       if !ok {
         paramIndex = -1
       }
       fr.debug.Declare(fr.builder, local, alloca, paramIndex)
     }
   }
 
-  // If this is the "init" function, enable init-specific optimizations.
-  if !isMethod && f.Name() == "init" {
-    fr.isInit = true
-  }
-
   // If the function contains any defers, we must first create
   // an unwind block. We can short-circuit the check for defers with
   // f.Recover != nil.
   if f.Recover != nil || hasDefer(f) {
     fr.unwindBlock = llvm.AddBasicBlock(fr.function, "")
     fr.frameptr = fr.builder.CreateAlloca(llvm.Int8Type(), "")
   }
 
-  term := fr.builder.CreateBr(fr.blocks[0])
-  fr.allocaBuilder.SetInsertPointBefore(term)
+  // Keep track of the block into which we need to insert the call
+  // to __go_register_gc_roots. This needs to be inserted after the
+  // init guard check under the llgo ABI.
+  var registerGcBlock llvm.BasicBlock
+
+  // If this is the "init" function, emit the init guard check and
+  // enable init-specific optimizations.
+  if !isMethod && f.Name() == "init" {
+    registerGcBlock = fr.emitInitPrologue()
+    fr.isInit = true
+  }
+
+  fr.builder.CreateBr(fr.blocks[0])
+  fr.allocaBuilder.SetInsertPointBefore(prologueBlock.FirstInstruction())
 
   for _, block := range f.DomPreorder() {
     fr.translateBlock(block, fr.blocks[block.Index])
   }
 
   fr.fixupPhis()
 
   if !fr.unwindBlock.IsNil() {
     fr.setupUnwindBlock(f.Recover, f.Signature.Results())
   }
 
   // The init function needs to register the GC roots first. We do this
   // after generating code for it because allocations may have caused
   // additional GC roots to be created.
   if fr.isInit {
-    fr.builder.SetInsertPointBefore(prologueBlock.FirstInstruction())
+    fr.builder.SetInsertPointBefore(registerGcBlock.FirstInstruction())
     fr.registerGcRoots()
   }
 }
 
 type pendingPhi struct {
   ssa  *ssa.Phi
   llvm llvm.Value
 }
func newFrame(u *unit, fn llvm.Value) *frame {
   }
 }
 
 func (fr *frame) dispose() {
   fr.builder.Dispose()
   fr.allocaBuilder.Dispose()
 }
 
+// emitInitPrologue emits the init-specific function prologue (guard check and
+// initialization of dependent packages under the llgo native ABI), and returns
+// the basic block into which the GC registration call should be emitted.
+func (fr *frame) emitInitPrologue() llvm.BasicBlock {
+  if fr.GccgoABI {
+    return fr.builder.GetInsertBlock()
+  }
+
+  initGuard := llvm.AddGlobal(fr.module.Module, llvm.Int1Type(), "init$guard")
+  initGuard.SetLinkage(llvm.InternalLinkage)
+  initGuard.SetInitializer(llvm.ConstNull(llvm.Int1Type()))
+
+  returnBlock := llvm.AddBasicBlock(fr.function, "")
+  initBlock := llvm.AddBasicBlock(fr.function, "")
+
+  initGuardVal := fr.builder.CreateLoad(initGuard, "")
+  fr.builder.CreateCondBr(initGuardVal, returnBlock, initBlock)
+
+  fr.builder.SetInsertPointAtEnd(returnBlock)
+  fr.builder.CreateRetVoid()
+
+  fr.builder.SetInsertPointAtEnd(initBlock)
+  fr.builder.CreateStore(llvm.ConstInt(llvm.Int1Type(), 1, false), initGuard)
+  ftyp := llvm.FunctionType(llvm.VoidType(), nil, false)
+  for _, pkg := range fr.pkg.Object.Imports() {
+    initname := ManglePackagePath(pkg.Path()) + "..import"
+    initfn := fr.module.Module.NamedFunction(initname)
+    if initfn.IsNil() {
+      initfn = llvm.AddFunction(fr.module.Module, initname, ftyp)
+    }
+    fr.builder.CreateCall(initfn, nil, "")
+  }
+
+  return initBlock
+}
+
 // bridgeRecoverFunc creates a function that may call recover(), and creates
 // a call to it from the current frame. The created function will be called
 // with a boolean parameter that indicates whether it may call recover().
 //
 // The created function will have the same name as the current frame's function
 // with "$recover" appended, having the same return types and parameters with
 // an additional boolean parameter appended.
 //

llgo/trunk/test/irgen/imports.go

+// RUN: llgo -S -emit-llvm -o - %s | FileCheck %s
+
+package foo
+
+import _ "fmt"
+
+var X interface{}
+
+// CHECK: @"init$guard" = internal global i1 false
+
+// CHECK: define void @foo..import()
+// CHECK-NEXT: :
+// CHECK-NEXT: %[[N:.*]] = load i1* @"init$guard"
+// CHECK-NEXT: br i1 %[[N]], label %{{.*}}, label %[[L:.*]]
+
+// CHECK: ; <label>:[[L]]
+// CHECK-NEXT: call void @__go_register_gc_roots
+// CHECK-NEXT: store i1 true, i1* @"init$guard"
+// CHECK-NEXT: call void @fmt..import()
+// CHECK-NEXT: br label