[dev.link] cmd/link: remove *Link from elf functions

dodata is a pile of dependencies on *Link. Pull some of these
dependencies out, and tighten up the visibility on the functions.

Change-Id: Id213f19ae7b63dd246ddb47b77ffde99f615aa80
Reviewed-on: https://go-review.googlesource.com/c/go/+/222061
Reviewed-by: Than McIntosh <thanm@google.com>

diff --git a/src/cmd/link/internal/amd64/asm.go b/src/cmd/link/internal/amd64/asm.go
index 3e9bba3af473ca7efc6c04a64b29feeb8823e3b2..de5a96507f9aefd0a521af06933e0e76a9b40fcb 100644 (file)
--- a/src/cmd/link/internal/amd64/asm.go
+++ b/src/cmd/link/internal/amd64/asm.go
@@ -381,7 +381,7 @@ func adddynrel(ctxt *ld.Link, s *sym.Symbol, r *sym.Reloc) bool {
                        // just in case the C code assigns to the variable,
                        // and of course it only works for single pointers,
                        // but we only need to support cgo and that's all it needs.
-                       ld.Adddynsym(ctxt, targ)
+                       ld.Adddynsym(&ctxt.Target, &ctxt.ArchSyms, targ)
 
                        got := ctxt.Syms.Lookup(".got", 0)
                        s.Type = got.Type
@@ -604,7 +604,7 @@ func addpltsym(ctxt *ld.Link, s *sym.Symbol) {
                return
        }
 
-       ld.Adddynsym(ctxt, s)
+       ld.Adddynsym(&ctxt.Target, &ctxt.ArchSyms, s)
 
        if ctxt.IsELF {
                plt := ctxt.Syms.Lookup(".plt", 0)
@@ -672,7 +672,7 @@ func addgotsym(ctxt *ld.Link, s *sym.Symbol) {
                return
        }
 
-       ld.Adddynsym(ctxt, s)
+       ld.Adddynsym(&ctxt.Target, &ctxt.ArchSyms, s)
        got := ctxt.Syms.Lookup(".got", 0)
        s.SetGot(int32(got.Size))
        got.AddUint64(ctxt.Arch, 0)

diff --git a/src/cmd/link/internal/arm/asm.go b/src/cmd/link/internal/arm/asm.go
index 457adb783ec4c15e62b5e15c1c0a65ef22154faf..233383432419ade97ae6e0715ff002fc26b9c2a7 100644 (file)
--- a/src/cmd/link/internal/arm/asm.go
+++ b/src/cmd/link/internal/arm/asm.go
@@ -243,7 +243,7 @@ func adddynrel(ctxt *ld.Link, s *sym.Symbol, r *sym.Reloc) bool {
                        break
                }
                if ctxt.IsELF {
-                       ld.Adddynsym(ctxt, targ)
+                       ld.Adddynsym(&ctxt.Target, &ctxt.ArchSyms, targ)
                        rel := ctxt.Syms.Lookup(".rel", 0)
                        rel.AddAddrPlus(ctxt.Arch, s, int64(r.Off))
                        rel.AddUint32(ctxt.Arch, ld.ELF32_R_INFO(uint32(targ.Dynid), uint32(elf.R_ARM_GLOB_DAT))) // we need a nil + A dynamic reloc
@@ -690,7 +690,7 @@ func addpltsym(ctxt *ld.Link, s *sym.Symbol) {
                return
        }
 
-       ld.Adddynsym(ctxt, s)
+       ld.Adddynsym(&ctxt.Target, &ctxt.ArchSyms, s)
 
        if ctxt.IsELF {
                plt := ctxt.Syms.Lookup(".plt", 0)
@@ -745,7 +745,7 @@ func addgotsym(ctxt *ld.Link, s *sym.Symbol) {
                return
        }
 
-       ld.Adddynsym(ctxt, s)
+       ld.Adddynsym(&ctxt.Target, &ctxt.ArchSyms, s)
        got := ctxt.Syms.Lookup(".got", 0)
        s.SetGot(int32(got.Size))
        got.AddUint32(ctxt.Arch, 0)

diff --git a/src/cmd/link/internal/arm64/asm.go b/src/cmd/link/internal/arm64/asm.go
index f03a4efc8d8f59a0f0bd13f0443166aa3f4ba995..33a1c851b69dea7057707b8c9fcd2fe418651ce1 100644 (file)
--- a/src/cmd/link/internal/arm64/asm.go
+++ b/src/cmd/link/internal/arm64/asm.go
@@ -760,7 +760,7 @@ func addpltsym(ctxt *ld.Link, s *sym.Symbol) {
                return
        }
 
-       ld.Adddynsym(ctxt, s)
+       ld.Adddynsym(&ctxt.Target, &ctxt.ArchSyms, s)
 
        if ctxt.IsELF {
                plt := ctxt.Syms.Lookup(".plt", 0)
@@ -808,7 +808,7 @@ func addgotsym(ctxt *ld.Link, s *sym.Symbol) {
                return
        }
 
-       ld.Adddynsym(ctxt, s)
+       ld.Adddynsym(&ctxt.Target, &ctxt.ArchSyms, s)
        got := ctxt.Syms.Lookup(".got", 0)
        s.SetGot(int32(got.Size))
        got.AddUint64(ctxt.Arch, 0)

diff --git a/src/cmd/link/internal/ld/elf.go b/src/cmd/link/internal/ld/elf.go
index b7221f04b308b45518a7b7aee427d2c93f82d016..d7db1b816cca79909a63b306ba6546f2a25bcee8 100644 (file)
--- a/src/cmd/link/internal/ld/elf.go
+++ b/src/cmd/link/internal/ld/elf.go
@@ -742,36 +742,36 @@ func elfhash(name string) uint32 {
        return h
 }
 
-func Elfwritedynent(ctxt *Link, s *sym.Symbol, tag int, val uint64) {
+func elfWriteDynEnt(arch *sys.Arch, s *sym.Symbol, tag int, val uint64) {
        if elf64 {
-               s.AddUint64(ctxt.Arch, uint64(tag))
-               s.AddUint64(ctxt.Arch, val)
+               s.AddUint64(arch, uint64(tag))
+               s.AddUint64(arch, val)
        } else {
-               s.AddUint32(ctxt.Arch, uint32(tag))
-               s.AddUint32(ctxt.Arch, uint32(val))
+               s.AddUint32(arch, uint32(tag))
+               s.AddUint32(arch, uint32(val))
        }
 }
 
-func elfwritedynentsym(ctxt *Link, s *sym.Symbol, tag int, t *sym.Symbol) {
-       Elfwritedynentsymplus(ctxt, s, tag, t, 0)
+func elfWriteDynEntSym(arch *sys.Arch, s *sym.Symbol, tag int, t *sym.Symbol) {
+       Elfwritedynentsymplus(arch, s, tag, t, 0)
 }
 
-func Elfwritedynentsymplus(ctxt *Link, s *sym.Symbol, tag int, t *sym.Symbol, add int64) {
+func Elfwritedynentsymplus(arch *sys.Arch, s *sym.Symbol, tag int, t *sym.Symbol, add int64) {
        if elf64 {
-               s.AddUint64(ctxt.Arch, uint64(tag))
+               s.AddUint64(arch, uint64(tag))
        } else {
-               s.AddUint32(ctxt.Arch, uint32(tag))
+               s.AddUint32(arch, uint32(tag))
        }
-       s.AddAddrPlus(ctxt.Arch, t, add)
+       s.AddAddrPlus(arch, t, add)
 }
 
-func elfwritedynentsymsize(ctxt *Link, s *sym.Symbol, tag int, t *sym.Symbol) {
+func elfWriteDynEntSymSize(arch *sys.Arch, s *sym.Symbol, tag int, t *sym.Symbol) {
        if elf64 {
-               s.AddUint64(ctxt.Arch, uint64(tag))
+               s.AddUint64(arch, uint64(tag))
        } else {
-               s.AddUint32(ctxt.Arch, uint32(tag))
+               s.AddUint32(arch, uint32(tag))
        }
-       s.AddSize(ctxt.Arch, t)
+       s.AddSize(arch, t)
 }
 
 func elfinterp(sh *ElfShdr, startva uint64, resoff uint64, p string) int {
@@ -1121,23 +1121,23 @@ func elfdynhash(ctxt *Link) {
        s = ctxt.Syms.Lookup(".dynamic", 0)
        elfverneed = nfile
        if elfverneed != 0 {
-               elfwritedynentsym(ctxt, s, DT_VERNEED, ctxt.Syms.Lookup(".gnu.version_r", 0))
-               Elfwritedynent(ctxt, s, DT_VERNEEDNUM, uint64(nfile))
-               elfwritedynentsym(ctxt, s, DT_VERSYM, ctxt.Syms.Lookup(".gnu.version", 0))
+               elfWriteDynEntSym(ctxt.Arch, s, DT_VERNEED, ctxt.Syms.Lookup(".gnu.version_r", 0))
+               elfWriteDynEnt(ctxt.Arch, s, DT_VERNEEDNUM, uint64(nfile))
+               elfWriteDynEntSym(ctxt.Arch, s, DT_VERSYM, ctxt.Syms.Lookup(".gnu.version", 0))
        }
 
        sy := ctxt.Syms.Lookup(elfRelType+".plt", 0)
        if sy.Size > 0 {
                if elfRelType == ".rela" {
-                       Elfwritedynent(ctxt, s, DT_PLTREL, DT_RELA)
+                       elfWriteDynEnt(ctxt.Arch, s, DT_PLTREL, DT_RELA)
                } else {
-                       Elfwritedynent(ctxt, s, DT_PLTREL, DT_REL)
+                       elfWriteDynEnt(ctxt.Arch, s, DT_PLTREL, DT_REL)
                }
-               elfwritedynentsymsize(ctxt, s, DT_PLTRELSZ, sy)
-               elfwritedynentsym(ctxt, s, DT_JMPREL, sy)
+               elfWriteDynEntSymSize(ctxt.Arch, s, DT_PLTRELSZ, sy)
+               elfWriteDynEntSym(ctxt.Arch, s, DT_JMPREL, sy)
        }
 
-       Elfwritedynent(ctxt, s, DT_NULL, 0)
+       elfWriteDynEnt(ctxt.Arch, s, DT_NULL, 0)
 }
 
 func elfphload(seg *sym.Segment) *ElfPhdr {
@@ -1622,47 +1622,47 @@ func (ctxt *Link) doelf() {
                /*
                 * .dynamic table
                 */
-               elfwritedynentsym(ctxt, s, DT_HASH, ctxt.Syms.Lookup(".hash", 0))
+               elfWriteDynEntSym(ctxt.Arch, s, DT_HASH, ctxt.Syms.Lookup(".hash", 0))
 
-               elfwritedynentsym(ctxt, s, DT_SYMTAB, ctxt.Syms.Lookup(".dynsym", 0))
+               elfWriteDynEntSym(ctxt.Arch, s, DT_SYMTAB, ctxt.Syms.Lookup(".dynsym", 0))
                if elf64 {
-                       Elfwritedynent(ctxt, s, DT_SYMENT, ELF64SYMSIZE)
+                       elfWriteDynEnt(ctxt.Arch, s, DT_SYMENT, ELF64SYMSIZE)
                } else {
-                       Elfwritedynent(ctxt, s, DT_SYMENT, ELF32SYMSIZE)
+                       elfWriteDynEnt(ctxt.Arch, s, DT_SYMENT, ELF32SYMSIZE)
                }
-               elfwritedynentsym(ctxt, s, DT_STRTAB, ctxt.Syms.Lookup(".dynstr", 0))
-               elfwritedynentsymsize(ctxt, s, DT_STRSZ, ctxt.Syms.Lookup(".dynstr", 0))
+               elfWriteDynEntSym(ctxt.Arch, s, DT_STRTAB, ctxt.Syms.Lookup(".dynstr", 0))
+               elfWriteDynEntSymSize(ctxt.Arch, s, DT_STRSZ, ctxt.Syms.Lookup(".dynstr", 0))
                if elfRelType == ".rela" {
-                       elfwritedynentsym(ctxt, s, DT_RELA, ctxt.Syms.Lookup(".rela", 0))
-                       elfwritedynentsymsize(ctxt, s, DT_RELASZ, ctxt.Syms.Lookup(".rela", 0))
-                       Elfwritedynent(ctxt, s, DT_RELAENT, ELF64RELASIZE)
+                       elfWriteDynEntSym(ctxt.Arch, s, DT_RELA, ctxt.Syms.Lookup(".rela", 0))
+                       elfWriteDynEntSymSize(ctxt.Arch, s, DT_RELASZ, ctxt.Syms.Lookup(".rela", 0))
+                       elfWriteDynEnt(ctxt.Arch, s, DT_RELAENT, ELF64RELASIZE)
                } else {
-                       elfwritedynentsym(ctxt, s, DT_REL, ctxt.Syms.Lookup(".rel", 0))
-                       elfwritedynentsymsize(ctxt, s, DT_RELSZ, ctxt.Syms.Lookup(".rel", 0))
-                       Elfwritedynent(ctxt, s, DT_RELENT, ELF32RELSIZE)
+                       elfWriteDynEntSym(ctxt.Arch, s, DT_REL, ctxt.Syms.Lookup(".rel", 0))
+                       elfWriteDynEntSymSize(ctxt.Arch, s, DT_RELSZ, ctxt.Syms.Lookup(".rel", 0))
+                       elfWriteDynEnt(ctxt.Arch, s, DT_RELENT, ELF32RELSIZE)
                }
 
                if rpath.val != "" {
-                       Elfwritedynent(ctxt, s, DT_RUNPATH, uint64(Addstring(dynstr, rpath.val)))
+                       elfWriteDynEnt(ctxt.Arch, s, DT_RUNPATH, uint64(Addstring(dynstr, rpath.val)))
                }
 
                if ctxt.Arch.Family == sys.PPC64 {
-                       elfwritedynentsym(ctxt, s, DT_PLTGOT, ctxt.Syms.Lookup(".plt", 0))
+                       elfWriteDynEntSym(ctxt.Arch, s, DT_PLTGOT, ctxt.Syms.Lookup(".plt", 0))
                } else if ctxt.Arch.Family == sys.S390X {
-                       elfwritedynentsym(ctxt, s, DT_PLTGOT, ctxt.Syms.Lookup(".got", 0))
+                       elfWriteDynEntSym(ctxt.Arch, s, DT_PLTGOT, ctxt.Syms.Lookup(".got", 0))
                } else {
-                       elfwritedynentsym(ctxt, s, DT_PLTGOT, ctxt.Syms.Lookup(".got.plt", 0))
+                       elfWriteDynEntSym(ctxt.Arch, s, DT_PLTGOT, ctxt.Syms.Lookup(".got.plt", 0))
                }
 
                if ctxt.Arch.Family == sys.PPC64 {
-                       Elfwritedynent(ctxt, s, DT_PPC64_OPT, 0)
+                       elfWriteDynEnt(ctxt.Arch, s, DT_PPC64_OPT, 0)
                }
 
                // Solaris dynamic linker can't handle an empty .rela.plt if
                // DT_JMPREL is emitted so we have to defer generation of DT_PLTREL,
                // DT_PLTRELSZ, and DT_JMPREL dynamic entries until after we know the
                // size of .rel(a).plt section.
-               Elfwritedynent(ctxt, s, DT_DEBUG, 0)
+               elfWriteDynEnt(ctxt.Arch, s, DT_DEBUG, 0)
        }
 
        if ctxt.BuildMode == BuildModeShared {
@@ -2271,15 +2271,15 @@ elfobj:
        }
 }
 
-func elfadddynsym(ctxt *Link, s *sym.Symbol) {
+func elfadddynsym(target *Target, syms *ArchSyms, s *sym.Symbol) {
        if elf64 {
                s.Dynid = int32(Nelfsym)
                Nelfsym++
 
-               d := ctxt.Syms.Lookup(".dynsym", 0)
+               d := syms.DynSym
 
                name := s.Extname()
-               d.AddUint32(ctxt.Arch, uint32(Addstring(ctxt.Syms.Lookup(".dynstr", 0), name)))
+               d.AddUint32(target.Arch, uint32(Addstring(syms.DynStr, name)))
 
                /* type */
                t := STB_GLOBAL << 4
@@ -2296,52 +2296,52 @@ func elfadddynsym(ctxt *Link, s *sym.Symbol) {
 
                /* section where symbol is defined */
                if s.Type == sym.SDYNIMPORT {
-                       d.AddUint16(ctxt.Arch, SHN_UNDEF)
+                       d.AddUint16(target.Arch, SHN_UNDEF)
                } else {
-                       d.AddUint16(ctxt.Arch, 1)
+                       d.AddUint16(target.Arch, 1)
                }
 
                /* value */
                if s.Type == sym.SDYNIMPORT {
-                       d.AddUint64(ctxt.Arch, 0)
+                       d.AddUint64(target.Arch, 0)
                } else {
-                       d.AddAddr(ctxt.Arch, s)
+                       d.AddAddr(target.Arch, s)
                }
 
                /* size of object */
-               d.AddUint64(ctxt.Arch, uint64(s.Size))
+               d.AddUint64(target.Arch, uint64(s.Size))
 
-               if ctxt.Arch.Family == sys.AMD64 && !s.Attr.CgoExportDynamic() && s.Dynimplib() != "" && !seenlib[s.Dynimplib()] {
-                       Elfwritedynent(ctxt, ctxt.Syms.Lookup(".dynamic", 0), DT_NEEDED, uint64(Addstring(ctxt.Syms.Lookup(".dynstr", 0), s.Dynimplib())))
+               if target.Arch.Family == sys.AMD64 && !s.Attr.CgoExportDynamic() && s.Dynimplib() != "" && !seenlib[s.Dynimplib()] {
+                       elfWriteDynEnt(target.Arch, syms.Dynamic, DT_NEEDED, uint64(Addstring(syms.DynStr, s.Dynimplib())))
                }
        } else {
                s.Dynid = int32(Nelfsym)
                Nelfsym++
 
-               d := ctxt.Syms.Lookup(".dynsym", 0)
+               d := syms.DynSym
 
                /* name */
                name := s.Extname()
 
-               d.AddUint32(ctxt.Arch, uint32(Addstring(ctxt.Syms.Lookup(".dynstr", 0), name)))
+               d.AddUint32(target.Arch, uint32(Addstring(syms.DynStr, name)))
 
                /* value */
                if s.Type == sym.SDYNIMPORT {
-                       d.AddUint32(ctxt.Arch, 0)
+                       d.AddUint32(target.Arch, 0)
                } else {
-                       d.AddAddr(ctxt.Arch, s)
+                       d.AddAddr(target.Arch, s)
                }
 
                /* size of object */
-               d.AddUint32(ctxt.Arch, uint32(s.Size))
+               d.AddUint32(target.Arch, uint32(s.Size))
 
                /* type */
                t := STB_GLOBAL << 4
 
                // TODO(mwhudson): presumably the behavior should actually be the same on both arm and 386.
-               if ctxt.Arch.Family == sys.I386 && s.Attr.CgoExport() && s.Type == sym.STEXT {
+               if target.Arch.Family == sys.I386 && s.Attr.CgoExport() && s.Type == sym.STEXT {
                        t |= STT_FUNC
-               } else if ctxt.Arch.Family == sys.ARM && s.Attr.CgoExportDynamic() && s.Type == sym.STEXT {
+               } else if target.Arch.Family == sys.ARM && s.Attr.CgoExportDynamic() && s.Type == sym.STEXT {
                        t |= STT_FUNC
                } else {
                        t |= STT_OBJECT
@@ -2351,9 +2351,9 @@ func elfadddynsym(ctxt *Link, s *sym.Symbol) {
 
                /* shndx */
                if s.Type == sym.SDYNIMPORT {
-                       d.AddUint16(ctxt.Arch, SHN_UNDEF)
+                       d.AddUint16(target.Arch, SHN_UNDEF)
                } else {
-                       d.AddUint16(ctxt.Arch, 1)
+                       d.AddUint16(target.Arch, 1)
                }
        }
 }

diff --git a/src/cmd/link/internal/ld/go.go b/src/cmd/link/internal/ld/go.go
index 8e6b8ee6b90faad5ec96de52bf45198e3679551e..55d82655778716d1cd4f315fdf402a2939f2d4e0 100644 (file)
--- a/src/cmd/link/internal/ld/go.go
+++ b/src/cmd/link/internal/ld/go.go
@@ -320,26 +320,26 @@ func adddynlib(ctxt *Link, lib string) {
        seenlib[lib] = true
 
        if ctxt.IsELF {
-               s := ctxt.Syms.Lookup(".dynstr", 0)
+               s := ctxt.DynStr
                if s.Size == 0 {
                        Addstring(s, "")
                }
-               Elfwritedynent(ctxt, ctxt.Syms.Lookup(".dynamic", 0), DT_NEEDED, uint64(Addstring(s, lib)))
+               elfWriteDynEnt(ctxt.Arch, ctxt.Dynamic, DT_NEEDED, uint64(Addstring(s, lib)))
        } else {
                Errorf(nil, "adddynlib: unsupported binary format")
        }
 }
 
-func Adddynsym(ctxt *Link, s *sym.Symbol) {
-       if s.Dynid >= 0 || ctxt.LinkMode == LinkExternal {
+func Adddynsym(target *Target, syms *ArchSyms, s *sym.Symbol) {
+       if s.Dynid >= 0 || target.LinkMode == LinkExternal {
                return
        }
 
-       if ctxt.IsELF {
-               elfadddynsym(ctxt, s)
-       } else if ctxt.HeadType == objabi.Hdarwin {
+       if target.IsELF {
+               elfadddynsym(target, syms, s)
+       } else if target.HeadType == objabi.Hdarwin {
                Errorf(s, "adddynsym: missed symbol (Extname=%s)", s.Extname())
-       } else if ctxt.HeadType == objabi.Hwindows {
+       } else if target.HeadType == objabi.Hwindows {
                // already taken care of
        } else {
                Errorf(s, "adddynsym: unsupported binary format")
@@ -403,7 +403,7 @@ func (ctxt *Link) addexport() {
        }
 
        for _, exp := range dynexp {
-               Adddynsym(ctxt, exp)
+               Adddynsym(&ctxt.Target, &ctxt.ArchSyms, exp)
        }
        for _, lib := range dynlib {
                adddynlib(ctxt, lib)

diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index a133ee20fc883c0626bc3a47a3632580755cfa7a..6ef0ac3ca6f410588c0d311a0bb9c1a37d33e52e 100644 (file)
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -108,6 +108,10 @@ type ArchSyms struct {
 
        Tlsg      *sym.Symbol
        Tlsoffset int
+
+       Dynamic *sym.Symbol
+       DynSym  *sym.Symbol
+       DynStr  *sym.Symbol
 }
 
 // setArchSyms sets up the ArchSyms structure, and must be called before
@@ -118,6 +122,10 @@ func (ctxt *Link) setArchSyms() {
        ctxt.GOT = ctxt.Syms.Lookup(".got", 0)
        ctxt.PLT = ctxt.Syms.Lookup(".plt", 0)
        ctxt.GOTPLT = ctxt.Syms.Lookup(".got.plt", 0)
+
+       ctxt.Dynamic = ctxt.Syms.Lookup(".dynamic", 0)
+       ctxt.DynSym = ctxt.Syms.Lookup(".dynsym", 0)
+       ctxt.DynStr = ctxt.Syms.Lookup(".dynstr", 0)
 }
 
 type Arch struct {

diff --git a/src/cmd/link/internal/ld/main.go b/src/cmd/link/internal/ld/main.go
index 6964ea59ff4fbed1f41ced1ca8de6d9c4ede99ec..7f66d271790c326b9dc7ae22c46b4ecfa2fae6e5 100644 (file)
--- a/src/cmd/link/internal/ld/main.go
+++ b/src/cmd/link/internal/ld/main.go
@@ -280,6 +280,7 @@ func Main(arch *sys.Arch, theArch Arch) {
        bench.Start("mangleTypeSym")
        ctxt.mangleTypeSym()
 
+       ctxt.setArchSyms()
        bench.Start("addexport")
        ctxt.addexport()
        bench.Start("Gentext")
@@ -303,7 +304,6 @@ 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/ppc64/asm.go b/src/cmd/link/internal/ppc64/asm.go
index 9548aef5f8df26a32a120d7f9a8a587d2681d1ea..b0a85f3a436563d74da0bd98118809383760f7ba 100644 (file)
--- a/src/cmd/link/internal/ppc64/asm.go
+++ b/src/cmd/link/internal/ppc64/asm.go
@@ -313,7 +313,7 @@ func addelfdynrel(ctxt *ld.Link, s *sym.Symbol, r *sym.Reloc) bool {
                r.Type = objabi.R_ADDR
                if targ.Type == sym.SDYNIMPORT {
                        // These happen in .toc sections
-                       ld.Adddynsym(ctxt, targ)
+                       ld.Adddynsym(&ctxt.Target, &ctxt.ArchSyms, targ)
 
                        rela := ctxt.Syms.Lookup(".rela", 0)
                        rela.AddAddrPlus(ctxt.Arch, s, int64(r.Off))
@@ -943,7 +943,7 @@ func addpltsym(ctxt *ld.Link, s *sym.Symbol) {
                return
        }
 
-       ld.Adddynsym(ctxt, s)
+       ld.Adddynsym(&ctxt.Target, &ctxt.ArchSyms, s)
 
        if ctxt.IsELF {
                plt := ctxt.Syms.Lookup(".plt", 0)
@@ -1038,7 +1038,7 @@ func ensureglinkresolver(ctxt *ld.Link) *sym.Symbol {
        // before the first symbol resolver stub.
        s := ctxt.Syms.Lookup(".dynamic", 0)
 
-       ld.Elfwritedynentsymplus(ctxt, s, ld.DT_PPC64_GLINK, glink, glink.Size-32)
+       ld.Elfwritedynentsymplus(ctxt.Arch, s, ld.DT_PPC64_GLINK, glink, glink.Size-32)
 
        return glink
 }

diff --git a/src/cmd/link/internal/s390x/asm.go b/src/cmd/link/internal/s390x/asm.go
index 030266fe9b4b34b9487babb436ef818bff1e4426..0d7199a16fbd89f6b7be46dba4c007e0744b7ace 100644 (file)
--- a/src/cmd/link/internal/s390x/asm.go
+++ b/src/cmd/link/internal/s390x/asm.go
@@ -424,7 +424,7 @@ func addpltsym(ctxt *ld.Link, s *sym.Symbol) {
                return
        }
 
-       ld.Adddynsym(ctxt, s)
+       ld.Adddynsym(&ctxt.Target, &ctxt.ArchSyms, s)
 
        if ctxt.IsELF {
                plt := ctxt.Syms.Lookup(".plt", 0)
@@ -487,7 +487,7 @@ func addgotsym(ctxt *ld.Link, s *sym.Symbol) {
                return
        }
 
-       ld.Adddynsym(ctxt, s)
+       ld.Adddynsym(&ctxt.Target, &ctxt.ArchSyms, s)
        got := ctxt.Syms.Lookup(".got", 0)
        s.SetGot(int32(got.Size))
        got.AddUint64(ctxt.Arch, 0)

diff --git a/src/cmd/link/internal/x86/asm.go b/src/cmd/link/internal/x86/asm.go
index d53454e20a4fbf5c7f24908bea3d489908839de4..a246be2b5762c057a4567fa144b3fd3a4b504164 100644 (file)
--- a/src/cmd/link/internal/x86/asm.go
+++ b/src/cmd/link/internal/x86/asm.go
@@ -312,7 +312,7 @@ func adddynrel(ctxt *ld.Link, s *sym.Symbol, r *sym.Reloc) bool {
                        break
                }
                if ctxt.IsELF {
-                       ld.Adddynsym(ctxt, targ)
+                       ld.Adddynsym(&ctxt.Target, &ctxt.ArchSyms, targ)
                        rel := ctxt.Syms.Lookup(".rel", 0)
                        rel.AddAddrPlus(ctxt.Arch, s, int64(r.Off))
                        rel.AddUint32(ctxt.Arch, ld.ELF32_R_INFO(uint32(targ.Dynid), uint32(elf.R_386_32)))
@@ -332,7 +332,7 @@ func adddynrel(ctxt *ld.Link, s *sym.Symbol, r *sym.Reloc) bool {
                        // just in case the C code assigns to the variable,
                        // and of course it only works for single pointers,
                        // but we only need to support cgo and that's all it needs.
-                       ld.Adddynsym(ctxt, targ)
+                       ld.Adddynsym(&ctxt.Target, &ctxt.ArchSyms, targ)
 
                        got := ctxt.Syms.Lookup(".got", 0)
                        s.Type = got.Type
@@ -543,7 +543,7 @@ func addpltsym(ctxt *ld.Link, s *sym.Symbol) {
                return
        }
 
-       ld.Adddynsym(ctxt, s)
+       ld.Adddynsym(&ctxt.Target, &ctxt.ArchSyms, s)
 
        if ctxt.IsELF {
                plt := ctxt.Syms.Lookup(".plt", 0)
@@ -603,7 +603,7 @@ func addgotsym(ctxt *ld.Link, s *sym.Symbol) {
                return
        }
 
-       ld.Adddynsym(ctxt, s)
+       ld.Adddynsym(&ctxt.Target, &ctxt.ArchSyms, s)
        got := ctxt.Syms.Lookup(".got", 0)
        s.SetGot(int32(got.Size))
        got.AddUint32(ctxt.Arch, 0)