[dev.link] cmd/link: use new-style relocation accessors in LoadFull

This gives some small speedup:

(linking cmd/compile)
Loadlibfull     77.8ms ± 6%    68.6ms ± 5%  -11.88%  (p=0.008 n=5+5)

Also convert some Relocs.At to At2, which should have been done
earlier.

Change-Id: I2a66aeb5857234c6e645e1b23380149cffc8221f
Reviewed-on: https://go-review.googlesource.com/c/go/+/226363
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>

diff --git a/src/cmd/link/internal/ld/deadcode2.go b/src/cmd/link/internal/ld/deadcode2.go
index 892f3f41e5753a30384a0efe4241bc4713aeadb0..f1555809c6798d3852f4905031bede7e42df27a8 100644 (file)
--- a/src/cmd/link/internal/ld/deadcode2.go
+++ b/src/cmd/link/internal/ld/deadcode2.go
@@ -272,7 +272,7 @@ func deadcode2(ctxt *Link) {
                        s := loader.Sym(i)
                        if ldr.IsItabLink(s) {
                                relocs := ldr.Relocs(s)
-                               if relocs.Count > 0 && ldr.AttrReachable(relocs.At(0).Sym) {
+                               if relocs.Count > 0 && ldr.AttrReachable(relocs.At2(0).Sym()) {
                                        ldr.SetAttrReachable(s, true)
                                }
                        }

diff --git a/src/cmd/link/internal/ld/pe.go b/src/cmd/link/internal/ld/pe.go
index 81fae7507278dd571d6f01703e20591560a0228d..527c1998379b6201dadb3154e1778351d2b4315b 100644 (file)
--- a/src/cmd/link/internal/ld/pe.go
+++ b/src/cmd/link/internal/ld/pe.go
@@ -1480,9 +1480,9 @@ func addpersrc(ctxt *Link) {
        // relocation
        relocs := ctxt.loader.Relocs(rsrcsym)
        for i := 0; i < relocs.Count; i++ {
-               r := relocs.At(i)
-               p := data[r.Off:]
-               val := uint32(int64(h.virtualAddress) + r.Add)
+               r := relocs.At2(i)
+               p := data[r.Off():]
+               val := uint32(int64(h.virtualAddress) + r.Add())
 
                // 32-bit little-endian
                p[0] = byte(val)

diff --git a/src/cmd/link/internal/loader/loader.go b/src/cmd/link/internal/loader/loader.go
index c04cc03b3e24ecd6febcebdb77311c98549b931e..7ebeb45cb12756bb11e0969831805f97cf86edbc 100644 (file)
--- a/src/cmd/link/internal/loader/loader.go
+++ b/src/cmd/link/internal/loader/loader.go
@@ -1865,7 +1865,8 @@ func (l *Loader) LoadFull(arch *sys.Arch, syms *sym.Symbols) {
                batch := l.relocBatch
                s.R = batch[:len(pp.relocs):len(pp.relocs)]
                l.relocBatch = batch[len(pp.relocs):]
-               l.convertRelocations(pp.relocs, s, false)
+               relocs := l.Relocs(i)
+               l.convertRelocations(&relocs, s, false)
 
                // Copy data
                s.P = pp.data
@@ -1977,7 +1978,6 @@ func (l *Loader) PropagateLoaderChangesToSymbols(toconvert []Sym, anonVerReplace
        // sym.Symbols are created.
 
        // First pass, symbol creation and symbol data fixup.
-       rslice := []Reloc{}
        for _, cand := range toconvert {
 
                sn := l.SymName(cand)
@@ -2063,11 +2063,10 @@ func (l *Loader) PropagateLoaderChangesToSymbols(toconvert []Sym, anonVerReplace
        for _, cand := range relocfixup {
                s := l.Syms[cand]
                relocs := l.Relocs(cand)
-               rslice = relocs.ReadAll(rslice)
-               if len(s.R) != len(rslice) {
-                       s.R = make([]sym.Reloc, len(rslice))
+               if len(s.R) != relocs.Count {
+                       s.R = make([]sym.Reloc, relocs.Count)
                }
-               l.convertRelocations(rslice, s, true)
+               l.convertRelocations(&relocs, s, true)
        }
 
        return result
@@ -2426,7 +2425,6 @@ func loadObjFull(l *Loader, r *oReader) {
        fdsyms := []*sym.Symbol{}
        var funcAllocCounts funcAllocInfo
        pcdataBase := r.PcdataBase()
-       rslice := []Reloc{}
        for i, n := 0, r.NSym()+r.NNonpkgdef(); i < n; i++ {
                // A symbol may be a dup or overwritten. In this case, its
                // content will actually be provided by a different object
@@ -2471,11 +2469,10 @@ func loadObjFull(l *Loader, r *oReader) {
 
                // Relocs
                relocs := l.relocs(r, i)
-               rslice = relocs.ReadAll(rslice)
                batch := l.relocBatch
                s.R = batch[:relocs.Count:relocs.Count]
                l.relocBatch = batch[relocs.Count:]
-               l.convertRelocations(rslice, s, false)
+               l.convertRelocations(&relocs, s, false)
 
                // Aux symbol info
                isym := -1
@@ -2645,12 +2642,12 @@ func loadObjFull(l *Loader, r *oReader) {
 // etc. It is assumed that the caller has pre-allocated the dst symbol
 // relocations slice. If 'strict' is set, then this method will
 // panic if it finds a relocation targeting a nil symbol.
-func (l *Loader) convertRelocations(src []Reloc, dst *sym.Symbol, strict bool) {
+func (l *Loader) convertRelocations(src *Relocs, dst *sym.Symbol, strict bool) {
        for j := range dst.R {
-               r := src[j]
-               rs := r.Sym
-               sz := r.Size
-               rt := r.Type
+               r := src.At2(j)
+               rs := r.Sym()
+               sz := r.Siz()
+               rt := r.Type()
                if rt == objabi.R_METHODOFF {
                        if l.attrReachable.Has(rs) {
                                rt = objabi.R_ADDROFF
@@ -2671,10 +2668,10 @@ func (l *Loader) convertRelocations(src []Reloc, dst *sym.Symbol, strict bool) {
                        panic("nil reloc target in convertRelocations")
                }
                dst.R[j] = sym.Reloc{
-                       Off:  r.Off,
+                       Off:  r.Off(),
                        Siz:  sz,
                        Type: rt,
-                       Add:  r.Add,
+                       Add:  r.Add(),
                        Sym:  l.Syms[rs],
                }
        }