llgo: Generate llvm.dbg.value calls

[axw]

Summary

This patch introduces calls to llvm.dbg.value for all local variables,
regardless of whether they are in memory or registers. We translate
go/ssa's DebugRef instructions directly, only where the target expression
is an identifier. go/ssa only generates DebugRef instructions for
referenced variables; the only local variables that may exist in a
function without being referenced are parameters, so we generate initial
calls for each decoded argument.

The "Debug Info Version" module flag has been bumped up to 2, to
match trunk LLVM's version.

We no longer emit source locations until the body has been entered.
This will cause debuggers to process the initial instructions when
breaking on the function.

[pcc]

This probably will not apply correctly after the changes I made in r224180. Would you mind updating and fixing any merge conflicts? Thanks.

debug/debug.go

97

The cwd changes seem unrelated. Can you move those to a separate revision, please?

irgen/ssa.go

888

Perhaps you want to check IsAddr to decide whether to emit an llvm.dbg.value here or not?

[axw]

Thanks for the review. I'll create a new revision when I've fixed it.

debug/debug.go

97

Note entirely unrelated, the metadata generated for files in getFile lacks directory names. I'll move it anyway, and keep this revision about DebugRefs.

irgen/ssa.go

888

Yes, thanks. This highlights another problem: if only the *address* of a local var is referenced, then only an address DebugRef gets generated. I'll need to rework this, since my assertions in the summary were wrong.

