Stowage/go
2
0
Fork 0
mirror of https://github.com/golang/go.git synced 2025-12-08 06:10:04 +00:00
Code Issues Projects Releases Packages Wiki Activity

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

Browse source 
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>
This commit is contained in:
Cherry Zhang 2020-04-29 22:00:28 -04:00
parent ca290169ab
commit cdfff4d25a
10 changed files with 55 additions and 67 deletions
Download patch file Download diff file Expand all files Collapse all files

33
src/cmd/link/internal/loader/loader.go
View file

@ -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
}
}
}