[dev.link] cmd/link: remove *Link from architecture relocers

Also correct a few places I hadn't switched over to Target from *Link
context.

Change-Id: I6de6b39723762de3fa5f8d12800085421aca76fb
Reviewed-on: https://go-review.googlesource.com/c/go/+/220840
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>

diff --git a/src/cmd/link/internal/amd64/asm.go b/src/cmd/link/internal/amd64/asm.go
index 1332cf14dd8183401e43bbb6693a265681f78ba3..3e9bba3af473ca7efc6c04a64b29feeb8823e3b2 100644 (file)
--- a/src/cmd/link/internal/amd64/asm.go
+++ b/src/cmd/link/internal/amd64/asm.go
@@ -563,11 +563,11 @@ func pereloc1(arch *sys.Arch, out *ld.OutBuf, s *sym.Symbol, r *sym.Reloc, secto
        return true
 }
 
-func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
+func archreloc(target *ld.Target, syms *ld.ArchSyms, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
        return val, false
 }
 
-func archrelocvariant(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, t int64) int64 {
+func archrelocvariant(target *ld.Target, syms *ld.ArchSyms, r *sym.Reloc, s *sym.Symbol, t int64) int64 {
        log.Fatalf("unexpected relocation variant")
        return t
 }

diff --git a/src/cmd/link/internal/arm/asm.go b/src/cmd/link/internal/arm/asm.go
index 25bb25b63c712a67cd09b4f1fd278fd9ba50db25..457adb783ec4c15e62b5e15c1c0a65ef22154faf 100644 (file)
--- a/src/cmd/link/internal/arm/asm.go
+++ b/src/cmd/link/internal/arm/asm.go
@@ -597,7 +597,7 @@ func gentrampdyn(arch *sys.Arch, tramp, target *sym.Symbol, offset int64) {
        }
 }
 
