cmd: initial compiler+linker support for DWARF5 .debug_addr

This patch rolls the main .debug_info DWARF section from version 4 to
version 5, and also introduces machinery in the Go compiler and linker
for taking advantage of the DWARF5 ".debug_addr" section for
subprogram DIE "high" and "low" PC attributes. All functionality is
gated by GOEXPERIMENT=dwarf5.

For the compiler portion of this patch, we add a new DIE attribute
form "DW_FORM_addrx", which accepts as an argument a function (text)
symbol.  The dwarf "putattr" function is enhanced to handle this
format by invoking a new dwarf context method "AddIndirectTextRef".
Under the hood, this method invokes the Lsym method WriteDwTxtAddrx,
which emits a new objabi.R_DWTXTADDR_* relocation. The size of the
relocation is dependent on the number of functions in the package; we
pick a size that is just big enough for the largest func index.

In the linker portion of this patch, we now switch over to writing out
a version number of 5 (instead of 4) in the compile unit header (this
is required if we want to use addrx attributes). In the parallel portion
of DWARF gen, within each compilation unit we scan subprogram DIEs to
look for R_DWTXTADDR_* relocations, and when we find such a reloc,
we assign a slot in the .debug_addr section for the func targeted.
After the parallel portion is complete, we then walk through all of the
compilation units to assign a value to their DW_AT_addr_base attribute,
which points to the portion of the single .debug_addr section containing
the text addrs for that compilation unit.

Note that once this patch is in, programs built with GOEXPERIMENT=dwarf5
will have broken/damaged DWARF info; in particular, since we've changed
only the CU and subprogram DIEs and haven't incorported the other
changes mandated by DWARF5 (ex: .debug_ranges => .debug_rnglists)
a lot of the variable location info will be missing/incorrect. This
will obviously change in subsequent patches.

Note also that R_DWTXTADDR_* can't be used effectively for lexical
scope DIE hi/lo PC attrs, since there isn't a viable way to encode
"addrx + constant" in the attribute value (you would need a new entry
for each attr endpoint in .debug_addr, which would defeat the point).

Updates #26379.

Change-Id: I2dfc45c9a8333e7b2a58f8e3b88fc8701fefd006
Reviewed-on: https://go-review.googlesource.com/c/go/+/635337
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>

Author: thanm

src/cmd/compile/internal/gc/compile.go

@@ -114,6 +114,8 @@ func prepareFunc(fn *ir.Func) {
 	ir.CurFunc = fn
 	walk.Walk(fn)
 	ir.CurFunc = nil // enforce no further uses of CurFunc
+
+	base.Ctxt.DwTextCount++
 }
 
 // compileFunctions compiles all functions in compilequeue.

src/cmd/internal/dwarf/dwarf.go