debug/debug.go

 //===----------------------------------------------------------------------===//
 
 package debug
 
 import (
   "debug/dwarf"
   "fmt"
   "go/token"
-  "os"
   "strings"
 
-  "llvm.org/llgo/third_party/go.tools/go/ssa"
   "llvm.org/llgo/third_party/go.tools/go/types"
   "llvm.org/llgo/third_party/go.tools/go/types/typeutil"
 
   "llvm.org/llvm/bindings/go/llvm"
 )
 
 const (
   // non-standard debug metadata tags
type DIBuilder struct {
   module     llvm.Module
   files      map[*token.File]llvm.Value
   cu, fn, lb llvm.Value
   fnFile     string
   debugScope []llvm.Value
   sizes      types.Sizes
   fset       *token.FileSet
   prefixMaps []PrefixMap
+  cwd        string
   types      typeutil.Map
   voidType   llvm.Value
 }
 
 // NewDIBuilder creates a new debug information builder.
-func NewDIBuilder(sizes types.Sizes, module llvm.Module, fset *token.FileSet, prefixMaps []PrefixMap) *DIBuilder {
+func NewDIBuilder(sizes types.Sizes, module llvm.Module, fset *token.FileSet, prefixMaps []PrefixMap, cwd string) *DIBuilder {
   var d DIBuilder
   d.module = module
   d.files = make(map[*token.File]llvm.Value)
   d.sizes = sizes
   d.fset = fset
   d.prefixMaps = prefixMaps
+  d.cwd = cwd
   d.builder = llvm.NewDIBuilder(d.module)
   d.cu = d.createCompileUnit()
   return &d
 }
 
 // Destroy destroys the DIBuilder.
 func (d *DIBuilder) Destroy() {
   d.builder.Destroy()
func (d *DIBuilder) remapFilePath(path string) string {
   }
   return path
 }
 
 func (d *DIBuilder) getFile(file *token.File) llvm.Value {
   if diFile := d.files[file]; !diFile.IsNil() {
     return diFile
   }
-  diFile := d.builder.CreateFile(d.remapFilePath(file.Name()), "")
+  diFile := d.builder.CreateFile(d.remapFilePath(file.Name()), d.cwd)
   d.files[file] = diFile
   return diFile
 }
 
 // createCompileUnit creates and returns debug metadata for the compile
 // unit as a whole, using the first file in the file set as a representative
 // (the choice of file is arbitrary).
 func (d *DIBuilder) createCompileUnit() llvm.Value {
   var file *token.File
   d.fset.Iterate(func(f *token.File) bool {
     file = f
     return false
   })
-  dir, err := os.Getwd()
-  if err != nil {
-    panic("could not get current directory: " + err.Error())
-  }
   return d.builder.CreateCompileUnit(llvm.DICompileUnit{
     Language: llvm.DW_LANG_Go,
     File:     d.remapFilePath(file.Name()),
-    Dir:      dir,
+    Dir:      d.cwd,
     Producer: "llgo",
   })
 }
 
 // PushFunction creates debug metadata for the specified function,
 // and pushes it onto the scope stack.
 func (d *DIBuilder) PushFunction(fnptr llvm.Value, sig *types.Signature, pos token.Pos) {
   var diFile llvm.Value
   var line int
   if file := d.fset.File(pos); file != nil {
     d.fnFile = file.Name()
     diFile = d.getFile(file)
     line = file.Line(pos)
   }
   d.fn = d.builder.CreateFunction(d.scope(), llvm.DIFunction{
     Name:         fnptr.Name(), // TODO(axw) unmangled name?
     LinkageName:  fnptr.Name(),
     File:         diFile,
     Line:         line,
     Type:         d.DIType(sig),
     IsDefinition: true,
     Function:     fnptr,
+    ScopeLine:    line,
   })
 }
 
 // PopFunction pops the previously pushed function off the scope stack.
 func (d *DIBuilder) PopFunction() {
   d.lb = llvm.Value{nil}
   d.fn = llvm.Value{nil}
   d.fnFile = ""
 }
 
-// Declare creates an llvm.dbg.declare call for the specified function
-// parameter or local variable.
-func (d *DIBuilder) Declare(b llvm.Builder, v ssa.Value, llv llvm.Value, paramIndex int) {
+// Value creates an llvm.dbg.value call, recording the current value for the
+// local variable with the specified name and source position.
+func (d *DIBuilder) Value(b llvm.Builder, name string, llv llvm.Value, t types.Type, pos token.Pos, paramIndex int) {
   tag := tagAutoVariable
   if paramIndex >= 0 {
     tag = tagArgVariable
   }
   var diFile llvm.Value
   var line int
-  if file := d.fset.File(v.Pos()); file != nil {
-    line = file.Line(v.Pos())
+  if file := d.fset.File(pos); file != nil {
+    line = file.Line(pos)
     diFile = d.getFile(file)
   }
   localVar := d.builder.CreateLocalVariable(d.scope(), llvm.DILocalVariable{
     Tag:   tag,
-    Name:  llv.Name(),
+    Name:  name,
     File:  diFile,
     Line:  line,
     ArgNo: paramIndex + 1,
-    Type:  d.DIType(v.Type()),
+    Type:  d.DIType(t),
   })
   expr := d.builder.CreateExpression(nil)
-  d.builder.InsertDeclareAtEnd(llv, localVar, expr, b.GetInsertBlock())
-}
-
-// Value creates an llvm.dbg.value call for the specified register value.
-func (d *DIBuilder) Value(b llvm.Builder, v ssa.Value, llv llvm.Value, paramIndex int) {
-  // TODO(axw)
+  d.builder.InsertValueAtEnd(llv, localVar, expr, 0, b.GetInsertBlock())
 }
 
 // SetLocation sets the current debug location.
 func (d *DIBuilder) SetLocation(b llvm.Builder, pos token.Pos) {
   if !pos.IsValid() {
     return
   }
   position := d.fset.Position(pos)
llvm.MDNode([]llvm.Value{
       llvm.ConstInt(llvm.Int32Type(), 4, false),
     }),
   )
   d.module.AddNamedMetadataOperand(
     "llvm.module.flags",
     llvm.MDNode([]llvm.Value{
       llvm.ConstInt(llvm.Int32Type(), 1, false), // Error on mismatch
       llvm.MDString("Debug Info Version"),
-      llvm.ConstInt(llvm.Int32Type(), 1, false),
+      llvm.ConstInt(llvm.Int32Type(), 2, false),
     }),
   )
   d.builder.Finalize()
 }
 
 // DIType maps a Go type to DIType debug metadata value.
 func (d *DIBuilder) DIType(t types.Type) llvm.Value {
   return d.typeDebugDescriptor(t, types.TypeString(nil, t))

irgen/compiler.go

 
 package irgen
 
 import (
   "bytes"
   "fmt"
   "go/token"
   "log"
+  "os"
   "sort"
   "strconv"
   "strings"
 
   llgobuild "llvm.org/llgo/build"
   "llvm.org/llgo/debug"
   "llvm.org/llvm/bindings/go/llvm"
 
func (compiler *compiler) compile(filenames []string, importpath string) (m *Module, err error) {
   impcfg.CreateFromFiles(importpath, astFiles...)
   iprog, err := impcfg.Load()
   if err != nil {
     return nil, err
   }
   program := ssa.Create(iprog, ssa.BareInits)
   mainPkginfo := iprog.InitialPackages()[0]
   mainPkg := program.CreatePackage(mainPkginfo)
+  mainPkg.SetDebugMode(compiler.GenerateDebug)
 
   // Create a Module, which contains the LLVM module.
   modulename := importpath
   compiler.module = &Module{Module: llvm.NewModule(modulename), Path: modulename}
   compiler.module.SetTarget(compiler.TargetTriple)
   compiler.module.SetDataLayout(compiler.dataLayout)
 
   // Create a new translation unit.
compiler.types = NewTypeMap(
     mainPkg,
     compiler.llvmtypes,
     compiler.module.Module,
     compiler.runtime,
     MethodResolver(unit),
   )
 
   if compiler.GenerateDebug {
+    cwd, err := os.Getwd()
+    if err != nil {
+      return nil, err
+    }
     compiler.debug = debug.NewDIBuilder(
       types.Sizes(compiler.llvmtypes),
       compiler.module.Module,
       impcfg.Fset,
       compiler.DebugPrefixMaps,
+      cwd,
     )
     defer compiler.debug.Destroy()
     defer compiler.debug.Finalize()
   }
 
   unit.translatePackage(mainPkg)
   compiler.processAnnotations(unit, mainPkginfo)
 

irgen/ssa.go

func (u *unit) defineFunction(f *ssa.Function) {
   fr.addCommonFunctionAttrs(fr.function)
   fr.function.SetLinkage(linkage)
 
   fr.logf("Define function: %s", f.String())
   fti := u.llvmtypes.getSignatureInfo(f.Signature)
   delete(u.undefinedFuncs, f)
   fr.retInf = fti.retInf
 
-  // Push the compile unit and function onto the debug context.
   if u.GenerateDebug {
     u.debug.PushFunction(fr.function, f.Signature, f.Pos())
     defer u.debug.PopFunction()
-    u.debug.SetLocation(fr.builder, f.Pos())
   }
 
   // If a function calls recover, we create a separate function to
   // hold the real function, and this function calls __go_can_recover
   // and bridges to it.
   if callsRecover(f) {
     fr = fr.bridgeRecoverFunc(fr.function, fti)
   }
 
   fr.blocks = make([]llvm.BasicBlock, len(f.Blocks))
   fr.lastBlocks = make([]llvm.BasicBlock, len(f.Blocks))
   for i, block := range f.Blocks {
     fr.blocks[i] = llvm.AddBasicBlock(fr.function, fmt.Sprintf(".%d.%s", i, block.Comment))
   }
   fr.builder.SetInsertPointAtEnd(fr.blocks[0])
 
   prologueBlock := llvm.InsertBasicBlock(fr.blocks[0], "prologue")
   fr.builder.SetInsertPointAtEnd(prologueBlock)
 
-  // Map parameter positions to indices. We use this
-  // when processing locals to map back to parameters
-  // when generating debug metadata.
-  paramPos := make(map[token.Pos]int)
+  // Decode parameters and generate initial llvm.dbg.value calls for each.
   for i, param := range f.Params {
-    paramPos[param.Pos()] = i
     llparam := fti.argInfos[i].decode(llvm.GlobalContext(), fr.builder, fr.builder)
     if isMethod && i == 0 {
       if _, ok := param.Type().Underlying().(*types.Pointer); !ok {
         llparam = fr.builder.CreateBitCast(llparam, llvm.PointerType(fr.types.ToLLVM(param.Type()), 0), "")
         llparam = fr.builder.CreateLoad(llparam, "")
       }
     }
     fr.env[param] = newValue(llparam, param.Type())
+    if fr.GenerateDebug {
+      fr.debug.Value(fr.builder, param.Name(), llparam, param.Type(), param.Pos(), i)
+    }
   }
 
   // Load closure, extract free vars.
   if len(f.FreeVars) > 0 {
     for _, fv := range f.FreeVars {
       fr.env[fv] = newValue(llvm.ConstNull(u.llvmtypes.ToLLVM(fv.Type())), fv.Type())
     }
     elemTypes := make([]llvm.Type, len(f.FreeVars)+1)
func (u *unit) defineFunction(f *ssa.Function) {
   // Allocate stack space for locals in the prologue block.
   for _, local := range f.Locals {
     typ := fr.llvmtypes.ToLLVM(deref(local.Type()))
     alloca := fr.builder.CreateAlloca(typ, local.Comment)
     fr.memsetZero(alloca, llvm.SizeOf(typ))
     bcalloca := fr.builder.CreateBitCast(alloca, llvm.PointerType(llvm.Int8Type(), 0), "")
     value := newValue(bcalloca, local.Type())
     fr.env[local] = value
-    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
func (fr *frame) createLandingPad(cleanup bool) llvm.Value {
   } else {
     lp.AddClause(llvm.ConstNull(llvm.PointerType(llvm.Int8Type(), 0)))
   }
   return lp
 }
 
 // Runs defers. If a defer panics, check for recovers in later defers.
 func (fr *frame) runDefers() {
+  if fr.frameptr.IsNil() {
+    // rundefers is emitted regardless of the presence of defers
+    // for SSA in naive form. If frameptr is nil, then there are
+    // no defers and no recovery block, so nothing to do.
+    return
+  }
+
   loopbb := llvm.AddBasicBlock(fr.function, "")
   fr.builder.CreateBr(loopbb)
 
   retrylpad := llvm.AddBasicBlock(fr.function, "")
   fr.builder.SetInsertPointAtEnd(retrylpad)
   fr.createLandingPad(false)
   fr.runtime.checkDefer.callOnly(fr, fr.frameptr)
   fr.builder.CreateBr(loopbb)
func (fr *frame) instruction(instr ssa.Instruction) {
   if fr.GenerateDebug {
     fr.debug.SetLocation(fr.builder, instr.Pos())
   }
 
   switch instr := instr.(type) {
   case *ssa.Alloc:
     typ := deref(instr.Type())
     llvmtyp := fr.llvmtypes.ToLLVM(typ)
-    var value llvm.Value
     if !instr.Heap {
-      value = fr.env[instr].value
+      value := fr.env[instr].value
       fr.memsetZero(value, llvm.SizeOf(llvmtyp))
     } else if fr.isInit && fr.shouldStaticallyAllocate(instr) {
       // If this is the init function and we think it may be beneficial,
       // allocate memory statically in the object file rather than on the
       // heap. This allows us to optimize constant stores into such
       // variables as static initializations.
       global := llvm.AddGlobal(fr.module.Module, llvmtyp, "")
       global.SetLinkage(llvm.InternalLinkage)
       fr.addGlobal(global, typ)
       ptr := llvm.ConstBitCast(global, llvm.PointerType(llvm.Int8Type(), 0))
       fr.env[instr] = newValue(ptr, instr.Type())
     } else {
-      value = fr.createTypeMalloc(typ)
+      value := fr.createTypeMalloc(typ)
       value.SetName(instr.Comment)
       value = fr.builder.CreateBitCast(value, llvm.PointerType(llvm.Int8Type(), 0), "")
       fr.env[instr] = newValue(value, instr.Type())
     }
 
   case *ssa.BinOp:
     lhs, rhs := fr.value(instr.X), fr.value(instr.Y)
     fr.env[instr] = fr.binaryOp(lhs, instr.Op, rhs)
if _, ok := instr.Type().Underlying().(*types.Pointer); ok {
       value = fr.builder.CreateBitCast(value, fr.llvmtypes.ToLLVM(instr.Type()), "")
     }
     fr.env[instr] = newValue(value, instr.Type())
 
   case *ssa.Convert:
     v := fr.value(instr.X)
     fr.env[instr] = fr.convert(v, instr.Type())
 
+  case *ssa.DebugRef:
+    id, ok := instr.Expr.(*ast.Ident)
+    if !ok || id.Obj == nil {
+      return
+    }
+    pos := id.Obj.Pos()
+    paramIndex := -1
+    for i, param := range instr.Parent().Params {
+      if pos == param.Pos() {
+        paramIndex = i
+        break
+      }
+    }
+    fr.debug.Value(fr.builder, id.Name, fr.llvmvalue(instr.X), instr.X.Type(), id.Obj.Pos(), paramIndex)
+
   case *ssa.Defer:
     fn, arg := fr.createThunk(instr)
     fr.runtime.Defer.call(fr, fr.frameptr, fn, arg)
 
   case *ssa.Extract:
     var elem llvm.Value
     if t, ok := fr.tuples[instr.Tuple]; ok {
       elem = t[instr.Index].value