[dev.link] cmd/link: add Target to relocation functions

We need to propogate Target through the relocation functions.

Change-Id: I1192d54a20a34569fd13c1511d2b21ebf2d1272e
Reviewed-on: https://go-review.googlesource.com/c/go/+/220839
Run-TryBot: Jeremy Faller <jeremy@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
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 cd85cb6bb34a2058024ced4d45924954534607fe..1332cf14dd8183401e43bbb6693a265681f78ba3 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, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
+func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
        return val, false
 }
 
-func archrelocvariant(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, t int64) int64 {
+func archrelocvariant(ctxt *ld.Link, target *ld.Target, 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 f2fb6543d0d939e17264f95a42d6c7c6c33b0764..25bb25b63c712a67cd09b4f1fd278fd9ba50db25 100644 (file)
--- a/src/cmd/link/internal/arm/asm.go
+++ b/src/cmd/link/internal/arm/asm.go
@@ -597,8 +597,8 @@ func gentrampdyn(arch *sys.Arch, tramp, target *sym.Symbol, offset int64) {
        }
 }
 
-func archreloc(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
-       if ctxt.LinkMode == ld.LinkExternal {
+func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
+       if target.IsExternal() {
                switch r.Type {
                case objabi.R_CALLARM:
                        r.Done = false
@@ -623,7 +623,7 @@ func archreloc(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bo
                        // the section load address.
                        // we need to compensate that by removing the instruction's address
                        // from addend.
-                       if ctxt.HeadType == objabi.Hdarwin {
+                       if target.IsDarwin() {
                                r.Xadd -= ld.Symaddr(s) + int64(r.Off)
                        }
 
@@ -667,7 +667,7 @@ func archreloc(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bo
        return val, false
 }
 
-func archrelocvariant(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, t int64) int64 {
+func archrelocvariant(ctxt *ld.Link, target *ld.Target, 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 9c3f4422384f563d1d617ac55fd60a061a654854..d8409d57f8dc63ff06d823518670fbf4c0968876 100644 (file)
--- a/src/cmd/link/internal/arm64/asm.go
+++ b/src/cmd/link/internal/arm64/asm.go
@@ -36,7 +36,6 @@ import (
        "cmd/link/internal/ld"
        "cmd/link/internal/sym"
        "debug/elf"
-       "encoding/binary"
        "fmt"
        "log"
 )
@@ -434,14 +433,14 @@ func machoreloc1(arch *sys.Arch, out *ld.OutBuf, s *sym.Symbol, r *sym.Reloc, se
        return true
 }
 
-func archreloc(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
-       if ctxt.LinkMode == ld.LinkExternal {
+func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
+       if target.IsExternal() {
                switch r.Type {
                default:
                        return val, false
                case objabi.R_ARM64_GOTPCREL:
                        var o1, o2 uint32
-                       if ctxt.Arch.ByteOrder == binary.BigEndian {
+                       if target.IsBigEndian() {
                                o1 = uint32(val >> 32)
                                o2 = uint32(val)
                        } else {
@@ -456,14 +455,14 @@ func archreloc(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bo
                        // (https://sourceware.org/bugzilla/show_bug.cgi?id=18270). So
                        // we convert the adrp; ld64 + R_ARM64_GOTPCREL into adrp;
                        // add + R_ADDRARM64.
-                       if !(r.Sym.IsFileLocal() || r.Sym.Attr.VisibilityHidden() || r.Sym.Attr.Local()) && r.Sym.Type == sym.STEXT && ctxt.DynlinkingGo() {
+                       if !(r.Sym.IsFileLocal() || r.Sym.Attr.VisibilityHidden() || r.Sym.Attr.Local()) && r.Sym.Type == sym.STEXT && target.IsDynlinkingGo() {
                                if o2&0xffc00000 != 0xf9400000 {
                                        ld.Errorf(s, "R_ARM64_GOTPCREL against unexpected instruction %x", o2)
                                }
                                o2 = 0x91000000 | (o2 & 0x000003ff)
                                r.Type = objabi.R_ADDRARM64
                        }
-                       if ctxt.Arch.ByteOrder == binary.BigEndian {
+                       if target.IsBigEndian() {
                                val = int64(o1)<<32 | int64(o2)
                        } else {
                                val = int64(o2)<<32 | int64(o1)
@@ -490,10 +489,10 @@ func archreloc(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bo
                        // the BR26 relocation should be fully resolved at link time.
                        // That is the reason why the next if block is disabled. When the bug in ld64
                        // is fixed, we can enable this block and also enable duff's device in cmd/7g.
-                       if false && ctxt.HeadType == objabi.Hdarwin {
+                       if false && target.IsDarwin() {
                                var o0, o1 uint32
 
-                               if ctxt.Arch.ByteOrder == binary.BigEndian {
+                               if target.IsBigEndian() {
                                        o0 = uint32(val >> 32)
                                        o1 = uint32(val)
                                } else {
@@ -510,7 +509,7 @@ func archreloc(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bo
                                r.Xadd = 0
 
                                // when laid out, the instruction order must always be o1, o2.
-                               if ctxt.Arch.ByteOrder == binary.BigEndian {
+                               if target.IsBigEndian() {
                                        val = int64(o0)<<32 | int64(o1)
                                } else {
                                        val = int64(o1)<<32 | int64(o0)
@@ -543,7 +542,7 @@ func archreloc(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bo
 
                var o0, o1 uint32
 
-               if ctxt.Arch.ByteOrder == binary.BigEndian {
+               if target.IsBigEndian() {
                        o0 = uint32(val >> 32)
                        o1 = uint32(val)
                } else {
@@ -555,42 +554,42 @@ func archreloc(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bo
                o1 |= uint32(t&0xfff) << 10
 
                // when laid out, the instruction order must always be o1, o2.
-               if ctxt.Arch.ByteOrder == binary.BigEndian {
+               if target.IsBigEndian() {
                        return int64(o0)<<32 | int64(o1), true
                }
                return int64(o1)<<32 | int64(o0), true
 
        case objabi.R_ARM64_TLS_LE:
                r.Done = false
-               if ctxt.HeadType == objabi.Hdarwin {
-                       ld.Errorf(s, "TLS reloc on unsupported OS %v", ctxt.HeadType)
+               if target.IsDarwin() {
+                       ld.Errorf(s, "TLS reloc on unsupported OS %v", target.HeadType)
                }
                // The TCB is two pointers. This is not documented anywhere, but is
                // de facto part of the ABI.
-               v := r.Sym.Value + int64(2*ctxt.Arch.PtrSize)
+               v := r.Sym.Value + int64(2*target.Arch.PtrSize)
                if v < 0 || v >= 32678 {
                        ld.Errorf(s, "TLS offset out of range %d", v)
                }
                return val | (v << 5), true
 
        case objabi.R_ARM64_TLS_IE:
-               if ctxt.BuildMode == ld.BuildModePIE && ctxt.IsELF {
+               if target.IsPIE() && target.IsElf() {
                        // We are linking the final executable, so we
                        // can optimize any TLS IE relocation to LE.
                        r.Done = false
-                       if ctxt.HeadType != objabi.Hlinux {
-                               ld.Errorf(s, "TLS reloc on unsupported OS %v", ctxt.HeadType)
+                       if !target.IsLinux() {
+                               ld.Errorf(s, "TLS reloc on unsupported OS %v", target.HeadType)
                        }
 
                        // The TCB is two pointers. This is not documented anywhere, but is
                        // de facto part of the ABI.
-                       v := ld.Symaddr(r.Sym) + int64(2*ctxt.Arch.PtrSize) + r.Add
+                       v := ld.Symaddr(r.Sym) + int64(2*target.Arch.PtrSize) + r.Add
                        if v < 0 || v >= 32678 {
                                ld.Errorf(s, "TLS offset out of range %d", v)
                        }
 
                        var o0, o1 uint32
-                       if ctxt.Arch.ByteOrder == binary.BigEndian {
+                       if target.IsBigEndian() {
                                o0 = uint32(val >> 32)
                                o1 = uint32(val)
                        } else {
@@ -609,7 +608,7 @@ func archreloc(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bo
                        o1 = 0xf2800000 | uint32(o1&0x1f) | (uint32(v&0xffff) << 5)
 
                        // when laid out, the instruction order must always be o0, o1.
-                       if ctxt.Arch.ByteOrder == binary.BigEndian {
+                       if target.IsBigEndian() {
                                return int64(o0)<<32 | int64(o1), true
                        }
                        return int64(o1)<<32 | int64(o0), true
@@ -707,7 +706,7 @@ func archreloc(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bo
        return val, false
 }
 
-func archrelocvariant(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, t int64) int64 {
+func archrelocvariant(ctxt *ld.Link, target *ld.Target, 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 e4d081c564dcf3264b8dd5d5377b53010afcf6d8..d57763ba4c9fcd31e62da8ff72ef76496cd59ed8 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, r, s, o); ok {
+                       if offset, ok := thearch.Archreloc(ctxt, target, 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, r, s, o)
+                               o = thearch.Archrelocvariant(ctxt, target, r, s, o)
                        }
                }
 

diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index f702e14e5f97c44d5857741a8188c3bae7a36c4c..6ccb36896aab2be950d04c9d8a2d87a2f65be5ae 100644 (file)
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -118,7 +118,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, rel *sym.Reloc, sym *sym.Symbol,
+       Archreloc func(link *Link, target *Target, 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 +128,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, rel *sym.Reloc, sym *sym.Symbol,
+       Archrelocvariant func(link *Link, target *Target, 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/target.go b/src/cmd/link/internal/ld/target.go
index abd33f04bd20ee0991efef9f552d67026aeb8ff5..0caf2976df47b88ee1c5a7480d0b50b164bd6b10 100644 (file)
--- a/src/cmd/link/internal/ld/target.go
+++ b/src/cmd/link/internal/ld/target.go
@@ -7,6 +7,7 @@ package ld
 import (
        "cmd/internal/objabi"
        "cmd/internal/sys"
+       "encoding/binary"
 )
 
 // Target holds the configuration we're building for.
@@ -35,6 +36,10 @@ func (t *Target) IsPlugin() bool {
        return t.BuildMode == BuildModePlugin
 }
 
+func (t *Target) IsInternal() bool {
+       return t.LinkMode == LinkInternal
+}
+
 func (t *Target) IsExternal() bool {
        return t.LinkMode == LinkExternal
 }
@@ -83,6 +88,10 @@ func (t *Target) IsS390X() bool {
 // OS Functions
 //
 
+func (t *Target) IsLinux() bool {
+       return t.HeadType == objabi.Hlinux
+}
+
 func (t *Target) IsDarwin() bool {
        return t.HeadType == objabi.Hdarwin
 }
@@ -102,3 +111,11 @@ func (t *Target) IsAIX() bool {
 func (t *Target) IsSolaris() bool {
        return t.HeadType == objabi.Hsolaris
 }
+
+//
+// MISC
+//
+
+func (t *Target) IsBigEndian() bool {
+       return t.Arch.ByteOrder == binary.BigEndian
+}

diff --git a/src/cmd/link/internal/mips/asm.go b/src/cmd/link/internal/mips/asm.go
index 16c94c147a32a75750bb62891da94eab99e442d1..697daec9e2b670c6e1807ecaeae8d8a07be34e8b 100644 (file)
--- a/src/cmd/link/internal/mips/asm.go
+++ b/src/cmd/link/internal/mips/asm.go
@@ -96,8 +96,8 @@ func applyrel(arch *sys.Arch, r *sym.Reloc, s *sym.Symbol, val int64, t int64) i
        }
 }
 
-func archreloc(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
-       if ctxt.LinkMode == ld.LinkExternal {
+func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
+       if target.IsExternal() {
                switch r.Type {
                default:
                        return val, false
@@ -116,12 +116,12 @@ func archreloc(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bo
                                ld.Errorf(s, "missing section for %s", rs.Name)
                        }
                        r.Xsym = rs
-                       return applyrel(ctxt.Arch, r, s, val, r.Xadd), true
+                       return applyrel(target.Arch, r, s, val, r.Xadd), true
                case objabi.R_ADDRMIPSTLS, objabi.R_CALLMIPS, objabi.R_JMPMIPS:
                        r.Done = false
                        r.Xsym = r.Sym
                        r.Xadd = r.Add
-                       return applyrel(ctxt.Arch, r, s, val, r.Add), true
+                       return applyrel(target.Arch, r, s, val, r.Add), true
                }
        }
 
@@ -132,7 +132,7 @@ func archreloc(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bo
                return ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(ctxt.Syms.Lookup(".got", 0)), true
        case objabi.R_ADDRMIPS, objabi.R_ADDRMIPSU:
                t := ld.Symaddr(r.Sym) + r.Add
-               return applyrel(ctxt.Arch, r, s, val, t), true
+               return applyrel(target.Arch, r, s, val, t), true
        case objabi.R_CALLMIPS, objabi.R_JMPMIPS:
                t := ld.Symaddr(r.Sym) + r.Add
 
@@ -145,20 +145,20 @@ func archreloc(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bo
                        ld.Errorf(s, "direct call too far: %s %x", r.Sym.Name, t)
                }
 
-               return applyrel(ctxt.Arch, r, s, val, t), true
+               return applyrel(target.Arch, r, s, val, t), true
        case objabi.R_ADDRMIPSTLS:
                // thread pointer is at 0x7000 offset from the start of TLS data area
                t := ld.Symaddr(r.Sym) + r.Add - 0x7000
                if t < -32768 || t >= 32678 {
                        ld.Errorf(s, "TLS offset out of range %d", t)
                }
-               return applyrel(ctxt.Arch, r, s, val, t), true
+               return applyrel(target.Arch, r, s, val, t), true
        }
 
        return val, false
 }
 
-func archrelocvariant(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, t int64) int64 {
+func archrelocvariant(ctxt *ld.Link, target *ld.Target, 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 5c6fef9c5bec111a05c6a8b753404acc615ae89d..cc1f858dadf0a23276cbab4a7335d6478df5fd78 100644 (file)
--- a/src/cmd/link/internal/mips64/asm.go
+++ b/src/cmd/link/internal/mips64/asm.go
@@ -99,8 +99,8 @@ func machoreloc1(arch *sys.Arch, out *ld.OutBuf, s *sym.Symbol, r *sym.Reloc, se
        return false
 }
 
-func archreloc(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
-       if ctxt.LinkMode == ld.LinkExternal {
+func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
+       if target.IsExternal() {
                switch r.Type {
                default:
                        return val, false
@@ -140,7 +140,7 @@ func archreloc(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bo
        case objabi.R_ADDRMIPS,
                objabi.R_ADDRMIPSU:
                t := ld.Symaddr(r.Sym) + r.Add
-               o1 := ctxt.Arch.ByteOrder.Uint32(s.P[r.Off:])
+               o1 := target.Arch.ByteOrder.Uint32(s.P[r.Off:])
                if r.Type == objabi.R_ADDRMIPS {
                        return int64(o1&0xffff0000 | uint32(t)&0xffff), true
                }
@@ -151,20 +151,20 @@ func archreloc(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bo
                if t < -32768 || t >= 32678 {
                        ld.Errorf(s, "TLS offset out of range %d", t)
                }
-               o1 := ctxt.Arch.ByteOrder.Uint32(s.P[r.Off:])
+               o1 := target.Arch.ByteOrder.Uint32(s.P[r.Off:])
                return int64(o1&0xffff0000 | uint32(t)&0xffff), true
        case objabi.R_CALLMIPS,
                objabi.R_JMPMIPS:
                // Low 26 bits = (S + A) >> 2
                t := ld.Symaddr(r.Sym) + r.Add
-               o1 := ctxt.Arch.ByteOrder.Uint32(s.P[r.Off:])
+               o1 := target.Arch.ByteOrder.Uint32(s.P[r.Off:])
                return int64(o1&0xfc000000 | uint32(t>>2)&^0xfc000000), true
        }
 
        return val, false
 }
 
-func archrelocvariant(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, t int64) int64 {
+func archrelocvariant(ctxt *ld.Link, target *ld.Target, 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 99173a5b9cacb308485e918fe9fd79870bc6fd81..2a31a16c9b3214a9a1bec719056244d218fd9af2 100644 (file)
--- a/src/cmd/link/internal/ppc64/asm.go
+++ b/src/cmd/link/internal/ppc64/asm.go
@@ -536,8 +536,8 @@ func symtoc(ctxt *ld.Link, s *sym.Symbol) int64 {
 // 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, r *sym.Reloc, s *sym.Symbol, val int64) int64 {
-       if ctxt.HeadType == objabi.Hlinux {
+func archreloctoc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, val int64) int64 {
+       if target.IsLinux() {
                ld.Errorf(s, "archrelocaddr called for %s relocation\n", r.Sym.Name)
        }
        var o1, o2 uint32
@@ -555,7 +555,7 @@ func archreloctoc(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) int64 {
                ld.Errorf(s, "archreloctoc called for a symbol without TOC anchor")
        }
 
-       if ctxt.LinkMode == ld.LinkInternal && tarSym != nil && tarSym.Attr.Reachable() && (tarSym.Sect.Seg == &ld.Segdata) {
+       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
                // change ld to addi in the second instruction
                o2 = (o2 & 0x03FF0000) | 0xE<<26
@@ -593,12 +593,12 @@ func archreloctoc(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) int64 {
 
 // archrelocaddr relocates a symbol address.
 // This code is for AIX only.
-func archrelocaddr(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) int64 {
-       if ctxt.HeadType == objabi.Haix {
+func archrelocaddr(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, val int64) int64 {
+       if target.IsAIX() {
                ld.Errorf(s, "archrelocaddr called for %s relocation\n", r.Sym.Name)
        }
        var o1, o2 uint32
-       if ctxt.Arch.ByteOrder == binary.BigEndian {
+       if target.IsBigEndian() {
                o1 = uint32(val >> 32)
                o2 = uint32(val)
        } else {
@@ -635,7 +635,7 @@ func archrelocaddr(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) int64
                return -1
        }
 
-       if ctxt.Arch.ByteOrder == binary.BigEndian {
+       if target.IsBigEndian() {
                return int64(o1)<<32 | int64(o2)
        }
        return int64(o2)<<32 | int64(o1)
@@ -770,7 +770,7 @@ func gentramp(ctxt *ld.Link, tramp, target *sym.Symbol, offset int64) {
        ctxt.Arch.ByteOrder.PutUint32(tramp.P[12:], o4)
 }
 
-func archreloc(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
+func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
        if ctxt.LinkMode == ld.LinkExternal {
                // On AIX, relocations (except TLS ones) must be also done to the
                // value with the current addresses.
@@ -825,9 +825,9 @@ func archreloc(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bo
        case objabi.R_GOTOFF:
                return ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(ctxt.Syms.Lookup(".got", 0)), true
        case objabi.R_ADDRPOWER_TOCREL, objabi.R_ADDRPOWER_TOCREL_DS:
-               return archreloctoc(ctxt, r, s, val), true
+               return archreloctoc(ctxt, &ctxt.Target, r, s, val), true
        case objabi.R_ADDRPOWER, objabi.R_ADDRPOWER_DS:
-               return archrelocaddr(ctxt, r, s, val), true
+               return archrelocaddr(ctxt, target, r, s, val), true
        case objabi.R_CALLPOWER:
                // Bits 6 through 29 = (S + A - P) >> 2
 
@@ -865,7 +865,7 @@ func archreloc(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bo
        return val, false
 }
 
-func archrelocvariant(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, t int64) int64 {
+func archrelocvariant(ctxt *ld.Link, taget *ld.Target, 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/riscv64/asm.go b/src/cmd/link/internal/riscv64/asm.go
index b0897288fcf13b99c51fad4dad144ff05fbc6493..9cc463a2962be1e3c529dcd251f72dbaf985d2bf 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, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
+func archreloc(ctxt *ld.Link, target *ld.Target, 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, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bo
        return val, false
 }
 
-func archrelocvariant(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, t int64) int64 {
+func archrelocvariant(ctxt *ld.Link, target *ld.Target, 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 94a5a2f86c5ec5e95478b106862f698d76e860de..44547db77ffec4839d91dda429fe3884e0162695 100644 (file)
--- a/src/cmd/link/internal/s390x/asm.go
+++ b/src/cmd/link/internal/s390x/asm.go
@@ -387,8 +387,8 @@ func machoreloc1(arch *sys.Arch, out *ld.OutBuf, s *sym.Symbol, r *sym.Reloc, se
        return false
 }
 
-func archreloc(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
-       if ctxt.LinkMode == ld.LinkExternal {
+func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
+       if target.IsExternal() {
                return val, false
        }
 
@@ -402,7 +402,7 @@ func archreloc(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bo
        return val, false
 }
 
-func archrelocvariant(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, t int64) int64 {
+func archrelocvariant(ctxt *ld.Link, target *ld.Target, 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 3fe36db64da0a139b306785a00baed05abb86c42..1a409810fd6fa0441719f2f52ada5989b49fa4a4 100644 (file)
--- a/src/cmd/link/internal/x86/asm.go
+++ b/src/cmd/link/internal/x86/asm.go
@@ -492,8 +492,8 @@ func pereloc1(arch *sys.Arch, out *ld.OutBuf, s *sym.Symbol, r *sym.Reloc, secto
        return true
 }
 
-func archreloc(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
-       if ctxt.LinkMode == ld.LinkExternal {
+func archreloc(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) {
+       if target.IsExternal() {
                return val, false
        }
        switch r.Type {
@@ -506,7 +506,7 @@ func archreloc(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bo
        return val, false
 }
 
-func archrelocvariant(ctxt *ld.Link, r *sym.Reloc, s *sym.Symbol, t int64) int64 {
+func archrelocvariant(ctxt *ld.Link, target *ld.Target, r *sym.Reloc, s *sym.Symbol, t int64) int64 {
        log.Fatalf("unexpected relocation variant")
        return t
 }