@@ -198,6 +198,7 @@ type Context interface {
 	AddCURelativeAddress(s Sym, t interface{}, ofs int64)
 	AddSectionOffset(s Sym, size int, t interface{}, ofs int64)
 	AddDWARFAddrSectionOffset(s Sym, t interface{}, ofs int64)
+	AddIndirectTextRef(s Sym, t interface{})
 	CurrentOffset(s Sym) int64
 	RecordDclReference(from Sym, to Sym, dclIdx int, inlIndex int)
 	RecordChildDieOffsets(s Sym, vars []*Var, offsets []int32)
@@ -368,21 +369,35 @@ type dwAbbrev struct {
 var abbrevsFinalized bool
 
 // expandPseudoForm takes an input DW_FORM_xxx value and translates it
-// into a platform-appropriate concrete form. Existing concrete/real
-// DW_FORM values are left untouched. For the moment the only
-// pseudo-form is DW_FORM_udata_pseudo, which gets expanded to
-// DW_FORM_data4 on Darwin and DW_FORM_udata everywhere else. See
-// issue #31459 for more context.
+// into a version- and platform-appropriate concrete form. Existing
+// concrete/real DW_FORM values are left untouched. For the moment the
+// only platform-specific pseudo-form is DW_FORM_udata_pseudo, which
+// gets expanded to DW_FORM_data4 on Darwin and DW_FORM_udata
+// everywhere else. See issue #31459 for more context. Then we have a
+// pair of pseudo-forms for lo and hi PC attributes, which are
+// expanded differently depending on whether we're generating DWARF
+// version 4 or 5.
 func expandPseudoForm(form uint8) uint8 {
-	// Is this a pseudo-form?
-	if form != DW_FORM_udata_pseudo {
+	switch form {
+	case DW_FORM_udata_pseudo:
+		expandedForm := DW_FORM_udata
+		if buildcfg.GOOS == "darwin" || buildcfg.GOOS == "ios" {
+			expandedForm = DW_FORM_data4
+		}
+		return uint8(expandedForm)
+	case DW_FORM_lo_pc_pseudo:
+		if buildcfg.Experiment.Dwarf5 {
+			return DW_FORM_addrx
+		}
+		return DW_FORM_addr
+	case DW_FORM_hi_pc_pseudo:
+		if buildcfg.Experiment.Dwarf5 {
+			return DW_FORM_udata
+		}
+		return DW_FORM_addr
+	default:
 		return form
 	}
-	expandedForm := DW_FORM_udata
-	if buildcfg.GOOS == "darwin" || buildcfg.GOOS == "ios" {
-		expandedForm = DW_FORM_data4
-	}
-	return uint8(expandedForm)
 }
 
 // Abbrevs returns the finalized abbrev array for the platform,
@@ -397,6 +412,25 @@ func Abbrevs() []dwAbbrev {
 			abbrevs[i].attr[j].form = expandPseudoForm(abbrevs[i].attr[j].form)
 		}
 	}
+	if buildcfg.Experiment.Dwarf5 {
+		// Tack on a new DW_AT_addr_base attribute to the compunit DIE,
+		// which will point to the offset in the .debug_addr section
+		// containing entries for this comp unit (this attr gets
+		// fixed up in the linker).
+		for i := 1; i < len(abbrevs); i++ {
+			haveLo := false
+			for j := 0; j < len(abbrevs[i].attr); j++ {
+				if abbrevs[i].attr[j].attr == DW_AT_low_pc {
+					haveLo = true
+				}
+			}
+			if abbrevs[i].tag == DW_TAG_compile_unit && haveLo {
+				abbrevs[i].attr = append(abbrevs[i].attr,
+					dwAttrForm{DW_AT_addr_base, DW_FORM_sec_offset})
+			}
+		}
+	}
+
 	abbrevsFinalized = true
 	return abbrevs
 }
@@ -422,6 +456,7 @@ var abbrevs = []dwAbbrev{
 			{DW_AT_comp_dir, DW_FORM_string},
 			{DW_AT_producer, DW_FORM_string},
 			{DW_AT_go_package_name, DW_FORM_string},
+			// NB: DWARF5 adds DW_AT_addr_base here.
 		},
 	},
 