-func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
+func archreloc(target *ld.Target, syms *ld.ArchSyms, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
        if target.IsExternal() {
                switch r.Type {
                case objabi.R_CALLARM:
@@ -641,19 +641,19 @@ func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, va
        case objabi.R_CONST:
                return r.Add, true
        case objabi.R_GOTOFF:
-               return ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(ctxt.Syms.Lookup(".got", 0)), true
+               return ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(syms.GOT), true
 
        // The following three arch specific relocations are only for generation of
        // Linux/ARM ELF's PLT entry (3 assembler instruction)
        case objabi.R_PLT0: // add ip, pc, #0xXX00000
-               if ld.Symaddr(ctxt.Syms.Lookup(".got.plt", 0)) < ld.Symaddr(ctxt.Syms.Lookup(".plt", 0)) {
+               if ld.Symaddr(syms.GOTPLT) < ld.Symaddr(syms.PLT) {
                        ld.Errorf(s, ".got.plt should be placed after .plt section.")
                }
-               return 0xe28fc600 + (0xff & (int64(uint32(ld.Symaddr(r.Sym)-(ld.Symaddr(ctxt.Syms.Lookup(".plt", 0))+int64(r.Off))+r.Add)) >> 20)), true
+               return 0xe28fc600 + (0xff & (int64(uint32(ld.Symaddr(r.Sym)-(ld.Symaddr(syms.PLT)+int64(r.Off))+r.Add)) >> 20)), true
        case objabi.R_PLT1: // add ip, ip, #0xYY000
-               return 0xe28cca00 + (0xff & (int64(uint32(ld.Symaddr(r.Sym)-(ld.Symaddr(ctxt.Syms.Lookup(".plt", 0))+int64(r.Off))+r.Add+4)) >> 12)), true
+               return 0xe28cca00 + (0xff & (int64(uint32(ld.Symaddr(r.Sym)-(ld.Symaddr(syms.PLT)+int64(r.Off))+r.Add+4)) >> 12)), true
        case objabi.R_PLT2: // ldr pc, [ip, #0xZZZ]!
-               return 0xe5bcf000 + (0xfff & int64(uint32(ld.Symaddr(r.Sym)-(ld.Symaddr(ctxt.Syms.Lookup(".plt", 0))+int64(r.Off))+r.Add+8))), true
+               return 0xe5bcf000 + (0xfff & int64(uint32(ld.Symaddr(r.Sym)-(ld.Symaddr(syms.PLT)+int64(r.Off))+r.Add+8))), true
        case objabi.R_CALLARM: // bl XXXXXX or b YYYYYY
                // r.Add is the instruction
                // low 24-bit encodes the target address
@@ -667,7 +667,7 @@ func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, va
        return val, false
 }
 
-func archrelocvariant(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, t int64) int64 {
+func archrelocvariant(target *ld.Target, syms *ld.ArchSyms, r *sym.Reloc, s *sym.Symbol, t int64) int64 {
        log.Fatalf("unexpected relocation variant")
        return t
 }

diff --git a/src/cmd/link/internal/arm64/asm.go b/src/cmd/link/internal/arm64/asm.go
index d8409d57f8dc63ff06d823518670fbf4c0968876..f03a4efc8d8f59a0f0bd13f0443166aa3f4ba995 100644 (file)
--- a/src/cmd/link/internal/arm64/asm.go
+++ b/src/cmd/link/internal/arm64/asm.go
@@ -433,7 +433,7 @@ func machoreloc1(arch *sys.Arch, out *ld.OutBuf, s *sym.Symbol, r *sym.Reloc, se
        return true
 }
 
-func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
+func archreloc(target *ld.Target, syms *ld.ArchSyms, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
        if target.IsExternal() {
                switch r.Type {
                default:
@@ -532,7 +532,7 @@ func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, va
                return r.Add, true
 
        case objabi.R_GOTOFF:
-               return ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(ctxt.Syms.Lookup(".got", 0)), true
+               return ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(syms.GOT), true
 
        case objabi.R_ADDRARM64:
                t := ld.Symaddr(r.Sym) + r.Add - ((s.Value + int64(r.Off)) &^ 0xfff)
@@ -619,7 +619,7 @@ func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, va
        case objabi.R_CALLARM64:
                var t int64
                if r.Sym.Type == sym.SDYNIMPORT {
-                       t = (ld.Symaddr(ctxt.Syms.Lookup(".plt", 0)) + r.Add) - (s.Value + int64(r.Off))
+                       t = (ld.Symaddr(syms.PLT) + r.Add) - (s.Value + int64(r.Off))
                } else {
                        t = (ld.Symaddr(r.Sym) + r.Add) - (s.Value + int64(r.Off))
                }
@@ -706,7 +706,7 @@ func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, va
        return val, false
 }
 
-func archrelocvariant(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, t int64) int64 {
+func archrelocvariant(target *ld.Target, syms *ld.ArchSyms, r *sym.Reloc, s *sym.Symbol, t int64) int64 {
        log.Fatalf("unexpected relocation variant")
        return -1
 }

diff --git a/src/cmd/link/internal/ld/data.go b/src/cmd/link/internal/ld/data.go
index d57763ba4c9fcd31e62da8ff72ef76496cd59ed8..3d02445ca1ce3079bb5c8a0fa90746665cbd139a 100644 (file)
--- a/src/cmd/link/internal/ld/data.go
+++ b/src/cmd/link/internal/ld/data.go
@@ -222,7 +222,7 @@ func relocsym(ctxt *Link, target *Target, s *sym.Symbol) {
                        case 8:
                                o = int64(target.Arch.ByteOrder.Uint64(s.P[off:]))
                        }
-                       if offset, ok := thearch.Archreloc(ctxt, target, r, s, o); ok {
+                       if offset, ok := thearch.Archreloc(target, &ctxt.ArchSyms, r, s, o); ok {
                                o = offset
                        } else {
                                Errorf(s, "unknown reloc to %v: %d (%s)", r.Sym.Name, r.Type, sym.RelocName(target.Arch, r.Type))
@@ -520,7 +520,7 @@ func relocsym(ctxt *Link, target *Target, s *sym.Symbol) {
                if target.IsPPC64() || target.IsS390X() {
                        r.InitExt()
                        if r.Variant != sym.RV_NONE {
-                               o = thearch.Archrelocvariant(ctxt, target, r, s, o)
+                               o = thearch.Archrelocvariant(target, &ctxt.ArchSyms, r, s, o)
                        }
                }
 

diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index d1aee36b88d21fc06464683f91ecce9613d50daa..763dbbab10d94b6fc38bd0ef74a83299688f1489 100644 (file)
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -94,6 +94,29 @@ import (
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+type LookupFn func(name string, version int) *sym.Symbol
+
+// ArchSyms holds a number of architecture specific symbols used during
+// relocation.  Rather than allowing them universal access to all symbols,
+// we keep a subset for relocation application.
+type ArchSyms struct {
+       TOC    *sym.Symbol
+       DotTOC *sym.Symbol
+       GOT    *sym.Symbol
+       PLT    *sym.Symbol
+       GOTPLT *sym.Symbol
+}
+
+// setArchSyms sets up the ArchSyms structure, and must be called before
+// relocations are applied.
+func (ctxt *Link) setArchSyms() {
+       ctxt.TOC = ctxt.Syms.Lookup("TOC", 0)
+       ctxt.DotTOC = ctxt.Syms.Lookup(".TOC.", 0)
+       ctxt.GOT = ctxt.Syms.Lookup(".got", 0)
+       ctxt.PLT = ctxt.Syms.Lookup(".plt", 0)
+       ctxt.GOTPLT = ctxt.Syms.Lookup(".got.plt", 0)
+}
+
 type Arch struct {
        Funcalign      int
        Maxalign       int
@@ -118,7 +141,7 @@ type Arch struct {
        // value is the appropriately relocated value (to be written back
        // to the same spot in sym.P) and a boolean indicating
        // success/failure (a failing value indicates a fatal error).
-       Archreloc func(link *Link, target *Target, rel *sym.Reloc, sym *sym.Symbol,
+       Archreloc func(target *Target, syms *ArchSyms, rel *sym.Reloc, sym *sym.Symbol,
                offset int64) (relocatedOffset int64, success bool)
        // Archrelocvariant is a second arch-specific hook used for
        // relocation processing; it handles relocations where r.Type is
@@ -128,7 +151,7 @@ type Arch struct {
        // relocation applies, and "off" is the contents of the
        // to-be-relocated data item (from sym.P). Return is an updated
        // offset value.
-       Archrelocvariant func(link *Link, target *Target, rel *sym.Reloc, sym *sym.Symbol,
+       Archrelocvariant func(target *Target, syms *ArchSyms, rel *sym.Reloc, sym *sym.Symbol,
                offset int64) (relocatedOffset int64)
        Trampoline func(*Link, *sym.Reloc, *sym.Symbol)
 

diff --git a/src/cmd/link/internal/ld/link.go b/src/cmd/link/internal/ld/link.go
index 677bc57d343fb4e26aab6833fd6cf9ed0867a5d4..5c690cf1f7f28210fa7dc0d43b661d5fc8e22cd7 100644 (file)
--- a/src/cmd/link/internal/ld/link.go
+++ b/src/cmd/link/internal/ld/link.go
@@ -52,6 +52,7 @@ type Shlib struct {
 type Link struct {
        Target
        ErrorReporter
+       ArchSyms
        Out *OutBuf
 
        Syms *sym.Symbols

diff --git a/src/cmd/link/internal/ld/main.go b/src/cmd/link/internal/ld/main.go
index 282e0a5ae86a02ade576895b1dd3c914075e1182..5933275dca2459b473360211c1b72870173f6945 100644 (file)
--- a/src/cmd/link/internal/ld/main.go
+++ b/src/cmd/link/internal/ld/main.go
@@ -294,6 +294,7 @@ func Main(arch *sys.Arch, theArch Arch) {
        bench.Start("address")
        order := ctxt.address()
        bench.Start("dwarfcompress")
+       ctxt.setArchSyms()
        dwarfcompress(ctxt)
        bench.Start("layout")
        filesize := ctxt.layout(order)

diff --git a/src/cmd/link/internal/mips/asm.go b/src/cmd/link/internal/mips/asm.go
index 697daec9e2b670c6e1807ecaeae8d8a07be34e8b..7531d3f78dbd62e9eae97db590273af04880c984 100644 (file)
--- a/src/cmd/link/internal/mips/asm.go
+++ b/src/cmd/link/internal/mips/asm.go
@@ -96,7 +96,7 @@ func applyrel(arch *sys.Arch, r *sym.Reloc, s *sym.Symbol, val int64, t int64) i
        }
 }
 
-func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
+func archreloc(target *ld.Target, syms *ld.ArchSyms, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
        if target.IsExternal() {
                switch r.Type {
                default:
@@ -129,7 +129,7 @@ func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, va
        case objabi.R_CONST:
                return r.Add, true
        case objabi.R_GOTOFF:
-               return ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(ctxt.Syms.Lookup(".got", 0)), true
+               return ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(syms.GOT), true
        case objabi.R_ADDRMIPS, objabi.R_ADDRMIPSU:
                t := ld.Symaddr(r.Sym) + r.Add
                return applyrel(target.Arch, r, s, val, t), true
@@ -158,7 +158,7 @@ func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, va
        return val, false
 }
 
-func archrelocvariant(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, t int64) int64 {
+func archrelocvariant(target *ld.Target, syms *ld.ArchSyms, r *sym.Reloc, s *sym.Symbol, t int64) int64 {
        return -1
 }
 

diff --git a/src/cmd/link/internal/mips64/asm.go b/src/cmd/link/internal/mips64/asm.go
index cc1f858dadf0a23276cbab4a7335d6478df5fd78..03caa2c6bcf249b458062d84de4c6b169393e030 100644 (file)
--- a/src/cmd/link/internal/mips64/asm.go
+++ b/src/cmd/link/internal/mips64/asm.go
@@ -99,7 +99,7 @@ func machoreloc1(arch *sys.Arch, out *ld.OutBuf, s *sym.Symbol, r *sym.Reloc, se
        return false
 }
 
-func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
+func archreloc(target *ld.Target, syms *ld.ArchSyms, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
        if target.IsExternal() {
                switch r.Type {
                default:
@@ -136,7 +136,7 @@ func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, va
        case objabi.R_CONST:
                return r.Add, true
        case objabi.R_GOTOFF:
-               return ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(ctxt.Syms.Lookup(".got", 0)), true
+               return ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(syms.GOT), true
        case objabi.R_ADDRMIPS,
                objabi.R_ADDRMIPSU:
                t := ld.Symaddr(r.Sym) + r.Add
@@ -164,7 +164,7 @@ func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, va
        return val, false
 }
 
-func archrelocvariant(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, t int64) int64 {
+func archrelocvariant(target *ld.Target, syms *ld.ArchSyms, r *sym.Reloc, s *sym.Symbol, t int64) int64 {
        return -1
 }
 

diff --git a/src/cmd/link/internal/ppc64/asm.go b/src/cmd/link/internal/ppc64/asm.go
index 2a31a16c9b3214a9a1bec719056244d218fd9af2..9548aef5f8df26a32a120d7f9a8a587d2681d1ea 100644 (file)
--- a/src/cmd/link/internal/ppc64/asm.go
+++ b/src/cmd/link/internal/ppc64/asm.go
@@ -513,30 +513,12 @@ func machoreloc1(arch *sys.Arch, out *ld.OutBuf, s *sym.Symbol, r *sym.Reloc, se
        return false
 }
 
-// Return the value of .TOC. for symbol s
-func symtoc(ctxt *ld.Link, s *sym.Symbol) int64 {
-       var toc *sym.Symbol
-
-       if s.Outer != nil {
-               toc = ctxt.Syms.ROLookup(".TOC.", int(s.Outer.Version))
-       } else {
-               toc = ctxt.Syms.ROLookup(".TOC.", int(s.Version))
-       }
-
-       if toc == nil {
-               ld.Errorf(s, "TOC-relative relocation in object without .TOC.")
-               return 0
-       }
-
-       return toc.Value
-}
-
 // archreloctoc relocates a TOC relative symbol.
 // If the symbol pointed by this TOC relative symbol is in .data or .bss, the
 // default load instruction can be changed to an addi instruction and the
 // symbol address can be used directly.
 // This code is for AIX only.
-func archreloctoc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, val int64) int64 {
+func archreloctoc(target *ld.Target, syms *ld.ArchSyms, r *sym.Reloc, s *sym.Symbol, val int64) int64 {
        if target.IsLinux() {
                ld.Errorf(s, "archrelocaddr called for %s relocation\n", r.Sym.Name)
        }
@@ -556,12 +538,12 @@ func archreloctoc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol,
        }
 
        if target.IsInternal() && tarSym != nil && tarSym.Attr.Reachable() && (tarSym.Sect.Seg == &ld.Segdata) {
-               t = ld.Symaddr(tarSym) + r.Add - ctxt.Syms.ROLookup("TOC", 0).Value
+               t = ld.Symaddr(tarSym) + r.Add - syms.TOC.Value
                // change ld to addi in the second instruction
                o2 = (o2 & 0x03FF0000) | 0xE<<26
                useAddi = true
        } else {
-               t = ld.Symaddr(r.Sym) + r.Add - ctxt.Syms.ROLookup("TOC", 0).Value
+               t = ld.Symaddr(r.Sym) + r.Add - syms.TOC.Value
        }
 
        if t != int64(int32(t)) {
@@ -593,7 +575,7 @@ func archreloctoc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol,
 
 // archrelocaddr relocates a symbol address.
 // This code is for AIX only.
-func archrelocaddr(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, val int64) int64 {
+func archrelocaddr(target *ld.Target, syms *ld.ArchSyms, r *sym.Reloc, s *sym.Symbol, val int64) int64 {
        if target.IsAIX() {
                ld.Errorf(s, "archrelocaddr called for %s relocation\n", r.Sym.Name)
        }
@@ -770,13 +752,13 @@ func gentramp(ctxt *ld.Link, tramp, target *sym.Symbol, offset int64) {
        ctxt.Arch.ByteOrder.PutUint32(tramp.P[12:], o4)
 }
 
-func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
-       if ctxt.LinkMode == ld.LinkExternal {
+func archreloc(target *ld.Target, syms *ld.ArchSyms, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
+       if target.IsExternal() {
                // On AIX, relocations (except TLS ones) must be also done to the
                // value with the current addresses.
                switch r.Type {
                default:
-                       if ctxt.HeadType != objabi.Haix {
+                       if target.IsAIX() {
                                return val, false
                        }
                case objabi.R_POWER_TLS, objabi.R_POWER_TLS_LE, objabi.R_POWER_TLS_IE:
@@ -806,14 +788,14 @@ func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, va
                        }
                        r.Xsym = rs
 
-                       if ctxt.HeadType != objabi.Haix {
+                       if !target.IsAIX() {
                                return val, true
                        }
                case objabi.R_CALLPOWER:
                        r.Done = false
                        r.Xsym = r.Sym
                        r.Xadd = r.Add
-                       if ctxt.HeadType != objabi.Haix {
+                       if !target.IsAIX() {
                                return val, true
                        }
                }
@@ -823,11 +805,11 @@ func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, va
        case objabi.R_CONST:
                return r.Add, true
        case objabi.R_GOTOFF:
-               return ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(ctxt.Syms.Lookup(".got", 0)), true
+               return ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(syms.GOT), true
        case objabi.R_ADDRPOWER_TOCREL, objabi.R_ADDRPOWER_TOCREL_DS:
-               return archreloctoc(ctxt, &ctxt.Target, r, s, val), true
+               return archreloctoc(target, syms, r, s, val), true
        case objabi.R_ADDRPOWER, objabi.R_ADDRPOWER_DS:
-               return archrelocaddr(ctxt, target, r, s, val), true
+               return archrelocaddr(target, syms, r, s, val), true
        case objabi.R_CALLPOWER:
                // Bits 6 through 29 = (S + A - P) >> 2
 
@@ -843,7 +825,7 @@ func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, va
                }
                return val | int64(uint32(t)&^0xfc000003), true
        case objabi.R_POWER_TOC: // S + A - .TOC.
-               return ld.Symaddr(r.Sym) + r.Add - symtoc(ctxt, s), true
+               return ld.Symaddr(r.Sym) + r.Add - syms.DotTOC.Value, true
 
        case objabi.R_POWER_TLS_LE:
                // The thread pointer points 0x7000 bytes after the start of the
@@ -851,7 +833,7 @@ func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, va
                // Runtime Handling" of "Power Architecture 64-Bit ELF V2 ABI
                // Specification".
                v := r.Sym.Value - 0x7000
-               if ctxt.HeadType == objabi.Haix {
+               if target.IsAIX() {
                        // On AIX, the thread pointer points 0x7800 bytes after
                        // the TLS.
                        v -= 0x800
@@ -865,7 +847,7 @@ func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, va
        return val, false
 }
 
-func archrelocvariant(ctxt *ld.Link, taget *ld.Target, r *sym.Reloc, s *sym.Symbol, t int64) int64 {
+func archrelocvariant(target *ld.Target, syms *ld.ArchSyms, r *sym.Reloc, s *sym.Symbol, t int64) int64 {
        switch r.Variant & sym.RV_TYPE_MASK {
        default:
                ld.Errorf(s, "unexpected relocation variant %d", r.Variant)
@@ -879,7 +861,7 @@ func archrelocvariant(ctxt *ld.Link, taget *ld.Target, r *sym.Reloc, s *sym.Symb
                        // Whether to check for signed or unsigned
                        // overflow depends on the instruction
                        var o1 uint32
-                       if ctxt.Arch.ByteOrder == binary.BigEndian {
+                       if target.IsBigEndian() {
                                o1 = binary.BigEndian.Uint32(s.P[r.Off-2:])
                        } else {
                                o1 = binary.LittleEndian.Uint32(s.P[r.Off:])
@@ -913,7 +895,7 @@ func archrelocvariant(ctxt *ld.Link, taget *ld.Target, r *sym.Reloc, s *sym.Symb
                        // Whether to check for signed or unsigned
                        // overflow depends on the instruction
                        var o1 uint32
-                       if ctxt.Arch.ByteOrder == binary.BigEndian {
+                       if target.IsBigEndian() {
                                o1 = binary.BigEndian.Uint32(s.P[r.Off-2:])
                        } else {
                                o1 = binary.LittleEndian.Uint32(s.P[r.Off:])
@@ -937,7 +919,7 @@ func archrelocvariant(ctxt *ld.Link, taget *ld.Target, r *sym.Reloc, s *sym.Symb
 
        case sym.RV_POWER_DS:
                var o1 uint32
-               if ctxt.Arch.ByteOrder == binary.BigEndian {
+               if target.IsBigEndian() {
                        o1 = uint32(binary.BigEndian.Uint16(s.P[r.Off:]))
                } else {
                        o1 = uint32(binary.LittleEndian.Uint16(s.P[r.Off:]))

diff --git a/src/cmd/link/internal/riscv64/asm.go b/src/cmd/link/internal/riscv64/asm.go
index 9cc463a2962be1e3c529dcd251f72dbaf985d2bf..fce0daf56a76bbd09d7e76a844f3baad025e7343 100644 (file)
--- a/src/cmd/link/internal/riscv64/asm.go
+++ b/src/cmd/link/internal/riscv64/asm.go
@@ -40,7 +40,7 @@ func machoreloc1(arch *sys.Arch, out *ld.OutBuf, s *sym.Symbol, r *sym.Reloc, se
        return false
 }
 
-func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
+func archreloc(target *ld.Target, syms *ld.ArchSyms, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
        switch r.Type {
        case objabi.R_CALLRISCV:
                // Nothing to do.
@@ -91,7 +91,7 @@ func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, va
        return val, false
 }
 
-func archrelocvariant(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, t int64) int64 {
+func archrelocvariant(target *ld.Target, syms *ld.ArchSyms, r *sym.Reloc, s *sym.Symbol, t int64) int64 {
        log.Fatalf("archrelocvariant")
        return -1
 }

diff --git a/src/cmd/link/internal/s390x/asm.go b/src/cmd/link/internal/s390x/asm.go
index 44547db77ffec4839d91dda429fe3884e0162695..030266fe9b4b34b9487babb436ef818bff1e4426 100644 (file)
--- a/src/cmd/link/internal/s390x/asm.go
+++ b/src/cmd/link/internal/s390x/asm.go
@@ -387,7 +387,7 @@ func machoreloc1(arch *sys.Arch, out *ld.OutBuf, s *sym.Symbol, r *sym.Reloc, se
        return false
 }
 
-func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
+func archreloc(target *ld.Target, syms *ld.ArchSyms, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
        if target.IsExternal() {
                return val, false
        }
@@ -396,13 +396,13 @@ func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, va
        case objabi.R_CONST:
                return r.Add, true
        case objabi.R_GOTOFF:
-               return ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(ctxt.Syms.Lookup(".got", 0)), true
+               return ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(syms.GOT), true
        }
 
        return val, false
 }
 
-func archrelocvariant(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, t int64) int64 {
+func archrelocvariant(target *ld.Target, syms *ld.ArchSyms, r *sym.Reloc, s *sym.Symbol, t int64) int64 {
        switch r.Variant & sym.RV_TYPE_MASK {
        default:
                ld.Errorf(s, "unexpected relocation variant %d", r.Variant)

diff --git a/src/cmd/link/internal/x86/asm.go b/src/cmd/link/internal/x86/asm.go
index 1a409810fd6fa0441719f2f52ada5989b49fa4a4..d53454e20a4fbf5c7f24908bea3d489908839de4 100644 (file)
--- a/src/cmd/link/internal/x86/asm.go
+++ b/src/cmd/link/internal/x86/asm.go
@@ -492,7 +492,7 @@ func pereloc1(arch *sys.Arch, out *ld.OutBuf, s *sym.Symbol, r *sym.Reloc, secto
        return true
 }
 
-func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
+func archreloc(target *ld.Target, syms *ld.ArchSyms, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
        if target.IsExternal() {
                return val, false
        }
@@ -500,13 +500,13 @@ func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, va
        case objabi.R_CONST:
                return r.Add, true
        case objabi.R_GOTOFF:
-               return ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(ctxt.Syms.Lookup(".got", 0)), true
+               return ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(syms.GOT), true
        }
 
        return val, false
 }
 
-func archrelocvariant(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, t int64) int64 {
+func archrelocvariant(target *ld.Target, syms *ld.ArchSyms, r *sym.Reloc, s *sym.Symbol, t int64) int64 {
        log.Fatalf("unexpected relocation variant")
        return t
 }