[dev.link] cmd/link: use more compact representation for external relocations

Currently, for external relocations, the ExtReloc structure
contains all the fields of the relocation. In fact, many of the
fields are the same with the original relocation. So, instead, we
can just use an index to reference the original relocation and
not expand the fields.

There is one place where we modify relocation type: changing
R_DWARFSECTREF to R_ADDR. Get away with it by changing
downstreams.

It also makes it easier to retrieve the reloc variant.

This reduces some allocation. Linking cmd/compile with external
linking,

name           old alloc/op   new alloc/op   delta
Reloc_GC         34.1MB ± 0%    22.7MB ± 0%  -33.30%  (p=0.000 n=5+4)

Change-Id: Id08a89ed2aee705296886d3b95014b806a0d55cf
Reviewed-on: https://go-review.googlesource.com/c/go/+/231217
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Jeremy Faller <jeremy@golang.org>

1 files changed, 17 insertions, 16 deletions

diff --git a/src/cmd/link/internal/loader/loader.go b/src/cmd/link/internal/loader/loader.go
index a7b65e3580..749995bf8e 100644
--- a/src/cmd/link/internal/loader/loader.go
+++ b/src/cmd/link/internal/loader/loader.go
@@ -51,11 +51,7 @@ type Reloc struct {
 
 // ExtReloc contains the payload for an external relocation.
 type ExtReloc struct {
-	Off  int32            // offset to rewrite
-	Siz  uint8            // number of bytes to rewrite: 0, 1, 2, or 4
-	Type objabi.RelocType // the relocation type
-	Sym  Sym              // global index of symbol the reloc addresses
-	Add  int64            // addend
+	Idx  int // index of the original relocation
 	Xsym Sym
 	Xadd int64
 }
@@ -2763,25 +2759,30 @@ func (l *Loader) convertExtRelocs(dst *sym.Symbol, src Sym) {
 	if int(src) >= len(l.extRelocs) {
 		return
 	}
-	relocs := l.extRelocs[src]
-	if len(relocs) == 0 {
+	extRelocs := l.extRelocs[src]
+	if len(extRelocs) == 0 {
 		return
 	}
 	if len(dst.R) != 0 {
 		panic("bad")
 	}
-	dst.R = make([]sym.Reloc, len(relocs))
+	dst.R = make([]sym.Reloc, len(extRelocs))
+	relocs := l.Relocs(src)
 	for i := range dst.R {
-		sr := &relocs[i]
+		er := &extRelocs[i]
+		sr := relocs.At2(er.Idx)
 		r := &dst.R[i]
 		r.InitExt()
-		r.Off = sr.Off
-		r.Siz = sr.Siz
-		r.Type = sr.Type
-		r.Sym = l.Syms[sr.Sym]
-		r.Add = sr.Add
-		r.Xsym = l.Syms[sr.Xsym]
-		r.Xadd = sr.Xadd
+		r.Off = sr.Off()
+		r.Siz = sr.Siz()
+		r.Type = sr.Type()
+		r.Sym = l.Syms[l.ResolveABIAlias(sr.Sym())]
+		r.Add = sr.Add()
+		r.Xsym = l.Syms[er.Xsym]
+		r.Xadd = er.Xadd
+		if rv := l.RelocVariant(src, er.Idx); rv != 0 {
+			r.Variant = rv
+		}
 	}
 }