@@ -444,8 +479,8 @@ var abbrevs = []dwAbbrev{
 		DW_CHILDREN_yes,
 		[]dwAttrForm{
 			{DW_AT_name, DW_FORM_string},
-			{DW_AT_low_pc, DW_FORM_addr},
-			{DW_AT_high_pc, DW_FORM_addr},
+			{DW_AT_low_pc, DW_FORM_lo_pc_pseudo},
+			{DW_AT_high_pc, DW_FORM_hi_pc_pseudo},
 			{DW_AT_frame_base, DW_FORM_block1},
 			{DW_AT_decl_file, DW_FORM_data4},
 			{DW_AT_decl_line, DW_FORM_udata},
@@ -459,8 +494,8 @@ var abbrevs = []dwAbbrev{
 		DW_CHILDREN_yes,
 		[]dwAttrForm{
 			{DW_AT_name, DW_FORM_string},
-			{DW_AT_low_pc, DW_FORM_addr},
-			{DW_AT_high_pc, DW_FORM_addr},
+			{DW_AT_low_pc, DW_FORM_lo_pc_pseudo},
+			{DW_AT_high_pc, DW_FORM_hi_pc_pseudo},
 			{DW_AT_frame_base, DW_FORM_block1},
 			{DW_AT_trampoline, DW_FORM_flag},
 		},
@@ -484,8 +519,8 @@ var abbrevs = []dwAbbrev{
 		DW_CHILDREN_yes,
 		[]dwAttrForm{
 			{DW_AT_abstract_origin, DW_FORM_ref_addr},
-			{DW_AT_low_pc, DW_FORM_addr},
-			{DW_AT_high_pc, DW_FORM_addr},
+			{DW_AT_low_pc, DW_FORM_lo_pc_pseudo},
+			{DW_AT_high_pc, DW_FORM_hi_pc_pseudo},
 			{DW_AT_frame_base, DW_FORM_block1},
 		},
 	},
@@ -496,8 +531,8 @@ var abbrevs = []dwAbbrev{
 		DW_CHILDREN_yes,
 		[]dwAttrForm{
 			{DW_AT_abstract_origin, DW_FORM_ref_addr},
-			{DW_AT_low_pc, DW_FORM_addr},
-			{DW_AT_high_pc, DW_FORM_addr},
+			{DW_AT_low_pc, DW_FORM_lo_pc_pseudo},
+			{DW_AT_high_pc, DW_FORM_hi_pc_pseudo},
 			{DW_AT_frame_base, DW_FORM_block1},
 			{DW_AT_trampoline, DW_FORM_flag},
 		},
@@ -509,8 +544,8 @@ var abbrevs = []dwAbbrev{
 		DW_CHILDREN_yes,
 		[]dwAttrForm{
 			{DW_AT_abstract_origin, DW_FORM_ref_addr},
-			{DW_AT_low_pc, DW_FORM_addr},
-			{DW_AT_high_pc, DW_FORM_addr},
+			{DW_AT_low_pc, DW_FORM_lo_pc_pseudo},
+			{DW_AT_high_pc, DW_FORM_hi_pc_pseudo},
 			{DW_AT_call_file, DW_FORM_data4},
 			{DW_AT_call_line, DW_FORM_udata_pseudo}, // pseudo-form
 		},
@@ -565,6 +600,12 @@ var abbrevs = []dwAbbrev{
 		DW_TAG_lexical_block,
 		DW_CHILDREN_yes,
 		[]dwAttrForm{
+			// Note: we can't take advantage of DW_FORM_addrx here,
+			// since there is no way (at least at the moment) to
+			// have an encoding for low_pc of the form "addrx + constant"
+			// in DWARF5. If we wanted to use addrx, we'd need to create
+			// a whole new entry in .debug_addr for the block start,
+			// which would kind of defeat the point.
 			{DW_AT_low_pc, DW_FORM_addr},
 			{DW_AT_high_pc, DW_FORM_addr},
 		},
@@ -943,6 +984,9 @@ func putattr(ctxt Context, s Sym, abbrev int, form int, cls int, value int64, da
 		}
 		ctxt.AddDWARFAddrSectionOffset(s, data, value)
 
+	case DW_FORM_addrx: // index into .debug_addr section
+		ctxt.AddIndirectTextRef(s, data)
+
 	case DW_FORM_ref1, // reference within the compilation unit
 		DW_FORM_ref2,      // reference
 		DW_FORM_ref4,      // reference
@@ -1241,8 +1285,7 @@ func putInlinedFunc(ctxt Context, s *FnState, callIdx int) error {
 	} else {
 		st := ic.Ranges[0].Start
 		en := ic.Ranges[0].End
-		putattr(ctxt, s.Info, abbrev, DW_FORM_addr, DW_CLS_ADDRESS, st, s.StartPC)
-		putattr(ctxt, s.Info, abbrev, DW_FORM_addr, DW_CLS_ADDRESS, en, s.StartPC)
+		emitHiLoPc(ctxt, abbrev, s, st, en)
 	}
 
 	// Emit call file, line attrs.
@@ -1274,14 +1317,24 @@ func putInlinedFunc(ctxt Context, s *FnState, callIdx int) error {
 	return nil
 }
 
+func emitHiLoPc(ctxt Context, abbrev int, fns *FnState, st int64, en int64) {
+	if buildcfg.Experiment.Dwarf5 {
+		putattr(ctxt, fns.Info, abbrev, DW_FORM_addrx, DW_CLS_CONSTANT, st, fns.StartPC)
+		putattr(ctxt, fns.Info, abbrev, DW_FORM_udata, DW_CLS_CONSTANT, en, 0)
+	} else {
+		putattr(ctxt, fns.Info, abbrev, DW_FORM_addr, DW_CLS_ADDRESS, st, fns.StartPC)
+		putattr(ctxt, fns.Info, abbrev, DW_FORM_addr, DW_CLS_ADDRESS, en, fns.StartPC)
+	}
+}
+
 // Emit DWARF attributes and child DIEs for a 'concrete' subprogram,
 // meaning the out-of-line copy of a function that was inlined at some
 // point during the compilation of its containing package. The first
 // attribute for a concrete DIE is a reference to the 'abstract' DIE
 // for the function (which holds location-independent attributes such
 // as name, type), then the remainder of the attributes are specific
 // to this instance (location, frame base, etc).
-func PutConcreteFunc(ctxt Context, s *FnState, isWrapper bool) error {
+func PutConcreteFunc(ctxt Context, s *FnState, isWrapper bool, fncount int) error {
 	if logDwarf {
 		ctxt.Logf("PutConcreteFunc(%v)\n", s.Info)
 	}
@@ -1295,8 +1348,7 @@ func PutConcreteFunc(ctxt Context, s *FnState, isWrapper bool) error {
 	putattr(ctxt, s.Info, abbrev, DW_FORM_ref_addr, DW_CLS_REFERENCE, 0, s.Absfn)
 
 	// Start/end PC.
-	putattr(ctxt, s.Info, abbrev, DW_FORM_addr, DW_CLS_ADDRESS, 0, s.StartPC)
-	putattr(ctxt, s.Info, abbrev, DW_FORM_addr, DW_CLS_ADDRESS, s.Size, s.StartPC)
+	emitHiLoPc(ctxt, abbrev, s, 0, s.Size)
 
 	// cfa / frame base
 	putattr(ctxt, s.Info, abbrev, DW_FORM_block1, DW_CLS_BLOCK, 1, []byte{DW_OP_call_frame_cfa})
@@ -1343,8 +1395,7 @@ func PutDefaultFunc(ctxt Context, s *FnState, isWrapper bool) error {
 	}
 
 	putattr(ctxt, s.Info, DW_ABRV_FUNCTION, DW_FORM_string, DW_CLS_STRING, int64(len(name)), name)
-	putattr(ctxt, s.Info, abbrev, DW_FORM_addr, DW_CLS_ADDRESS, 0, s.StartPC)
-	putattr(ctxt, s.Info, abbrev, DW_FORM_addr, DW_CLS_ADDRESS, s.Size, s.StartPC)
+	emitHiLoPc(ctxt, abbrev, s, 0, s.Size)
 	putattr(ctxt, s.Info, abbrev, DW_FORM_block1, DW_CLS_BLOCK, 1, []byte{DW_OP_call_frame_cfa})
 	if isWrapper {
 		putattr(ctxt, s.Info, abbrev, DW_FORM_flag, DW_CLS_FLAG, int64(1), 0)

src/cmd/internal/dwarf/dwarf_defs.go

@@ -187,6 +187,7 @@ const (
 	DW_AT_elemental      = 0x66 // flag
 	DW_AT_pure           = 0x67 // flag
 	DW_AT_recursive      = 0x68 // flag
+	DW_AT_addr_base      = 0x73 // addrptr
 
 	DW_AT_lo_user = 0x2000 // ---
 	DW_AT_hi_user = 0x3fff // ---
@@ -219,9 +220,14 @@ const (
 	DW_FORM_sec_offset   = 0x17 // lineptr, loclistptr, macptr, rangelistptr
 	DW_FORM_exprloc      = 0x18 // exprloc
 	DW_FORM_flag_present = 0x19 // flag
-	DW_FORM_ref_sig8     = 0x20 // reference
+	// Dwarf5
+	DW_FORM_addrx = 0x1b
 	// Pseudo-form: expanded to data4 on IOS, udata elsewhere.
 	DW_FORM_udata_pseudo = 0x99
+	// Pseudo-form: expands to DW_FORM_addrx in DWARF5, DW_FORM_addr in DWARF4
+	DW_FORM_lo_pc_pseudo = 0x9a
+	// Pseudo-form: expands to DW_FORM_udata in DWARF5, DW_FORM_addr in DWARF4
+	DW_FORM_hi_pc_pseudo = 0x9b
 )
 
 // Table 24 (#operands, notes)

src/cmd/internal/obj/data.go

@@ -210,3 +210,22 @@ func (s *LSym) AddRel(ctxt *Link, rel Reloc) {
 	}
 	s.R = append(s.R, rel)
 }
+
+// WriteDwTxtAddrx appends a zero blob of the proper size to s at off
+// and attaches one of the various R_DWTXTADDR_U* relocations to the
+// symbol. Here size is dependent on the total number of functions in
+// the package (for more on why this is needed, consult the
+// .debug_addr generation code in the linker).
+func (s *LSym) WriteDwTxtAddrx(ctxt *Link, off int64, rsym *LSym, maxFuncs int) {
+	rtype, sz := objabi.FuncCountToDwTxtAddrFlavor(maxFuncs)
+	s.prepwrite(ctxt, off, sz)
+	if int64(int32(off)) != off {
+		ctxt.Diag("WriteDwTxtAddrx: off overflow %d in %s", off, s.Name)
+	}
+	s.AddRel(ctxt, Reloc{
+		Type: rtype,
+		Off:  int32(off),
+		Siz:  uint8(sz),
+		Sym:  rsym,
+	})
+}

src/cmd/internal/obj/dwarf.go

@@ -288,6 +288,16 @@ func (c dwCtxt) Logf(format string, args ...interface{}) {
 	c.Link.Logf(format, args...)
 }
 
+func (c dwCtxt) AddIndirectTextRef(s dwarf.Sym, t interface{}) {
+	ls := s.(*LSym)
+	tsym := t.(*LSym)
+	// Note the doubling below -- DwTextCount is an estimate and
+	// usually a little short due to additional wrapper functions and
+	// such; by using c.DwTextCount*2 as the limit we'll ensure that
+	// we don't run out of space.
+	ls.WriteDwTxtAddrx(c.Link, ls.Size, tsym, c.DwTextCount*2)
+}
+
 func isDwarf64(ctxt *Link) bool {
 	return ctxt.Headtype == objabi.Haix
 }
@@ -371,7 +381,8 @@ func (ctxt *Link) populateDWARF(curfn Func, s *LSym) {
 		if err != nil {
 			ctxt.Diag("emitting DWARF for %s failed: %v", s.Name, err)
 		}
-		err = dwarf.PutConcreteFunc(dwctxt, fnstate, s.Wrapper())
+		err = dwarf.PutConcreteFunc(dwctxt, fnstate, s.Wrapper(),
+			ctxt.DwTextCount)
 	} else {
 		err = dwarf.PutDefaultFunc(dwctxt, fnstate, s.Wrapper())
 	}

src/cmd/internal/obj/link.go

@@ -1158,6 +1158,7 @@ type Link struct {
 	PosTable           src.PosTable
 	InlTree            InlTree // global inlining tree used by gc/inl.go
 	DwFixups           *DwarfFixupTable
+	DwTextCount        int
 	Imports            []goobj.ImportedPkg
 	DiagFunc           func(string, ...interface{})
 	DiagFlush          func()

src/cmd/link/internal/dwtest/dwtest.go

@@ -195,3 +195,58 @@ func (ex *Examiner) Named(name string) []*dwarf.Entry {
 	}
 	return ret
 }
+
+// SubprogLoAndHighPc returns the values of the lo_pc and high_pc
+// attrs of the DWARF DIE subprogdie.  For DWARF versions 2-3, both of
+// these attributes had to be of class address; with DWARF 4 the rules
+// were changed, allowing compilers to emit a high PC attr of class
+// constant, where the high PC could be computed by starting with the
+// low PC address and then adding in the high_pc attr offset.  This
+// function accepts both styles of specifying a hi/lo pair, returning
+// the values or an error if the attributes are malformed in some way.
+func SubprogLoAndHighPc(subprogdie *dwarf.Entry) (lo uint64, hi uint64, err error) {
+	// The low_pc attr for a subprogram DIE has to be of class address.
+	lofield := subprogdie.AttrField(dwarf.AttrLowpc)
+	if lofield == nil {
+		err = fmt.Errorf("subprogram DIE has no low_pc attr")
+		return
+	}
+	if lofield.Class != dwarf.ClassAddress {
+		err = fmt.Errorf("subprogram DIE low_pc attr is not of class address")
+		return
+	}
+	if lopc, ok := lofield.Val.(uint64); ok {
+		lo = lopc
+	} else {
+		err = fmt.Errorf("subprogram DIE low_pc not convertible to uint64")
+		return
+	}
+
+	// For the high_pc value, we'll accept either an address or a constant
+	// offset from lo pc.
+	hifield := subprogdie.AttrField(dwarf.AttrHighpc)
+	if hifield == nil {
+		err = fmt.Errorf("subprogram DIE has no high_pc attr")
+		return
+	}
+	switch hifield.Class {
+	case dwarf.ClassAddress:
+		if hipc, ok := hifield.Val.(uint64); ok {
+			hi = hipc
+		} else {
+			err = fmt.Errorf("subprogram DIE high not convertible to uint64")
+			return
+		}
+	case dwarf.ClassConstant:
+		if hioff, ok := hifield.Val.(int64); ok {
+			hi = lo + uint64(hioff)
+		} else {
+			err = fmt.Errorf("subprogram DIE high_pc not convertible to uint64")
+			return
+		}
+	default:
+		err = fmt.Errorf("subprogram DIE high_pc unknown value class %s",
+			hifield.Class)
+	}
+	return
+}