internal/gocore: support for DWARF version 5 location lists

Rework the DWARF reading code to handle location lists in DWARF 5
format in addition to the existing DWARF 2/4 code.

Updates golang/go#26379.

Change-Id: I9d502f5bcecc752e4c1fe7cfaa9ff5871fe417de
Reviewed-on: https://go-review.googlesource.com/c/debug/+/654256
Reviewed-by: Junyang Shao <shaojunyang@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Michael Pratt <mpratt@google.com>

Author: thanm

internal/core/process.go

@@ -47,11 +47,13 @@ type Process struct {
 	memory    splicedMemory // virtual address mappings
 	pageTable pageTable4    // for fast address->mapping lookups
 
-	syms     map[string]Address // symbols (could be empty if executable is stripped)
-	symErr   error              // an error encountered while reading symbols
-	dwarf    *dwarf.Data        // debugging info (could be nil)
-	dwarfErr error              // an error encountered while reading DWARF
-	dwarfLoc []byte             // .debug_loc section
+	syms          map[string]Address // symbols (could be empty if executable is stripped)
+	symErr        error              // an error encountered while reading symbols
+	dwarf         *dwarf.Data        // debugging info (could be nil)
+	dwarfErr      error              // an error encountered while reading DWARF
+	dwarfLoc      []byte             // .debug_loc section
+	dwarfLocLists []byte             // .debug_loclists section
+	dwarfAddr     []byte             // .debug_addr section
 
 	warnings []string // warnings generated during loading
 }
@@ -181,6 +183,14 @@ func (p *Process) DWARFLoc() ([]byte, error) {
 	return p.dwarfLoc, p.dwarfErr
 }
 
+func (p *Process) DWARFLocLists() ([]byte, error) {
+	return p.dwarfLocLists, p.dwarfErr
+}
+
+func (p *Process) DWARFAddr() ([]byte, error) {
+	return p.dwarfAddr, p.dwarfErr
+}
+
 // Symbols returns a mapping from name to inferior address, along with
 // any error encountered during reading the symbol information.
 // (There may be both an error and some returned symbols.)
@@ -282,12 +292,27 @@ func Core(corePath, base, exePath string) (*Process, error) {
 	if dwarfErr != nil {
 		dwarfErr = fmt.Errorf("error reading DWARF info from %s: %v", exeFile.Name(), dwarfErr)
 	}
-	var dwarfLoc []byte
-	if locSection := exeElf.Section(".debug_loc"); locSection != nil {
-		var err error
-		dwarfLoc, err = locSection.Data()
-		if err != nil && dwarfErr == nil {
-			dwarfErr = fmt.Errorf("error reading DWARF location list section from %s: %v", exeFile.Name(), err)
+
+	// Note that we expect to find .debug_loc for DWARF V4 binaries
+	// and .debug_loclists + .debug_addr for DWARF V5.  If C code is
+	// mixed in, we may see both sections, since you're allowed to mix
+	// different DWARF versions by compilation unit.
+	var dwarfLoc, dwarfLocLists, dwarfAddr []byte
+	toRead := []struct {
+		name    string
+		payload *[]byte
+	}{
+		{name: ".debug_loc", payload: &dwarfLoc},
+		{name: ".debug_loclists", payload: &dwarfLocLists},
+		{name: ".debug_addr", payload: &dwarfAddr},
+	}
+	for _, secitem := range toRead {
+		if section := exeElf.Section(secitem.name); section != nil {
+			payload, err := section.Data()
+			if err != nil && dwarfErr == nil {
+				dwarfErr = fmt.Errorf("error reading DWARF %s section from %s: %v", secitem.name, exeFile.Name(), err)
+			}
+			*(secitem.payload) = payload
 		}
 	}
 
@@ -368,19 +393,21 @@ func Core(corePath, base, exePath string) (*Process, error) {
 	}
 
 	p := &Process{
-		meta:       meta,
-		entryPoint: entryPoint,
-		staticBase: staticBase,
-		args:       args,
-		threads:    threads,
-		memory:     mem,
-		pageTable:  pageTable,
-		syms:       syms,
-		symErr:     symErr,
-		dwarf:      dwarf,
-		dwarfErr:   dwarfErr,
-		dwarfLoc:   dwarfLoc,
-		warnings:   warnings,
+		meta:          meta,
+		entryPoint:    entryPoint,
+		staticBase:    staticBase,
+		args:          args,
+		threads:       threads,
+		memory:        mem,
+		pageTable:     pageTable,
+		syms:          syms,
+		symErr:        symErr,
+		dwarf:         dwarf,
+		dwarfErr:      dwarfErr,
+		dwarfLoc:      dwarfLoc,
+		dwarfLocLists: dwarfLocLists,
+		dwarfAddr:     dwarfAddr,
+		warnings:      warnings,
 	}
 
 	return p, nil

internal/gocore/dwarf.go

@@ -14,6 +14,7 @@ import (
 	"golang.org/x/debug/dwtest"
 	"golang.org/x/debug/internal/core"
 
+	"golang.org/x/debug/third_party/delve/dwarf/godwarf"
 	"golang.org/x/debug/third_party/delve/dwarf/loclist"
 	"golang.org/x/debug/third_party/delve/dwarf/op"
 	"golang.org/x/debug/third_party/delve/dwarf/regnum"
@@ -386,15 +387,40 @@ func readDWARFVars(p *core.Process, fns *funcTab, dwarfTypeMap map[dwarf.Type]*T
 	if err != nil {
 		return nil, fmt.Errorf("failed to read DWARF: %v", err)
 	}
+	dLocListsSec, derr := p.DWARFLocLists()
+	if derr != nil {
+		return nil, fmt.Errorf("failed to read DWARF: %v", derr)
+	}
+	dAddrSec, daerr := p.DWARFAddr()
+	if daerr != nil {
+		return nil, fmt.Errorf("failed to read DWARF: %v", daerr)
+	}
+	debugAddrSec := godwarf.ParseAddr(dAddrSec)
 	vars := make(map[*Func][]dwarfVar)
 	var curfn *Func
 	r := d.Reader()
+	addrBase := uint64(0)
+	unitVersion := 4
 	for e, err := r.Next(); e != nil && err == nil; e, err = r.Next() {
 		if isNonGoCU(e) {
 			r.SkipChildren()
 			continue
 		}
-
+		if e.Tag == dwarf.TagCompileUnit {
+			// Determine whether we're looking at DWARF version 5 or
+			// some version prior to 5.  At the moment the DWARF
+			// reading machinery in debug/dwarf keeps track of DWARF
+			// version for each unit but doesn't expose this info to
+			// clients, so we need to do the detection indirectly,
+			// here by looking for an attribute that only gets generated
+			// if DWARF 5 is being used.
+			if f := e.AttrField(dwarf.AttrAddrBase); f != nil {
+				addrBase = uint64(f.Val.(int64))
+				unitVersion = 5
+			} else {
+				unitVersion = 4
+			}
+		}
 		if e.Tag == dwarf.TagSubprogram {
 			if e.AttrField(dwarf.AttrLowpc) == nil ||
 				e.AttrField(dwarf.AttrHighpc) == nil {
@@ -459,30 +485,74 @@ func readDWARFVars(p *core.Process, fns *funcTab, dwarfTypeMap map[dwarf.Type]*T
 		}
 		name := nf.Val.(string)
 
-		// No .debug_loc section, can't make progress.
-		if len(dLocSec) == 0 {
-			continue
-		}
+		// FIXME A note on the code above: we're screening out
+		// variables that don't have a specific name and type, which
+		// on the surface seems workable, however this also rejects
+		// vars corresponding to "concrete" instances of vars that
+		// have been inlined, which is almost certainly a mistake. For
+		// more on concrete/abstract variables see
+		// https://github.com/golang/proposal/blob/master/design/22080-dwarf-inlining.md#how-the-generated-dwarf-should-look,
+		// which has examples.  Instead what the code above should be
+		// doing is caching any abstract variables it encounters in a
+		// map (indexed by DWARF offset), then when it encounters a
+		// concrete var, pick the name and type up from the abstract
+		// variable.
+
+		switch unitVersion {
+		case 5:
+			{
+				// No .debug_loclists section, can't make progress.
+				if len(dLocListsSec) == 0 {
+					continue
+				}
 
-		// Read the location list.
-		locListOff := aloc.Val.(int64)
-		dr := loclist.NewDwarf2Reader(dLocSec, int(p.PtrSize()))
-		dr.Seek(int(locListOff))
-		var base uint64
-		var e loclist.Entry
-		for dr.Next(&e) {
-			if e.BaseAddressSelection() {
-				base = e.HighPC + p.StaticBase()
-				continue
+				debugAddr := debugAddrSec.GetSubsection(addrBase)
+				// Read the location lists.
+				locListOff := aloc.Val.(int64)
+				dr := loclist.NewDwarf5Reader(dLocListsSec)
+				elist, err := dr.Enumerate(locListOff, p.StaticBase(), debugAddr)
+				if err != nil {
+					return nil, err
+				}
+				for _, e := range elist {
+					vars[curfn] = append(vars[curfn], dwarfVar{
+						lowPC:  core.Address(e.LowPC),
+						highPC: core.Address(e.HighPC),
+						kind:   kind,
+						instr:  e.Instr,
+						name:   name,
+						typ:    dwarfTypeMap[dt],
+					})
+				}
+			}
+		default:
+			{
+				// No .debug_loc section, can't make progress.
+				if len(dLocSec) == 0 {
+					continue
+				}
+
+				// Read the location list.
+				locListOff := aloc.Val.(int64)
+				dr := loclist.NewDwarf2Reader(dLocSec, int(p.PtrSize()))
+				dr.Seek(int(locListOff))
+				var base uint64
+				var e loclist.Entry
+				for dr.Next(&e) {
+					if e.BaseAddressSelection() {
+						base = e.HighPC + p.StaticBase()
+						continue
+					}
+					vars[curfn] = append(vars[curfn], dwarfVar{
+						lowPC:  core.Address(e.LowPC + base),
+						highPC: core.Address(e.HighPC + base),
+						kind:   kind,
+						instr:  e.Instr,
+						name:   name,
+						typ:    dwarfTypeMap[dt],
+					})
+				}
 			}
-			vars[curfn] = append(vars[curfn], dwarfVar{
-				lowPC:  core.Address(e.LowPC + base),
-				highPC: core.Address(e.HighPC + base),
-				kind:   kind,
-				instr:  e.Instr,
-				name:   name,
-				typ:    dwarfTypeMap[dt],
-			})
 		}
 	}
 	return vars, nil