mirror of
https://github.com/golang/go.git
synced 2025-05-18 13:54:40 +00:00
2867a85541
The undef pass basically double-checks the relocation targets are defined. We already do that in the reloc pass, and for external relocations we check that when we emit relocations. The undef pass doesn't seem necessary. Change-Id: Iecfa654dc014fdc6e59c624cbf5948ad65fd367a Reviewed-on: https://go-review.googlesource.com/c/go/+/232577 Run-TryBot: Cherry Zhang <cherryyz@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Jeremy Faller <jeremy@golang.org> Reviewed-by: Than McIntosh <thanm@google.com>
2911 lines
83 KiB
Go
2911 lines
83 KiB
Go
// Inferno utils/8l/asm.c
|
||
// https://bitbucket.org/inferno-os/inferno-os/src/default/utils/8l/asm.c
|
||
//
|
||
// Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved.
|
||
// Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
|
||
// Portions Copyright © 1997-1999 Vita Nuova Limited
|
||
// Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
|
||
// Portions Copyright © 2004,2006 Bruce Ellis
|
||
// Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
|
||
// Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
|
||
// Portions Copyright © 2009 The Go Authors. All rights reserved.
|
||
//
|
||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||
// of this software and associated documentation files (the "Software"), to deal
|
||
// in the Software without restriction, including without limitation the rights
|
||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||
// copies of the Software, and to permit persons to whom the Software is
|
||
// furnished to do so, subject to the following conditions:
|
||
//
|
||
// The above copyright notice and this permission notice shall be included in
|
||
// all copies or substantial portions of the Software.
|
||
//
|
||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||
// THE SOFTWARE.
|
||
|
||
package ld
|
||
|
||
import (
|
||
"bytes"
|
||
"cmd/internal/bio"
|
||
"cmd/internal/goobj2"
|
||
"cmd/internal/obj"
|
||
"cmd/internal/objabi"
|
||
"cmd/internal/sys"
|
||
"cmd/link/internal/loadelf"
|
||
"cmd/link/internal/loader"
|
||
"cmd/link/internal/loadmacho"
|
||
"cmd/link/internal/loadpe"
|
||
"cmd/link/internal/loadxcoff"
|
||
"cmd/link/internal/sym"
|
||
"crypto/sha1"
|
||
"debug/elf"
|
||
"debug/macho"
|
||
"encoding/base64"
|
||
"encoding/binary"
|
||
"encoding/hex"
|
||
"fmt"
|
||
"io"
|
||
"io/ioutil"
|
||
"log"
|
||
"os"
|
||
"os/exec"
|
||
"path/filepath"
|
||
"runtime"
|
||
"sort"
|
||
"strings"
|
||
"sync"
|
||
)
|
||
|
||
// Data layout and relocation.
|
||
|
||
// Derived from Inferno utils/6l/l.h
|
||
// https://bitbucket.org/inferno-os/inferno-os/src/default/utils/6l/l.h
|
||
//
|
||
// Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved.
|
||
// Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
|
||
// Portions Copyright © 1997-1999 Vita Nuova Limited
|
||
// Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
|
||
// Portions Copyright © 2004,2006 Bruce Ellis
|
||
// Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
|
||
// Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
|
||
// Portions Copyright © 2009 The Go Authors. All rights reserved.
|
||
//
|
||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||
// of this software and associated documentation files (the "Software"), to deal
|
||
// in the Software without restriction, including without limitation the rights
|
||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||
// copies of the Software, and to permit persons to whom the Software is
|
||
// furnished to do so, subject to the following conditions:
|
||
//
|
||
// The above copyright notice and this permission notice shall be included in
|
||
// all copies or substantial portions of the Software.
|
||
//
|
||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||
// 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 // for each version
|
||
|
||
GOT *sym.Symbol
|
||
PLT *sym.Symbol
|
||
GOTPLT *sym.Symbol
|
||
|
||
Tlsg *sym.Symbol
|
||
Tlsoffset int
|
||
|
||
Dynamic *sym.Symbol
|
||
DynSym *sym.Symbol
|
||
DynStr *sym.Symbol
|
||
|
||
// Elf specific
|
||
Rel *sym.Symbol
|
||
Rela *sym.Symbol
|
||
RelPLT *sym.Symbol
|
||
RelaPLT *sym.Symbol
|
||
|
||
// Darwin symbols
|
||
LinkEditGOT *sym.Symbol
|
||
LinkEditPLT *sym.Symbol
|
||
|
||
// ----- loader.Sym equivalents -----
|
||
|
||
Rel2 loader.Sym
|
||
Rela2 loader.Sym
|
||
RelPLT2 loader.Sym
|
||
RelaPLT2 loader.Sym
|
||
|
||
LinkEditGOT2 loader.Sym
|
||
LinkEditPLT2 loader.Sym
|
||
|
||
TOC2 loader.Sym
|
||
DotTOC2 []loader.Sym // for each version
|
||
|
||
GOT2 loader.Sym
|
||
PLT2 loader.Sym
|
||
GOTPLT2 loader.Sym
|
||
|
||
Tlsg2 loader.Sym
|
||
|
||
Dynamic2 loader.Sym
|
||
DynSym2 loader.Sym
|
||
DynStr2 loader.Sym
|
||
}
|
||
|
||
const BeforeLoadlibFull = 1
|
||
const AfterLoadlibFull = 2
|
||
|
||
// mkArchSym is a helper for setArchSyms, invoked once before loadlibfull
|
||
// and once after. On the first call it creates a loader.Sym with the
|
||
// specified name, and on the second call a corresponding sym.Symbol.
|
||
func (ctxt *Link) mkArchSym(which int, name string, ver int, ls *loader.Sym, ss **sym.Symbol) {
|
||
if which == BeforeLoadlibFull {
|
||
*ls = ctxt.loader.LookupOrCreateSym(name, ver)
|
||
} else {
|
||
*ss = ctxt.loader.Syms[*ls]
|
||
}
|
||
}
|
||
|
||
// mkArchVecSym is similar to setArchSyms, but operates on elements within
|
||
// a slice, where each element corresponds to some symbol version.
|
||
func (ctxt *Link) mkArchSymVec(which int, name string, ver int, ls []loader.Sym, ss []*sym.Symbol) {
|
||
if which == BeforeLoadlibFull {
|
||
ls[ver] = ctxt.loader.LookupOrCreateSym(name, ver)
|
||
} else if ls[ver] != 0 {
|
||
ss[ver] = ctxt.loader.Syms[ls[ver]]
|
||
}
|
||
}
|
||
|
||
// setArchSyms sets up the ArchSyms structure, and must be called before
|
||
// relocations are applied. This function is invoked twice, once prior
|
||
// to loadlibfull(), and once after the work of loadlibfull is complete.
|
||
func (ctxt *Link) setArchSyms(which int) {
|
||
if which != BeforeLoadlibFull && which != AfterLoadlibFull {
|
||
panic("internal error")
|
||
}
|
||
ctxt.mkArchSym(which, ".got", 0, &ctxt.GOT2, &ctxt.GOT)
|
||
ctxt.mkArchSym(which, ".plt", 0, &ctxt.PLT2, &ctxt.PLT)
|
||
ctxt.mkArchSym(which, ".got.plt", 0, &ctxt.GOTPLT2, &ctxt.GOTPLT)
|
||
ctxt.mkArchSym(which, ".dynamic", 0, &ctxt.Dynamic2, &ctxt.Dynamic)
|
||
ctxt.mkArchSym(which, ".dynsym", 0, &ctxt.DynSym2, &ctxt.DynSym)
|
||
ctxt.mkArchSym(which, ".dynstr", 0, &ctxt.DynStr2, &ctxt.DynStr)
|
||
|
||
if ctxt.IsPPC64() {
|
||
ctxt.mkArchSym(which, "TOC", 0, &ctxt.TOC2, &ctxt.TOC)
|
||
|
||
// NB: note the +2 below for DotTOC2 compared to the +1 for
|
||
// DocTOC. This is because loadlibfull() creates an additional
|
||
// syms version during conversion of loader.Sym symbols to
|
||
// *sym.Symbol symbols. Symbols that are assigned this final
|
||
// version are not going to have TOC references, so it should
|
||
// be ok for them to inherit an invalid .TOC. symbol.
|
||
if which == BeforeLoadlibFull {
|
||
ctxt.DotTOC2 = make([]loader.Sym, ctxt.Syms.MaxVersion()+2)
|
||
} else {
|
||
ctxt.DotTOC = make([]*sym.Symbol, ctxt.Syms.MaxVersion()+1)
|
||
}
|
||
for i := 0; i <= ctxt.Syms.MaxVersion(); i++ {
|
||
if i >= 2 && i < sym.SymVerStatic { // these versions are not used currently
|
||
continue
|
||
}
|
||
ctxt.mkArchSymVec(which, ".TOC.", i, ctxt.DotTOC2, ctxt.DotTOC)
|
||
}
|
||
}
|
||
if ctxt.IsElf() {
|
||
ctxt.mkArchSym(which, ".rel", 0, &ctxt.Rel2, &ctxt.Rel)
|
||
ctxt.mkArchSym(which, ".rela", 0, &ctxt.Rela2, &ctxt.Rela)
|
||
ctxt.mkArchSym(which, ".rel.plt", 0, &ctxt.RelPLT2, &ctxt.RelPLT)
|
||
ctxt.mkArchSym(which, ".rela.plt", 0, &ctxt.RelaPLT2, &ctxt.RelaPLT)
|
||
}
|
||
if ctxt.IsDarwin() {
|
||
ctxt.mkArchSym(which, ".linkedit.got", 0, &ctxt.LinkEditGOT2, &ctxt.LinkEditGOT)
|
||
ctxt.mkArchSym(which, ".linkedit.plt", 0, &ctxt.LinkEditPLT2, &ctxt.LinkEditPLT)
|
||
}
|
||
}
|
||
|
||
type Arch struct {
|
||
Funcalign int
|
||
Maxalign int
|
||
Minalign int
|
||
Dwarfregsp int
|
||
Dwarfreglr int
|
||
Androiddynld string
|
||
Linuxdynld string
|
||
Freebsddynld string
|
||
Netbsddynld string
|
||
Openbsddynld string
|
||
Dragonflydynld string
|
||
Solarisdynld string
|
||
Adddynrel func(*Target, *loader.Loader, *ArchSyms, *sym.Symbol, *sym.Reloc) bool
|
||
Adddynrel2 func(*Target, *loader.Loader, *ArchSyms, loader.Sym, loader.Reloc2, int) bool
|
||
Archinit func(*Link)
|
||
// Archreloc is an arch-specific hook that assists in relocation processing
|
||
// (invoked by 'relocsym'); it handles target-specific relocation tasks.
|
||
// Here "rel" is the current relocation being examined, "sym" is the symbol
|
||
// containing the chunk of data to which the relocation applies, and "off"
|
||
// is the contents of the to-be-relocated data item (from sym.P). Return
|
||
// value is the appropriately relocated value (to be written back to the
|
||
// same spot in sym.P), a boolean indicating if the external relocations'
|
||
// been used, and a boolean indicating success/failure (a failing value
|
||
// indicates a fatal error).
|
||
Archreloc func(target *Target, syms *ArchSyms, rel *sym.Reloc, sym *sym.Symbol,
|
||
offset int64) (relocatedOffset int64, success bool)
|
||
Archreloc2 func(*Target, *loader.Loader, *ArchSyms, loader.Reloc2, *loader.ExtReloc,
|
||
loader.Sym, int64) (relocatedOffset int64, needExtReloc bool, ok bool)
|
||
// Archrelocvariant is a second arch-specific hook used for
|
||
// relocation processing; it handles relocations where r.Type is
|
||
// insufficient to describe the relocation (r.Variant !=
|
||
// sym.RV_NONE). Here "rel" is the relocation being applied, "sym"
|
||
// is the symbol containing the chunk of data to which the
|
||
// 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(target *Target, syms *ArchSyms, rel *sym.Reloc, sym *sym.Symbol,
|
||
offset int64) (relocatedOffset int64)
|
||
Archrelocvariant2 func(target *Target, ldr *loader.Loader, rel loader.Reloc2,
|
||
rv sym.RelocVariant, sym loader.Sym, offset int64) (relocatedOffset int64)
|
||
|
||
// Generate a trampoline for a call from s to rs if necessary. ri is
|
||
// index of the relocation.
|
||
Trampoline func(ctxt *Link, ldr *loader.Loader, ri int, rs, s loader.Sym)
|
||
|
||
// Asmb and Asmb2 are arch-specific routines that write the output
|
||
// file. Typically, Asmb writes most of the content (sections and
|
||
// segments), for which we have computed the size and offset. Asmb2
|
||
// writes the rest.
|
||
Asmb func(*Link, *loader.Loader)
|
||
Asmb2 func(*Link)
|
||
|
||
Elfreloc1 func(*Link, *sym.Reloc, int64) bool
|
||
Elfreloc2 func(*Link, *loader.Loader, loader.Sym, loader.ExtRelocView, int64) bool
|
||
Elfsetupplt func(ctxt *Link, plt, gotplt *loader.SymbolBuilder, dynamic loader.Sym)
|
||
Gentext func(*Link)
|
||
Gentext2 func(*Link, *loader.Loader)
|
||
Machoreloc1 func(*sys.Arch, *OutBuf, *sym.Symbol, *sym.Reloc, int64) bool
|
||
PEreloc1 func(*sys.Arch, *OutBuf, *sym.Symbol, *sym.Reloc, int64) bool
|
||
Xcoffreloc1 func(*sys.Arch, *OutBuf, *sym.Symbol, *sym.Reloc, int64) bool
|
||
|
||
// TLSIEtoLE converts a TLS Initial Executable relocation to
|
||
// a TLS Local Executable relocation.
|
||
//
|
||
// This is possible when a TLS IE relocation refers to a local
|
||
// symbol in an executable, which is typical when internally
|
||
// linking PIE binaries.
|
||
TLSIEtoLE func(P []byte, off, size int)
|
||
|
||
// optional override for assignAddress
|
||
AssignAddress func(ldr *loader.Loader, sect *sym.Section, n int, s loader.Sym, va uint64, isTramp bool) (*sym.Section, int, uint64)
|
||
}
|
||
|
||
var (
|
||
thearch Arch
|
||
Lcsize int32
|
||
rpath Rpath
|
||
Spsize int32
|
||
Symsize int32
|
||
)
|
||
|
||
const (
|
||
MINFUNC = 16 // minimum size for a function
|
||
)
|
||
|
||
// DynlinkingGo reports whether we are producing Go code that can live
|
||
// in separate shared libraries linked together at runtime.
|
||
func (ctxt *Link) DynlinkingGo() bool {
|
||
if !ctxt.Loaded {
|
||
panic("DynlinkingGo called before all symbols loaded")
|
||
}
|
||
return ctxt.BuildMode == BuildModeShared || ctxt.linkShared || ctxt.BuildMode == BuildModePlugin || ctxt.canUsePlugins
|
||
}
|
||
|
||
// CanUsePlugins reports whether a plugins can be used
|
||
func (ctxt *Link) CanUsePlugins() bool {
|
||
if !ctxt.Loaded {
|
||
panic("CanUsePlugins called before all symbols loaded")
|
||
}
|
||
return ctxt.canUsePlugins
|
||
}
|
||
|
||
var (
|
||
dynexp []*sym.Symbol
|
||
dynlib []string
|
||
ldflag []string
|
||
havedynamic int
|
||
Funcalign int
|
||
iscgo bool
|
||
elfglobalsymndx int
|
||
interpreter string
|
||
|
||
debug_s bool // backup old value of debug['s']
|
||
HEADR int32
|
||
|
||
nerrors int
|
||
liveness int64
|
||
|
||
// See -strictdups command line flag.
|
||
checkStrictDups int // 0=off 1=warning 2=error
|
||
strictDupMsgCount int
|
||
)
|
||
|
||
var (
|
||
Segtext sym.Segment
|
||
Segrodata sym.Segment
|
||
Segrelrodata sym.Segment
|
||
Segdata sym.Segment
|
||
Segdwarf sym.Segment
|
||
)
|
||
|
||
const pkgdef = "__.PKGDEF"
|
||
|
||
var (
|
||
// Set if we see an object compiled by the host compiler that is not
|
||
// from a package that is known to support internal linking mode.
|
||
externalobj = false
|
||
theline string
|
||
)
|
||
|
||
func Lflag(ctxt *Link, arg string) {
|
||
ctxt.Libdir = append(ctxt.Libdir, arg)
|
||
}
|
||
|
||
/*
|
||
* Unix doesn't like it when we write to a running (or, sometimes,
|
||
* recently run) binary, so remove the output file before writing it.
|
||
* On Windows 7, remove() can force a subsequent create() to fail.
|
||
* S_ISREG() does not exist on Plan 9.
|
||
*/
|
||
func mayberemoveoutfile() {
|
||
if fi, err := os.Lstat(*flagOutfile); err == nil && !fi.Mode().IsRegular() {
|
||
return
|
||
}
|
||
os.Remove(*flagOutfile)
|
||
}
|
||
|
||
func libinit(ctxt *Link) {
|
||
Funcalign = thearch.Funcalign
|
||
|
||
// add goroot to the end of the libdir list.
|
||
suffix := ""
|
||
|
||
suffixsep := ""
|
||
if *flagInstallSuffix != "" {
|
||
suffixsep = "_"
|
||
suffix = *flagInstallSuffix
|
||
} else if *flagRace {
|
||
suffixsep = "_"
|
||
suffix = "race"
|
||
} else if *flagMsan {
|
||
suffixsep = "_"
|
||
suffix = "msan"
|
||
}
|
||
|
||
Lflag(ctxt, filepath.Join(objabi.GOROOT, "pkg", fmt.Sprintf("%s_%s%s%s", objabi.GOOS, objabi.GOARCH, suffixsep, suffix)))
|
||
|
||
mayberemoveoutfile()
|
||
|
||
if err := ctxt.Out.Open(*flagOutfile); err != nil {
|
||
Exitf("cannot create %s: %v", *flagOutfile, err)
|
||
}
|
||
|
||
if *flagEntrySymbol == "" {
|
||
switch ctxt.BuildMode {
|
||
case BuildModeCShared, BuildModeCArchive:
|
||
*flagEntrySymbol = fmt.Sprintf("_rt0_%s_%s_lib", objabi.GOARCH, objabi.GOOS)
|
||
case BuildModeExe, BuildModePIE:
|
||
*flagEntrySymbol = fmt.Sprintf("_rt0_%s_%s", objabi.GOARCH, objabi.GOOS)
|
||
case BuildModeShared, BuildModePlugin:
|
||
// No *flagEntrySymbol for -buildmode=shared and plugin
|
||
default:
|
||
Errorf(nil, "unknown *flagEntrySymbol for buildmode %v", ctxt.BuildMode)
|
||
}
|
||
}
|
||
}
|
||
|
||
func exitIfErrors() {
|
||
if nerrors != 0 || checkStrictDups > 1 && strictDupMsgCount > 0 {
|
||
mayberemoveoutfile()
|
||
Exit(2)
|
||
}
|
||
|
||
}
|
||
|
||
func errorexit() {
|
||
exitIfErrors()
|
||
Exit(0)
|
||
}
|
||
|
||
func loadinternal(ctxt *Link, name string) *sym.Library {
|
||
zerofp := goobj2.FingerprintType{}
|
||
if ctxt.linkShared && ctxt.PackageShlib != nil {
|
||
if shlib := ctxt.PackageShlib[name]; shlib != "" {
|
||
return addlibpath(ctxt, "internal", "internal", "", name, shlib, zerofp)
|
||
}
|
||
}
|
||
if ctxt.PackageFile != nil {
|
||
if pname := ctxt.PackageFile[name]; pname != "" {
|
||
return addlibpath(ctxt, "internal", "internal", pname, name, "", zerofp)
|
||
}
|
||
ctxt.Logf("loadinternal: cannot find %s\n", name)
|
||
return nil
|
||
}
|
||
|
||
for _, libdir := range ctxt.Libdir {
|
||
if ctxt.linkShared {
|
||
shlibname := filepath.Join(libdir, name+".shlibname")
|
||
if ctxt.Debugvlog != 0 {
|
||
ctxt.Logf("searching for %s.a in %s\n", name, shlibname)
|
||
}
|
||
if _, err := os.Stat(shlibname); err == nil {
|
||
return addlibpath(ctxt, "internal", "internal", "", name, shlibname, zerofp)
|
||
}
|
||
}
|
||
pname := filepath.Join(libdir, name+".a")
|
||
if ctxt.Debugvlog != 0 {
|
||
ctxt.Logf("searching for %s.a in %s\n", name, pname)
|
||
}
|
||
if _, err := os.Stat(pname); err == nil {
|
||
return addlibpath(ctxt, "internal", "internal", pname, name, "", zerofp)
|
||
}
|
||
}
|
||
|
||
ctxt.Logf("warning: unable to find %s.a\n", name)
|
||
return nil
|
||
}
|
||
|
||
// extld returns the current external linker.
|
||
func (ctxt *Link) extld() string {
|
||
if *flagExtld == "" {
|
||
*flagExtld = "gcc"
|
||
}
|
||
return *flagExtld
|
||
}
|
||
|
||
// findLibPathCmd uses cmd command to find gcc library libname.
|
||
// It returns library full path if found, or "none" if not found.
|
||
func (ctxt *Link) findLibPathCmd(cmd, libname string) string {
|
||
extld := ctxt.extld()
|
||
args := hostlinkArchArgs(ctxt.Arch)
|
||
args = append(args, cmd)
|
||
if ctxt.Debugvlog != 0 {
|
||
ctxt.Logf("%s %v\n", extld, args)
|
||
}
|
||
out, err := exec.Command(extld, args...).Output()
|
||
if err != nil {
|
||
if ctxt.Debugvlog != 0 {
|
||
ctxt.Logf("not using a %s file because compiler failed\n%v\n%s\n", libname, err, out)
|
||
}
|
||
return "none"
|
||
}
|
||
return strings.TrimSpace(string(out))
|
||
}
|
||
|
||
// findLibPath searches for library libname.
|
||
// It returns library full path if found, or "none" if not found.
|
||
func (ctxt *Link) findLibPath(libname string) string {
|
||
return ctxt.findLibPathCmd("--print-file-name="+libname, libname)
|
||
}
|
||
|
||
func (ctxt *Link) loadlib() {
|
||
var flags uint32
|
||
switch *FlagStrictDups {
|
||
case 0:
|
||
// nothing to do
|
||
case 1, 2:
|
||
flags = loader.FlagStrictDups
|
||
default:
|
||
log.Fatalf("invalid -strictdups flag value %d", *FlagStrictDups)
|
||
}
|
||
ctxt.loader = loader.NewLoader(flags, elfsetstring, &ctxt.ErrorReporter.ErrorReporter)
|
||
ctxt.ErrorReporter.SymName = func(s loader.Sym) string {
|
||
return ctxt.loader.SymName(s)
|
||
}
|
||
|
||
ctxt.cgo_export_static = make(map[string]bool)
|
||
ctxt.cgo_export_dynamic = make(map[string]bool)
|
||
|
||
// ctxt.Library grows during the loop, so not a range loop.
|
||
i := 0
|
||
for ; i < len(ctxt.Library); i++ {
|
||
lib := ctxt.Library[i]
|
||
if lib.Shlib == "" {
|
||
if ctxt.Debugvlog > 1 {
|
||
ctxt.Logf("autolib: %s (from %s)\n", lib.File, lib.Objref)
|
||
}
|
||
loadobjfile(ctxt, lib)
|
||
}
|
||
}
|
||
|
||
// load internal packages, if not already
|
||
if *flagRace {
|
||
loadinternal(ctxt, "runtime/race")
|
||
}
|
||
if *flagMsan {
|
||
loadinternal(ctxt, "runtime/msan")
|
||
}
|
||
loadinternal(ctxt, "runtime")
|
||
for ; i < len(ctxt.Library); i++ {
|
||
lib := ctxt.Library[i]
|
||
if lib.Shlib == "" {
|
||
loadobjfile(ctxt, lib)
|
||
}
|
||
}
|
||
// At this point, the Go objects are "preloaded". Not all the symbols are
|
||
// added to the symbol table (only defined package symbols are). Looking
|
||
// up symbol by name may not get expected result.
|
||
|
||
iscgo = ctxt.LibraryByPkg["runtime/cgo"] != nil
|
||
ctxt.canUsePlugins = ctxt.LibraryByPkg["plugin"] != nil
|
||
|
||
// We now have enough information to determine the link mode.
|
||
determineLinkMode(ctxt)
|
||
|
||
if ctxt.LinkMode == LinkExternal && !iscgo && !(objabi.GOOS == "darwin" && ctxt.BuildMode != BuildModePlugin && ctxt.Arch.Family == sys.AMD64) {
|
||
// This indicates a user requested -linkmode=external.
|
||
// The startup code uses an import of runtime/cgo to decide
|
||
// whether to initialize the TLS. So give it one. This could
|
||
// be handled differently but it's an unusual case.
|
||
if lib := loadinternal(ctxt, "runtime/cgo"); lib != nil && lib.Shlib == "" {
|
||
if ctxt.BuildMode == BuildModeShared || ctxt.linkShared {
|
||
Exitf("cannot implicitly include runtime/cgo in a shared library")
|
||
}
|
||
loadobjfile(ctxt, lib)
|
||
}
|
||
}
|
||
|
||
// Add non-package symbols and references of externally defined symbols.
|
||
ctxt.loader.LoadNonpkgSyms(ctxt.Arch)
|
||
|
||
// Load symbols from shared libraries, after all Go object symbols are loaded.
|
||
for _, lib := range ctxt.Library {
|
||
if lib.Shlib != "" {
|
||
if ctxt.Debugvlog > 1 {
|
||
ctxt.Logf("autolib: %s (from %s)\n", lib.Shlib, lib.Objref)
|
||
}
|
||
ldshlibsyms(ctxt, lib.Shlib)
|
||
}
|
||
}
|
||
|
||
// Process cgo directives (has to be done before host object loading).
|
||
ctxt.loadcgodirectives()
|
||
|
||
// Conditionally load host objects, or setup for external linking.
|
||
hostobjs(ctxt)
|
||
hostlinksetup(ctxt)
|
||
|
||
if ctxt.LinkMode == LinkInternal && len(hostobj) != 0 {
|
||
// If we have any undefined symbols in external
|
||
// objects, try to read them from the libgcc file.
|
||
any := false
|
||
undefs := ctxt.loader.UndefinedRelocTargets(1)
|
||
if len(undefs) > 0 {
|
||
any = true
|
||
}
|
||
if any {
|
||
if *flagLibGCC == "" {
|
||
*flagLibGCC = ctxt.findLibPathCmd("--print-libgcc-file-name", "libgcc")
|
||
}
|
||
if runtime.GOOS == "openbsd" && *flagLibGCC == "libgcc.a" {
|
||
// On OpenBSD `clang --print-libgcc-file-name` returns "libgcc.a".
|
||
// In this case we fail to load libgcc.a and can encounter link
|
||
// errors - see if we can find libcompiler_rt.a instead.
|
||
*flagLibGCC = ctxt.findLibPathCmd("--print-file-name=libcompiler_rt.a", "libcompiler_rt")
|
||
}
|
||
if *flagLibGCC != "none" {
|
||
hostArchive(ctxt, *flagLibGCC)
|
||
}
|
||
if ctxt.HeadType == objabi.Hwindows {
|
||
if p := ctxt.findLibPath("libmingwex.a"); p != "none" {
|
||
hostArchive(ctxt, p)
|
||
}
|
||
if p := ctxt.findLibPath("libmingw32.a"); p != "none" {
|
||
hostArchive(ctxt, p)
|
||
}
|
||
// Link libmsvcrt.a to resolve '__acrt_iob_func' symbol
|
||
// (see https://golang.org/issue/23649 for details).
|
||
if p := ctxt.findLibPath("libmsvcrt.a"); p != "none" {
|
||
hostArchive(ctxt, p)
|
||
}
|
||
// TODO: maybe do something similar to peimporteddlls to collect all lib names
|
||
// and try link them all to final exe just like libmingwex.a and libmingw32.a:
|
||
/*
|
||
for:
|
||
#cgo windows LDFLAGS: -lmsvcrt -lm
|
||
import:
|
||
libmsvcrt.a libm.a
|
||
*/
|
||
}
|
||
}
|
||
}
|
||
|
||
// We've loaded all the code now.
|
||
ctxt.Loaded = true
|
||
|
||
importcycles()
|
||
|
||
strictDupMsgCount = ctxt.loader.NStrictDupMsgs()
|
||
}
|
||
|
||
// genSymsForDynexp constructs a *sym.Symbol version of ctxt.dynexp,
|
||
// writing to the global variable 'dynexp'.
|
||
func genSymsForDynexp(ctxt *Link) {
|
||
dynexp = make([]*sym.Symbol, len(ctxt.dynexp2))
|
||
for i, s := range ctxt.dynexp2 {
|
||
dynexp[i] = ctxt.loader.Syms[s]
|
||
}
|
||
}
|
||
|
||
// setupdynexp constructs ctxt.dynexp, a list of loader.Sym.
|
||
func setupdynexp(ctxt *Link) {
|
||
dynexpMap := ctxt.cgo_export_dynamic
|
||
if ctxt.LinkMode == LinkExternal {
|
||
dynexpMap = ctxt.cgo_export_static
|
||
}
|
||
d := make([]loader.Sym, 0, len(dynexpMap))
|
||
for exp := range dynexpMap {
|
||
s := ctxt.loader.LookupOrCreateSym(exp, 0)
|
||
d = append(d, s)
|
||
// sanity check
|
||
if !ctxt.loader.AttrReachable(s) {
|
||
panic("dynexp entry not reachable")
|
||
}
|
||
}
|
||
sort.Slice(d, func(i, j int) bool {
|
||
return ctxt.loader.SymName(d[i]) < ctxt.loader.SymName(d[j])
|
||
})
|
||
|
||
// Resolve ABI aliases in the list of cgo-exported functions.
|
||
// This is necessary because we load the ABI0 symbol for all
|
||
// cgo exports.
|
||
for i, s := range d {
|
||
if ctxt.loader.SymType(s) != sym.SABIALIAS {
|
||
continue
|
||
}
|
||
t := ctxt.loader.ResolveABIAlias(s)
|
||
ctxt.loader.CopyAttributes(s, t)
|
||
ctxt.loader.SetSymExtname(t, ctxt.loader.SymExtname(s))
|
||
d[i] = t
|
||
}
|
||
ctxt.dynexp2 = d
|
||
|
||
ctxt.cgo_export_static = nil
|
||
ctxt.cgo_export_dynamic = nil
|
||
}
|
||
|
||
// loadcgodirectives reads the previously discovered cgo directives, creating
|
||
// symbols in preparation for host object loading or use later in the link.
|
||
func (ctxt *Link) loadcgodirectives() {
|
||
l := ctxt.loader
|
||
hostObjSyms := make(map[loader.Sym]struct{})
|
||
for _, d := range ctxt.cgodata {
|
||
setCgoAttr(ctxt, ctxt.loader.LookupOrCreateSym, d.file, d.pkg, d.directives, hostObjSyms)
|
||
}
|
||
ctxt.cgodata = nil
|
||
|
||
if ctxt.LinkMode == LinkInternal {
|
||
// Drop all the cgo_import_static declarations.
|
||
// Turns out we won't be needing them.
|
||
for symIdx := range hostObjSyms {
|
||
if l.SymType(symIdx) == sym.SHOSTOBJ {
|
||
// If a symbol was marked both
|
||
// cgo_import_static and cgo_import_dynamic,
|
||
// then we want to make it cgo_import_dynamic
|
||
// now.
|
||
su := l.MakeSymbolUpdater(symIdx)
|
||
if l.SymExtname(symIdx) != "" && l.SymDynimplib(symIdx) != "" && !(l.AttrCgoExportStatic(symIdx) || l.AttrCgoExportDynamic(symIdx)) {
|
||
su.SetType(sym.SDYNIMPORT)
|
||
} else {
|
||
su.SetType(0)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Set up flags and special symbols depending on the platform build mode.
|
||
// This version works with loader.Loader.
|
||
func (ctxt *Link) linksetup() {
|
||
switch ctxt.BuildMode {
|
||
case BuildModeCShared, BuildModePlugin:
|
||
symIdx := ctxt.loader.LookupOrCreateSym("runtime.islibrary", 0)
|
||
sb := ctxt.loader.MakeSymbolUpdater(symIdx)
|
||
sb.SetType(sym.SNOPTRDATA)
|
||
sb.AddUint8(1)
|
||
case BuildModeCArchive:
|
||
symIdx := ctxt.loader.LookupOrCreateSym("runtime.isarchive", 0)
|
||
sb := ctxt.loader.MakeSymbolUpdater(symIdx)
|
||
sb.SetType(sym.SNOPTRDATA)
|
||
sb.AddUint8(1)
|
||
}
|
||
|
||
// Recalculate pe parameters now that we have ctxt.LinkMode set.
|
||
if ctxt.HeadType == objabi.Hwindows {
|
||
Peinit(ctxt)
|
||
}
|
||
|
||
if ctxt.HeadType == objabi.Hdarwin && ctxt.LinkMode == LinkExternal {
|
||
*FlagTextAddr = 0
|
||
}
|
||
|
||
// If there are no dynamic libraries needed, gcc disables dynamic linking.
|
||
// Because of this, glibc's dynamic ELF loader occasionally (like in version 2.13)
|
||
// assumes that a dynamic binary always refers to at least one dynamic library.
|
||
// Rather than be a source of test cases for glibc, disable dynamic linking
|
||
// the same way that gcc would.
|
||
//
|
||
// Exception: on OS X, programs such as Shark only work with dynamic
|
||
// binaries, so leave it enabled on OS X (Mach-O) binaries.
|
||
// Also leave it enabled on Solaris which doesn't support
|
||
// statically linked binaries.
|
||
if ctxt.BuildMode == BuildModeExe {
|
||
if havedynamic == 0 && ctxt.HeadType != objabi.Hdarwin && ctxt.HeadType != objabi.Hsolaris {
|
||
*FlagD = true
|
||
}
|
||
}
|
||
|
||
if ctxt.LinkMode == LinkExternal && ctxt.Arch.Family == sys.PPC64 && objabi.GOOS != "aix" {
|
||
toc := ctxt.loader.LookupOrCreateSym(".TOC.", 0)
|
||
sb := ctxt.loader.MakeSymbolUpdater(toc)
|
||
sb.SetType(sym.SDYNIMPORT)
|
||
}
|
||
|
||
// The Android Q linker started to complain about underalignment of the our TLS
|
||
// section. We don't actually use the section on android, so don't
|
||
// generate it.
|
||
if objabi.GOOS != "android" {
|
||
tlsg := ctxt.loader.LookupOrCreateSym("runtime.tlsg", 0)
|
||
sb := ctxt.loader.MakeSymbolUpdater(tlsg)
|
||
|
||
// runtime.tlsg is used for external linking on platforms that do not define
|
||
// a variable to hold g in assembly (currently only intel).
|
||
if sb.Type() == 0 {
|
||
sb.SetType(sym.STLSBSS)
|
||
sb.SetSize(int64(ctxt.Arch.PtrSize))
|
||
} else if sb.Type() != sym.SDYNIMPORT {
|
||
Errorf(nil, "runtime declared tlsg variable %v", sb.Type())
|
||
}
|
||
ctxt.loader.SetAttrReachable(tlsg, true)
|
||
ctxt.Tlsg2 = tlsg
|
||
}
|
||
|
||
var moduledata loader.Sym
|
||
var mdsb *loader.SymbolBuilder
|
||
if ctxt.BuildMode == BuildModePlugin {
|
||
moduledata = ctxt.loader.LookupOrCreateSym("local.pluginmoduledata", 0)
|
||
mdsb = ctxt.loader.MakeSymbolUpdater(moduledata)
|
||
ctxt.loader.SetAttrLocal(moduledata, true)
|
||
} else {
|
||
moduledata = ctxt.loader.LookupOrCreateSym("runtime.firstmoduledata", 0)
|
||
mdsb = ctxt.loader.MakeSymbolUpdater(moduledata)
|
||
}
|
||
if mdsb.Type() != 0 && mdsb.Type() != sym.SDYNIMPORT {
|
||
// If the module (toolchain-speak for "executable or shared
|
||
// library") we are linking contains the runtime package, it
|
||
// will define the runtime.firstmoduledata symbol and we
|
||
// truncate it back to 0 bytes so we can define its entire
|
||
// contents in symtab.go:symtab().
|
||
mdsb.SetSize(0)
|
||
|
||
// In addition, on ARM, the runtime depends on the linker
|
||
// recording the value of GOARM.
|
||
if ctxt.Arch.Family == sys.ARM {
|
||
goarm := ctxt.loader.LookupOrCreateSym("runtime.goarm", 0)
|
||
sb := ctxt.loader.MakeSymbolUpdater(goarm)
|
||
sb.SetType(sym.SDATA)
|
||
sb.SetSize(0)
|
||
sb.AddUint8(uint8(objabi.GOARM))
|
||
}
|
||
|
||
if objabi.Framepointer_enabled(objabi.GOOS, objabi.GOARCH) {
|
||
fpe := ctxt.loader.LookupOrCreateSym("runtime.framepointer_enabled", 0)
|
||
sb := ctxt.loader.MakeSymbolUpdater(fpe)
|
||
sb.SetType(sym.SNOPTRDATA)
|
||
sb.SetSize(0)
|
||
sb.AddUint8(1)
|
||
}
|
||
} else {
|
||
// If OTOH the module does not contain the runtime package,
|
||
// create a local symbol for the moduledata.
|
||
moduledata = ctxt.loader.LookupOrCreateSym("local.moduledata", 0)
|
||
mdsb = ctxt.loader.MakeSymbolUpdater(moduledata)
|
||
ctxt.loader.SetAttrLocal(moduledata, true)
|
||
}
|
||
// In all cases way we mark the moduledata as noptrdata to hide it from
|
||
// the GC.
|
||
mdsb.SetType(sym.SNOPTRDATA)
|
||
ctxt.loader.SetAttrReachable(moduledata, true)
|
||
ctxt.Moduledata2 = moduledata
|
||
|
||
// If package versioning is required, generate a hash of the
|
||
// packages used in the link.
|
||
if ctxt.BuildMode == BuildModeShared || ctxt.BuildMode == BuildModePlugin || ctxt.CanUsePlugins() {
|
||
for _, lib := range ctxt.Library {
|
||
if lib.Shlib == "" {
|
||
genhash(ctxt, lib)
|
||
}
|
||
}
|
||
}
|
||
|
||
if ctxt.Arch == sys.Arch386 && ctxt.HeadType != objabi.Hwindows {
|
||
if (ctxt.BuildMode == BuildModeCArchive && ctxt.IsELF) || ctxt.BuildMode == BuildModeCShared || ctxt.BuildMode == BuildModePIE || ctxt.DynlinkingGo() {
|
||
got := ctxt.loader.LookupOrCreateSym("_GLOBAL_OFFSET_TABLE_", 0)
|
||
sb := ctxt.loader.MakeSymbolUpdater(got)
|
||
sb.SetType(sym.SDYNIMPORT)
|
||
ctxt.loader.SetAttrReachable(got, true)
|
||
}
|
||
}
|
||
|
||
// DWARF-gen and other phases require that the unit Textp2 slices
|
||
// be populated, so that it can walk the functions in each unit.
|
||
// Call into the loader to do this (requires that we collect the
|
||
// set of internal libraries first). NB: might be simpler if we
|
||
// moved isRuntimeDepPkg to cmd/internal and then did the test in
|
||
// loader.AssignTextSymbolOrder.
|
||
ctxt.Library = postorder(ctxt.Library)
|
||
intlibs := []bool{}
|
||
for _, lib := range ctxt.Library {
|
||
intlibs = append(intlibs, isRuntimeDepPkg(lib.Pkg))
|
||
}
|
||
ctxt.Textp2 = ctxt.loader.AssignTextSymbolOrder(ctxt.Library, intlibs, ctxt.Textp2)
|
||
}
|
||
|
||
// mangleTypeSym shortens the names of symbols that represent Go types
|
||
// if they are visible in the symbol table.
|
||
//
|
||
// As the names of these symbols are derived from the string of
|
||
// the type, they can run to many kilobytes long. So we shorten
|
||
// them using a SHA-1 when the name appears in the final binary.
|
||
// This also removes characters that upset external linkers.
|
||
//
|
||
// These are the symbols that begin with the prefix 'type.' and
|
||
// contain run-time type information used by the runtime and reflect
|
||
// packages. All Go binaries contain these symbols, but only
|
||
// those programs loaded dynamically in multiple parts need these
|
||
// symbols to have entries in the symbol table.
|
||
func (ctxt *Link) mangleTypeSym() {
|
||
if ctxt.BuildMode != BuildModeShared && !ctxt.linkShared && ctxt.BuildMode != BuildModePlugin && !ctxt.CanUsePlugins() {
|
||
return
|
||
}
|
||
|
||
ldr := ctxt.loader
|
||
for s := loader.Sym(1); s < loader.Sym(ldr.NSym()); s++ {
|
||
if !ldr.AttrReachable(s) {
|
||
continue
|
||
}
|
||
name := ldr.SymName(s)
|
||
newName := typeSymbolMangle(name)
|
||
if newName != name {
|
||
ldr.SetSymExtname(s, newName)
|
||
|
||
// When linking against a shared library, the Go object file may
|
||
// have reference to the original symbol name whereas the shared
|
||
// library provides a symbol with the mangled name. We need to
|
||
// copy the payload of mangled to original.
|
||
// XXX maybe there is a better way to do this.
|
||
dup := ldr.Lookup(newName, ldr.SymVersion(s))
|
||
if dup != 0 {
|
||
st := ldr.SymType(s)
|
||
dt := ldr.SymType(dup)
|
||
if st == sym.Sxxx && dt != sym.Sxxx {
|
||
ldr.CopySym(dup, s)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// typeSymbolMangle mangles the given symbol name into something shorter.
|
||
//
|
||
// Keep the type.. prefix, which parts of the linker (like the
|
||
// DWARF generator) know means the symbol is not decodable.
|
||
// Leave type.runtime. symbols alone, because other parts of
|
||
// the linker manipulates them.
|
||
func typeSymbolMangle(name string) string {
|
||
if !strings.HasPrefix(name, "type.") {
|
||
return name
|
||
}
|
||
if strings.HasPrefix(name, "type.runtime.") {
|
||
return name
|
||
}
|
||
if len(name) <= 14 && !strings.Contains(name, "@") { // Issue 19529
|
||
return name
|
||
}
|
||
hash := sha1.Sum([]byte(name))
|
||
prefix := "type."
|
||
if name[5] == '.' {
|
||
prefix = "type.."
|
||
}
|
||
return prefix + base64.StdEncoding.EncodeToString(hash[:6])
|
||
}
|
||
|
||
/*
|
||
* look for the next file in an archive.
|
||
* adapted from libmach.
|
||
*/
|
||
func nextar(bp *bio.Reader, off int64, a *ArHdr) int64 {
|
||
if off&1 != 0 {
|
||
off++
|
||
}
|
||
bp.MustSeek(off, 0)
|
||
var buf [SAR_HDR]byte
|
||
if n, err := io.ReadFull(bp, buf[:]); err != nil {
|
||
if n == 0 && err != io.EOF {
|
||
return -1
|
||
}
|
||
return 0
|
||
}
|
||
|
||
a.name = artrim(buf[0:16])
|
||
a.date = artrim(buf[16:28])
|
||
a.uid = artrim(buf[28:34])
|
||
a.gid = artrim(buf[34:40])
|
||
a.mode = artrim(buf[40:48])
|
||
a.size = artrim(buf[48:58])
|
||
a.fmag = artrim(buf[58:60])
|
||
|
||
arsize := atolwhex(a.size)
|
||
if arsize&1 != 0 {
|
||
arsize++
|
||
}
|
||
return arsize + SAR_HDR
|
||
}
|
||
|
||
func genhash(ctxt *Link, lib *sym.Library) {
|
||
f, err := bio.Open(lib.File)
|
||
if err != nil {
|
||
Errorf(nil, "cannot open file %s for hash generation: %v", lib.File, err)
|
||
return
|
||
}
|
||
defer f.Close()
|
||
|
||
var magbuf [len(ARMAG)]byte
|
||
if _, err := io.ReadFull(f, magbuf[:]); err != nil {
|
||
Exitf("file %s too short", lib.File)
|
||
}
|
||
|
||
if string(magbuf[:]) != ARMAG {
|
||
Exitf("%s is not an archive file", lib.File)
|
||
}
|
||
|
||
var arhdr ArHdr
|
||
l := nextar(f, f.Offset(), &arhdr)
|
||
if l <= 0 {
|
||
Errorf(nil, "%s: short read on archive file symbol header", lib.File)
|
||
return
|
||
}
|
||
if arhdr.name != pkgdef {
|
||
Errorf(nil, "%s: missing package data entry", lib.File)
|
||
return
|
||
}
|
||
|
||
h := sha1.New()
|
||
|
||
// To compute the hash of a package, we hash the first line of
|
||
// __.PKGDEF (which contains the toolchain version and any
|
||
// GOEXPERIMENT flags) and the export data (which is between
|
||
// the first two occurrences of "\n$$").
|
||
|
||
pkgDefBytes := make([]byte, atolwhex(arhdr.size))
|
||
_, err = io.ReadFull(f, pkgDefBytes)
|
||
if err != nil {
|
||
Errorf(nil, "%s: error reading package data: %v", lib.File, err)
|
||
return
|
||
}
|
||
firstEOL := bytes.IndexByte(pkgDefBytes, '\n')
|
||
if firstEOL < 0 {
|
||
Errorf(nil, "cannot parse package data of %s for hash generation, no newline found", lib.File)
|
||
return
|
||
}
|
||
firstDoubleDollar := bytes.Index(pkgDefBytes, []byte("\n$$"))
|
||
if firstDoubleDollar < 0 {
|
||
Errorf(nil, "cannot parse package data of %s for hash generation, no \\n$$ found", lib.File)
|
||
return
|
||
}
|
||
secondDoubleDollar := bytes.Index(pkgDefBytes[firstDoubleDollar+1:], []byte("\n$$"))
|
||
if secondDoubleDollar < 0 {
|
||
Errorf(nil, "cannot parse package data of %s for hash generation, only one \\n$$ found", lib.File)
|
||
return
|
||
}
|
||
h.Write(pkgDefBytes[0:firstEOL])
|
||
h.Write(pkgDefBytes[firstDoubleDollar : firstDoubleDollar+secondDoubleDollar])
|
||
lib.Hash = hex.EncodeToString(h.Sum(nil))
|
||
}
|
||
|
||
func loadobjfile(ctxt *Link, lib *sym.Library) {
|
||
pkg := objabi.PathToPrefix(lib.Pkg)
|
||
|
||
if ctxt.Debugvlog > 1 {
|
||
ctxt.Logf("ldobj: %s (%s)\n", lib.File, pkg)
|
||
}
|
||
f, err := bio.Open(lib.File)
|
||
if err != nil {
|
||
Exitf("cannot open file %s: %v", lib.File, err)
|
||
}
|
||
defer f.Close()
|
||
defer func() {
|
||
if pkg == "main" && !lib.Main {
|
||
Exitf("%s: not package main", lib.File)
|
||
}
|
||
|
||
// Ideally, we'd check that *all* object files within
|
||
// the archive were marked safe, but here we settle
|
||
// for *any*.
|
||
//
|
||
// Historically, cmd/link only checked the __.PKGDEF
|
||
// file, which in turn came from the first object
|
||
// file, typically produced by cmd/compile. The
|
||
// remaining object files are normally produced by
|
||
// cmd/asm, which doesn't support marking files as
|
||
// safe anyway. So at least in practice, this matches
|
||
// how safe mode has always worked.
|
||
if *flagU && !lib.Safe {
|
||
Exitf("%s: load of unsafe package %s", lib.File, pkg)
|
||
}
|
||
}()
|
||
|
||
for i := 0; i < len(ARMAG); i++ {
|
||
if c, err := f.ReadByte(); err == nil && c == ARMAG[i] {
|
||
continue
|
||
}
|
||
|
||
/* load it as a regular file */
|
||
l := f.MustSeek(0, 2)
|
||
f.MustSeek(0, 0)
|
||
ldobj(ctxt, f, lib, l, lib.File, lib.File)
|
||
return
|
||
}
|
||
|
||
/*
|
||
* load all the object files from the archive now.
|
||
* this gives us sequential file access and keeps us
|
||
* from needing to come back later to pick up more
|
||
* objects. it breaks the usual C archive model, but
|
||
* this is Go, not C. the common case in Go is that
|
||
* we need to load all the objects, and then we throw away
|
||
* the individual symbols that are unused.
|
||
*
|
||
* loading every object will also make it possible to
|
||
* load foreign objects not referenced by __.PKGDEF.
|
||
*/
|
||
var arhdr ArHdr
|
||
off := f.Offset()
|
||
for {
|
||
l := nextar(f, off, &arhdr)
|
||
if l == 0 {
|
||
break
|
||
}
|
||
if l < 0 {
|
||
Exitf("%s: malformed archive", lib.File)
|
||
}
|
||
off += l
|
||
|
||
// __.PKGDEF isn't a real Go object file, and it's
|
||
// absent in -linkobj builds anyway. Skipping it
|
||
// ensures consistency between -linkobj and normal
|
||
// build modes.
|
||
if arhdr.name == pkgdef {
|
||
continue
|
||
}
|
||
|
||
// Skip other special (non-object-file) sections that
|
||
// build tools may have added. Such sections must have
|
||
// short names so that the suffix is not truncated.
|
||
if len(arhdr.name) < 16 {
|
||
if ext := filepath.Ext(arhdr.name); ext != ".o" && ext != ".syso" {
|
||
continue
|
||
}
|
||
}
|
||
|
||
pname := fmt.Sprintf("%s(%s)", lib.File, arhdr.name)
|
||
l = atolwhex(arhdr.size)
|
||
ldobj(ctxt, f, lib, l, pname, lib.File)
|
||
}
|
||
}
|
||
|
||
type Hostobj struct {
|
||
ld func(*Link, *bio.Reader, string, int64, string)
|
||
pkg string
|
||
pn string
|
||
file string
|
||
off int64
|
||
length int64
|
||
}
|
||
|
||
var hostobj []Hostobj
|
||
|
||
// These packages can use internal linking mode.
|
||
// Others trigger external mode.
|
||
var internalpkg = []string{
|
||
"crypto/x509",
|
||
"net",
|
||
"os/user",
|
||
"runtime/cgo",
|
||
"runtime/race",
|
||
"runtime/msan",
|
||
}
|
||
|
||
func ldhostobj(ld func(*Link, *bio.Reader, string, int64, string), headType objabi.HeadType, f *bio.Reader, pkg string, length int64, pn string, file string) *Hostobj {
|
||
isinternal := false
|
||
for _, intpkg := range internalpkg {
|
||
if pkg == intpkg {
|
||
isinternal = true
|
||
break
|
||
}
|
||
}
|
||
|
||
// DragonFly declares errno with __thread, which results in a symbol
|
||
// type of R_386_TLS_GD or R_X86_64_TLSGD. The Go linker does not
|
||
// currently know how to handle TLS relocations, hence we have to
|
||
// force external linking for any libraries that link in code that
|
||
// uses errno. This can be removed if the Go linker ever supports
|
||
// these relocation types.
|
||
if headType == objabi.Hdragonfly {
|
||
if pkg == "net" || pkg == "os/user" {
|
||
isinternal = false
|
||
}
|
||
}
|
||
|
||
if !isinternal {
|
||
externalobj = true
|
||
}
|
||
|
||
hostobj = append(hostobj, Hostobj{})
|
||
h := &hostobj[len(hostobj)-1]
|
||
h.ld = ld
|
||
h.pkg = pkg
|
||
h.pn = pn
|
||
h.file = file
|
||
h.off = f.Offset()
|
||
h.length = length
|
||
return h
|
||
}
|
||
|
||
func hostobjs(ctxt *Link) {
|
||
if ctxt.LinkMode != LinkInternal {
|
||
return
|
||
}
|
||
var h *Hostobj
|
||
|
||
for i := 0; i < len(hostobj); i++ {
|
||
h = &hostobj[i]
|
||
f, err := bio.Open(h.file)
|
||
if err != nil {
|
||
Exitf("cannot reopen %s: %v", h.pn, err)
|
||
}
|
||
|
||
f.MustSeek(h.off, 0)
|
||
h.ld(ctxt, f, h.pkg, h.length, h.pn)
|
||
f.Close()
|
||
}
|
||
}
|
||
|
||
func hostlinksetup(ctxt *Link) {
|
||
if ctxt.LinkMode != LinkExternal {
|
||
return
|
||
}
|
||
|
||
// For external link, record that we need to tell the external linker -s,
|
||
// and turn off -s internally: the external linker needs the symbol
|
||
// information for its final link.
|
||
debug_s = *FlagS
|
||
*FlagS = false
|
||
|
||
// create temporary directory and arrange cleanup
|
||
if *flagTmpdir == "" {
|
||
dir, err := ioutil.TempDir("", "go-link-")
|
||
if err != nil {
|
||
log.Fatal(err)
|
||
}
|
||
*flagTmpdir = dir
|
||
ownTmpDir = true
|
||
AtExit(func() {
|
||
ctxt.Out.Close()
|
||
os.RemoveAll(*flagTmpdir)
|
||
})
|
||
}
|
||
|
||
// change our output to temporary object file
|
||
if err := ctxt.Out.Close(); err != nil {
|
||
Exitf("error closing output file")
|
||
}
|
||
mayberemoveoutfile()
|
||
|
||
p := filepath.Join(*flagTmpdir, "go.o")
|
||
if err := ctxt.Out.Open(p); err != nil {
|
||
Exitf("cannot create %s: %v", p, err)
|
||
}
|
||
}
|
||
|
||
// hostobjCopy creates a copy of the object files in hostobj in a
|
||
// temporary directory.
|
||
func hostobjCopy() (paths []string) {
|
||
var wg sync.WaitGroup
|
||
sema := make(chan struct{}, runtime.NumCPU()) // limit open file descriptors
|
||
for i, h := range hostobj {
|
||
h := h
|
||
dst := filepath.Join(*flagTmpdir, fmt.Sprintf("%06d.o", i))
|
||
paths = append(paths, dst)
|
||
|
||
wg.Add(1)
|
||
go func() {
|
||
sema <- struct{}{}
|
||
defer func() {
|
||
<-sema
|
||
wg.Done()
|
||
}()
|
||
f, err := os.Open(h.file)
|
||
if err != nil {
|
||
Exitf("cannot reopen %s: %v", h.pn, err)
|
||
}
|
||
defer f.Close()
|
||
if _, err := f.Seek(h.off, 0); err != nil {
|
||
Exitf("cannot seek %s: %v", h.pn, err)
|
||
}
|
||
|
||
w, err := os.Create(dst)
|
||
if err != nil {
|
||
Exitf("cannot create %s: %v", dst, err)
|
||
}
|
||
if _, err := io.CopyN(w, f, h.length); err != nil {
|
||
Exitf("cannot write %s: %v", dst, err)
|
||
}
|
||
if err := w.Close(); err != nil {
|
||
Exitf("cannot close %s: %v", dst, err)
|
||
}
|
||
}()
|
||
}
|
||
wg.Wait()
|
||
return paths
|
||
}
|
||
|
||
// writeGDBLinkerScript creates gcc linker script file in temp
|
||
// directory. writeGDBLinkerScript returns created file path.
|
||
// The script is used to work around gcc bug
|
||
// (see https://golang.org/issue/20183 for details).
|
||
func writeGDBLinkerScript() string {
|
||
name := "fix_debug_gdb_scripts.ld"
|
||
path := filepath.Join(*flagTmpdir, name)
|
||
src := `SECTIONS
|
||
{
|
||
.debug_gdb_scripts BLOCK(__section_alignment__) (NOLOAD) :
|
||
{
|
||
*(.debug_gdb_scripts)
|
||
}
|
||
}
|
||
INSERT AFTER .debug_types;
|
||
`
|
||
err := ioutil.WriteFile(path, []byte(src), 0666)
|
||
if err != nil {
|
||
Errorf(nil, "WriteFile %s failed: %v", name, err)
|
||
}
|
||
return path
|
||
}
|
||
|
||
// archive builds a .a archive from the hostobj object files.
|
||
func (ctxt *Link) archive() {
|
||
if ctxt.BuildMode != BuildModeCArchive {
|
||
return
|
||
}
|
||
|
||
exitIfErrors()
|
||
|
||
if *flagExtar == "" {
|
||
*flagExtar = "ar"
|
||
}
|
||
|
||
mayberemoveoutfile()
|
||
|
||
// Force the buffer to flush here so that external
|
||
// tools will see a complete file.
|
||
if err := ctxt.Out.Close(); err != nil {
|
||
Exitf("error closing %v", *flagOutfile)
|
||
}
|
||
|
||
argv := []string{*flagExtar, "-q", "-c", "-s"}
|
||
if ctxt.HeadType == objabi.Haix {
|
||
argv = append(argv, "-X64")
|
||
}
|
||
argv = append(argv, *flagOutfile)
|
||
argv = append(argv, filepath.Join(*flagTmpdir, "go.o"))
|
||
argv = append(argv, hostobjCopy()...)
|
||
|
||
if ctxt.Debugvlog != 0 {
|
||
ctxt.Logf("archive: %s\n", strings.Join(argv, " "))
|
||
}
|
||
|
||
// If supported, use syscall.Exec() to invoke the archive command,
|
||
// which should be the final remaining step needed for the link.
|
||
// This will reduce peak RSS for the link (and speed up linking of
|
||
// large applications), since when the archive command runs we
|
||
// won't be holding onto all of the linker's live memory.
|
||
if syscallExecSupported && !ownTmpDir {
|
||
runAtExitFuncs()
|
||
ctxt.execArchive(argv)
|
||
panic("should not get here")
|
||
}
|
||
|
||
// Otherwise invoke 'ar' in the usual way (fork + exec).
|
||
if out, err := exec.Command(argv[0], argv[1:]...).CombinedOutput(); err != nil {
|
||
Exitf("running %s failed: %v\n%s", argv[0], err, out)
|
||
}
|
||
}
|
||
|
||
func (ctxt *Link) hostlink() {
|
||
if ctxt.LinkMode != LinkExternal || nerrors > 0 {
|
||
return
|
||
}
|
||
if ctxt.BuildMode == BuildModeCArchive {
|
||
return
|
||
}
|
||
|
||
var argv []string
|
||
argv = append(argv, ctxt.extld())
|
||
argv = append(argv, hostlinkArchArgs(ctxt.Arch)...)
|
||
|
||
if *FlagS || debug_s {
|
||
if ctxt.HeadType == objabi.Hdarwin {
|
||
// Recent versions of macOS print
|
||
// ld: warning: option -s is obsolete and being ignored
|
||
// so do not pass any arguments.
|
||
} else {
|
||
argv = append(argv, "-s")
|
||
}
|
||
}
|
||
|
||
switch ctxt.HeadType {
|
||
case objabi.Hdarwin:
|
||
if machoPlatform == PLATFORM_MACOS {
|
||
// -headerpad is incompatible with -fembed-bitcode.
|
||
argv = append(argv, "-Wl,-headerpad,1144")
|
||
}
|
||
if ctxt.DynlinkingGo() && !ctxt.Arch.InFamily(sys.ARM, sys.ARM64) {
|
||
argv = append(argv, "-Wl,-flat_namespace")
|
||
}
|
||
case objabi.Hopenbsd:
|
||
argv = append(argv, "-Wl,-nopie")
|
||
case objabi.Hwindows:
|
||
if windowsgui {
|
||
argv = append(argv, "-mwindows")
|
||
} else {
|
||
argv = append(argv, "-mconsole")
|
||
}
|
||
// Mark as having awareness of terminal services, to avoid
|
||
// ancient compatibility hacks.
|
||
argv = append(argv, "-Wl,--tsaware")
|
||
|
||
// Enable DEP
|
||
argv = append(argv, "-Wl,--nxcompat")
|
||
|
||
argv = append(argv, fmt.Sprintf("-Wl,--major-os-version=%d", PeMinimumTargetMajorVersion))
|
||
argv = append(argv, fmt.Sprintf("-Wl,--minor-os-version=%d", PeMinimumTargetMinorVersion))
|
||
argv = append(argv, fmt.Sprintf("-Wl,--major-subsystem-version=%d", PeMinimumTargetMajorVersion))
|
||
argv = append(argv, fmt.Sprintf("-Wl,--minor-subsystem-version=%d", PeMinimumTargetMinorVersion))
|
||
case objabi.Haix:
|
||
argv = append(argv, "-pthread")
|
||
// prevent ld to reorder .text functions to keep the same
|
||
// first/last functions for moduledata.
|
||
argv = append(argv, "-Wl,-bnoobjreorder")
|
||
// mcmodel=large is needed for every gcc generated files, but
|
||
// ld still need -bbigtoc in order to allow larger TOC.
|
||
argv = append(argv, "-mcmodel=large")
|
||
argv = append(argv, "-Wl,-bbigtoc")
|
||
}
|
||
|
||
switch ctxt.BuildMode {
|
||
case BuildModeExe:
|
||
if ctxt.HeadType == objabi.Hdarwin {
|
||
if machoPlatform == PLATFORM_MACOS {
|
||
argv = append(argv, "-Wl,-no_pie")
|
||
argv = append(argv, "-Wl,-pagezero_size,4000000")
|
||
}
|
||
}
|
||
case BuildModePIE:
|
||
switch ctxt.HeadType {
|
||
case objabi.Hdarwin, objabi.Haix:
|
||
case objabi.Hwindows:
|
||
// Enable ASLR.
|
||
argv = append(argv, "-Wl,--dynamicbase")
|
||
// enable high-entropy ASLR on 64-bit.
|
||
if ctxt.Arch.PtrSize >= 8 {
|
||
argv = append(argv, "-Wl,--high-entropy-va")
|
||
}
|
||
// Work around binutils limitation that strips relocation table for dynamicbase.
|
||
// See https://sourceware.org/bugzilla/show_bug.cgi?id=19011
|
||
argv = append(argv, "-Wl,--export-all-symbols")
|
||
default:
|
||
// ELF.
|
||
if ctxt.UseRelro() {
|
||
argv = append(argv, "-Wl,-z,relro")
|
||
}
|
||
argv = append(argv, "-pie")
|
||
}
|
||
case BuildModeCShared:
|
||
if ctxt.HeadType == objabi.Hdarwin {
|
||
argv = append(argv, "-dynamiclib")
|
||
if ctxt.Arch.Family != sys.AMD64 {
|
||
argv = append(argv, "-Wl,-read_only_relocs,suppress")
|
||
}
|
||
} else {
|
||
// ELF.
|
||
argv = append(argv, "-Wl,-Bsymbolic")
|
||
if ctxt.UseRelro() {
|
||
argv = append(argv, "-Wl,-z,relro")
|
||
}
|
||
argv = append(argv, "-shared")
|
||
if ctxt.HeadType != objabi.Hwindows {
|
||
// Pass -z nodelete to mark the shared library as
|
||
// non-closeable: a dlclose will do nothing.
|
||
argv = append(argv, "-Wl,-z,nodelete")
|
||
}
|
||
}
|
||
case BuildModeShared:
|
||
if ctxt.UseRelro() {
|
||
argv = append(argv, "-Wl,-z,relro")
|
||
}
|
||
argv = append(argv, "-shared")
|
||
case BuildModePlugin:
|
||
if ctxt.HeadType == objabi.Hdarwin {
|
||
argv = append(argv, "-dynamiclib")
|
||
} else {
|
||
if ctxt.UseRelro() {
|
||
argv = append(argv, "-Wl,-z,relro")
|
||
}
|
||
argv = append(argv, "-shared")
|
||
}
|
||
}
|
||
|
||
if ctxt.IsELF && ctxt.DynlinkingGo() {
|
||
// We force all symbol resolution to be done at program startup
|
||
// because lazy PLT resolution can use large amounts of stack at
|
||
// times we cannot allow it to do so.
|
||
argv = append(argv, "-Wl,-znow")
|
||
|
||
// Do not let the host linker generate COPY relocations. These
|
||
// can move symbols out of sections that rely on stable offsets
|
||
// from the beginning of the section (like sym.STYPE).
|
||
argv = append(argv, "-Wl,-znocopyreloc")
|
||
|
||
if ctxt.Arch.InFamily(sys.ARM, sys.ARM64) && objabi.GOOS == "linux" {
|
||
// On ARM, the GNU linker will generate COPY relocations
|
||
// even with -znocopyreloc set.
|
||
// https://sourceware.org/bugzilla/show_bug.cgi?id=19962
|
||
//
|
||
// On ARM64, the GNU linker will fail instead of
|
||
// generating COPY relocations.
|
||
//
|
||
// In both cases, switch to gold.
|
||
argv = append(argv, "-fuse-ld=gold")
|
||
|
||
// If gold is not installed, gcc will silently switch
|
||
// back to ld.bfd. So we parse the version information
|
||
// and provide a useful error if gold is missing.
|
||
cmd := exec.Command(*flagExtld, "-fuse-ld=gold", "-Wl,--version")
|
||
if out, err := cmd.CombinedOutput(); err == nil {
|
||
if !bytes.Contains(out, []byte("GNU gold")) {
|
||
log.Fatalf("ARM external linker must be gold (issue #15696), but is not: %s", out)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if ctxt.Arch.Family == sys.ARM64 && objabi.GOOS == "freebsd" {
|
||
// Switch to ld.bfd on freebsd/arm64.
|
||
argv = append(argv, "-fuse-ld=bfd")
|
||
|
||
// Provide a useful error if ld.bfd is missing.
|
||
cmd := exec.Command(*flagExtld, "-fuse-ld=bfd", "-Wl,--version")
|
||
if out, err := cmd.CombinedOutput(); err == nil {
|
||
if !bytes.Contains(out, []byte("GNU ld")) {
|
||
log.Fatalf("ARM64 external linker must be ld.bfd (issue #35197), please install devel/binutils")
|
||
}
|
||
}
|
||
}
|
||
|
||
if ctxt.IsELF && len(buildinfo) > 0 {
|
||
argv = append(argv, fmt.Sprintf("-Wl,--build-id=0x%x", buildinfo))
|
||
}
|
||
|
||
// On Windows, given -o foo, GCC will append ".exe" to produce
|
||
// "foo.exe". We have decided that we want to honor the -o
|
||
// option. To make this work, we append a '.' so that GCC
|
||
// will decide that the file already has an extension. We
|
||
// only want to do this when producing a Windows output file
|
||
// on a Windows host.
|
||
outopt := *flagOutfile
|
||
if objabi.GOOS == "windows" && runtime.GOOS == "windows" && filepath.Ext(outopt) == "" {
|
||
outopt += "."
|
||
}
|
||
argv = append(argv, "-o")
|
||
argv = append(argv, outopt)
|
||
|
||
if rpath.val != "" {
|
||
argv = append(argv, fmt.Sprintf("-Wl,-rpath,%s", rpath.val))
|
||
}
|
||
|
||
// Force global symbols to be exported for dlopen, etc.
|
||
if ctxt.IsELF {
|
||
argv = append(argv, "-rdynamic")
|
||
}
|
||
if ctxt.HeadType == objabi.Haix {
|
||
fileName := xcoffCreateExportFile(ctxt)
|
||
argv = append(argv, "-Wl,-bE:"+fileName)
|
||
}
|
||
|
||
if strings.Contains(argv[0], "clang") {
|
||
argv = append(argv, "-Qunused-arguments")
|
||
}
|
||
|
||
const compressDWARF = "-Wl,--compress-debug-sections=zlib-gnu"
|
||
if ctxt.compressDWARF && linkerFlagSupported(argv[0], compressDWARF) {
|
||
argv = append(argv, compressDWARF)
|
||
}
|
||
|
||
argv = append(argv, filepath.Join(*flagTmpdir, "go.o"))
|
||
argv = append(argv, hostobjCopy()...)
|
||
if ctxt.HeadType == objabi.Haix {
|
||
// We want to have C files after Go files to remove
|
||
// trampolines csects made by ld.
|
||
argv = append(argv, "-nostartfiles")
|
||
argv = append(argv, "/lib/crt0_64.o")
|
||
|
||
extld := ctxt.extld()
|
||
// Get starting files.
|
||
getPathFile := func(file string) string {
|
||
args := []string{"-maix64", "--print-file-name=" + file}
|
||
out, err := exec.Command(extld, args...).CombinedOutput()
|
||
if err != nil {
|
||
log.Fatalf("running %s failed: %v\n%s", extld, err, out)
|
||
}
|
||
return strings.Trim(string(out), "\n")
|
||
}
|
||
argv = append(argv, getPathFile("crtcxa.o"))
|
||
argv = append(argv, getPathFile("crtdbase.o"))
|
||
}
|
||
|
||
if ctxt.linkShared {
|
||
seenDirs := make(map[string]bool)
|
||
seenLibs := make(map[string]bool)
|
||
addshlib := func(path string) {
|
||
dir, base := filepath.Split(path)
|
||
if !seenDirs[dir] {
|
||
argv = append(argv, "-L"+dir)
|
||
if !rpath.set {
|
||
argv = append(argv, "-Wl,-rpath="+dir)
|
||
}
|
||
seenDirs[dir] = true
|
||
}
|
||
base = strings.TrimSuffix(base, ".so")
|
||
base = strings.TrimPrefix(base, "lib")
|
||
if !seenLibs[base] {
|
||
argv = append(argv, "-l"+base)
|
||
seenLibs[base] = true
|
||
}
|
||
}
|
||
for _, shlib := range ctxt.Shlibs {
|
||
addshlib(shlib.Path)
|
||
for _, dep := range shlib.Deps {
|
||
if dep == "" {
|
||
continue
|
||
}
|
||
libpath := findshlib(ctxt, dep)
|
||
if libpath != "" {
|
||
addshlib(libpath)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// clang, unlike GCC, passes -rdynamic to the linker
|
||
// even when linking with -static, causing a linker
|
||
// error when using GNU ld. So take out -rdynamic if
|
||
// we added it. We do it in this order, rather than
|
||
// only adding -rdynamic later, so that -*extldflags
|
||
// can override -rdynamic without using -static.
|
||
checkStatic := func(arg string) {
|
||
if ctxt.IsELF && arg == "-static" {
|
||
for i := range argv {
|
||
if argv[i] == "-rdynamic" {
|
||
argv[i] = "-static"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
for _, p := range ldflag {
|
||
argv = append(argv, p)
|
||
checkStatic(p)
|
||
}
|
||
|
||
// When building a program with the default -buildmode=exe the
|
||
// gc compiler generates code requires DT_TEXTREL in a
|
||
// position independent executable (PIE). On systems where the
|
||
// toolchain creates PIEs by default, and where DT_TEXTREL
|
||
// does not work, the resulting programs will not run. See
|
||
// issue #17847. To avoid this problem pass -no-pie to the
|
||
// toolchain if it is supported.
|
||
if ctxt.BuildMode == BuildModeExe && !ctxt.linkShared {
|
||
// GCC uses -no-pie, clang uses -nopie.
|
||
for _, nopie := range []string{"-no-pie", "-nopie"} {
|
||
if linkerFlagSupported(argv[0], nopie) {
|
||
argv = append(argv, nopie)
|
||
break
|
||
}
|
||
}
|
||
}
|
||
|
||
for _, p := range strings.Fields(*flagExtldflags) {
|
||
argv = append(argv, p)
|
||
checkStatic(p)
|
||
}
|
||
if ctxt.HeadType == objabi.Hwindows {
|
||
// use gcc linker script to work around gcc bug
|
||
// (see https://golang.org/issue/20183 for details).
|
||
p := writeGDBLinkerScript()
|
||
argv = append(argv, "-Wl,-T,"+p)
|
||
// libmingw32 and libmingwex have some inter-dependencies,
|
||
// so must use linker groups.
|
||
argv = append(argv, "-Wl,--start-group", "-lmingwex", "-lmingw32", "-Wl,--end-group")
|
||
argv = append(argv, peimporteddlls()...)
|
||
}
|
||
|
||
if ctxt.Debugvlog != 0 {
|
||
ctxt.Logf("host link:")
|
||
for _, v := range argv {
|
||
ctxt.Logf(" %q", v)
|
||
}
|
||
ctxt.Logf("\n")
|
||
}
|
||
|
||
out, err := exec.Command(argv[0], argv[1:]...).CombinedOutput()
|
||
if err != nil {
|
||
Exitf("running %s failed: %v\n%s", argv[0], err, out)
|
||
}
|
||
|
||
// Filter out useless linker warnings caused by bugs outside Go.
|
||
// See also cmd/go/internal/work/exec.go's gccld method.
|
||
var save [][]byte
|
||
var skipLines int
|
||
for _, line := range bytes.SplitAfter(out, []byte("\n")) {
|
||
// golang.org/issue/26073 - Apple Xcode bug
|
||
if bytes.Contains(line, []byte("ld: warning: text-based stub file")) {
|
||
continue
|
||
}
|
||
|
||
if skipLines > 0 {
|
||
skipLines--
|
||
continue
|
||
}
|
||
|
||
// Remove TOC overflow warning on AIX.
|
||
if bytes.Contains(line, []byte("ld: 0711-783")) {
|
||
skipLines = 2
|
||
continue
|
||
}
|
||
|
||
save = append(save, line)
|
||
}
|
||
out = bytes.Join(save, nil)
|
||
|
||
if len(out) > 0 {
|
||
// always print external output even if the command is successful, so that we don't
|
||
// swallow linker warnings (see https://golang.org/issue/17935).
|
||
ctxt.Logf("%s", out)
|
||
}
|
||
|
||
if !*FlagS && !*FlagW && !debug_s && ctxt.HeadType == objabi.Hdarwin {
|
||
dsym := filepath.Join(*flagTmpdir, "go.dwarf")
|
||
if out, err := exec.Command("dsymutil", "-f", *flagOutfile, "-o", dsym).CombinedOutput(); err != nil {
|
||
Exitf("%s: running dsymutil failed: %v\n%s", os.Args[0], err, out)
|
||
}
|
||
// Skip combining if `dsymutil` didn't generate a file. See #11994.
|
||
if _, err := os.Stat(dsym); os.IsNotExist(err) {
|
||
return
|
||
}
|
||
// For os.Rename to work reliably, must be in same directory as outfile.
|
||
combinedOutput := *flagOutfile + "~"
|
||
exef, err := os.Open(*flagOutfile)
|
||
if err != nil {
|
||
Exitf("%s: combining dwarf failed: %v", os.Args[0], err)
|
||
}
|
||
defer exef.Close()
|
||
exem, err := macho.NewFile(exef)
|
||
if err != nil {
|
||
Exitf("%s: parsing Mach-O header failed: %v", os.Args[0], err)
|
||
}
|
||
// Only macOS supports unmapped segments such as our __DWARF segment.
|
||
if machoPlatform == PLATFORM_MACOS {
|
||
if err := machoCombineDwarf(ctxt, exef, exem, dsym, combinedOutput); err != nil {
|
||
Exitf("%s: combining dwarf failed: %v", os.Args[0], err)
|
||
}
|
||
os.Remove(*flagOutfile)
|
||
if err := os.Rename(combinedOutput, *flagOutfile); err != nil {
|
||
Exitf("%s: %v", os.Args[0], err)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
var createTrivialCOnce sync.Once
|
||
|
||
func linkerFlagSupported(linker, flag string) bool {
|
||
createTrivialCOnce.Do(func() {
|
||
src := filepath.Join(*flagTmpdir, "trivial.c")
|
||
if err := ioutil.WriteFile(src, []byte("int main() { return 0; }"), 0666); err != nil {
|
||
Errorf(nil, "WriteFile trivial.c failed: %v", err)
|
||
}
|
||
})
|
||
|
||
flagsWithNextArgSkip := []string{
|
||
"-F",
|
||
"-l",
|
||
"-L",
|
||
"-framework",
|
||
"-Wl,-framework",
|
||
"-Wl,-rpath",
|
||
"-Wl,-undefined",
|
||
}
|
||
flagsWithNextArgKeep := []string{
|
||
"-arch",
|
||
"-isysroot",
|
||
"--sysroot",
|
||
"-target",
|
||
}
|
||
prefixesToKeep := []string{
|
||
"-f",
|
||
"-m",
|
||
"-p",
|
||
"-Wl,",
|
||
"-arch",
|
||
"-isysroot",
|
||
"--sysroot",
|
||
"-target",
|
||
}
|
||
|
||
var flags []string
|
||
keep := false
|
||
skip := false
|
||
extldflags := strings.Fields(*flagExtldflags)
|
||
for _, f := range append(extldflags, ldflag...) {
|
||
if keep {
|
||
flags = append(flags, f)
|
||
keep = false
|
||
} else if skip {
|
||
skip = false
|
||
} else if f == "" || f[0] != '-' {
|
||
} else if contains(flagsWithNextArgSkip, f) {
|
||
skip = true
|
||
} else if contains(flagsWithNextArgKeep, f) {
|
||
flags = append(flags, f)
|
||
keep = true
|
||
} else {
|
||
for _, p := range prefixesToKeep {
|
||
if strings.HasPrefix(f, p) {
|
||
flags = append(flags, f)
|
||
break
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
flags = append(flags, flag, "trivial.c")
|
||
|
||
cmd := exec.Command(linker, flags...)
|
||
cmd.Dir = *flagTmpdir
|
||
cmd.Env = append([]string{"LC_ALL=C"}, os.Environ()...)
|
||
out, err := cmd.CombinedOutput()
|
||
// GCC says "unrecognized command line option ‘-no-pie’"
|
||
// clang says "unknown argument: '-no-pie'"
|
||
return err == nil && !bytes.Contains(out, []byte("unrecognized")) && !bytes.Contains(out, []byte("unknown"))
|
||
}
|
||
|
||
// hostlinkArchArgs returns arguments to pass to the external linker
|
||
// based on the architecture.
|
||
func hostlinkArchArgs(arch *sys.Arch) []string {
|
||
switch arch.Family {
|
||
case sys.I386:
|
||
return []string{"-m32"}
|
||
case sys.AMD64, sys.S390X:
|
||
return []string{"-m64"}
|
||
case sys.ARM:
|
||
return []string{"-marm"}
|
||
case sys.ARM64:
|
||
// nothing needed
|
||
case sys.MIPS64:
|
||
return []string{"-mabi=64"}
|
||
case sys.MIPS:
|
||
return []string{"-mabi=32"}
|
||
case sys.PPC64:
|
||
if objabi.GOOS == "aix" {
|
||
return []string{"-maix64"}
|
||
} else {
|
||
return []string{"-m64"}
|
||
}
|
||
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// ldobj loads an input object. If it is a host object (an object
|
||
// compiled by a non-Go compiler) it returns the Hostobj pointer. If
|
||
// it is a Go object, it returns nil.
|
||
func ldobj(ctxt *Link, f *bio.Reader, lib *sym.Library, length int64, pn string, file string) *Hostobj {
|
||
pkg := objabi.PathToPrefix(lib.Pkg)
|
||
|
||
eof := f.Offset() + length
|
||
start := f.Offset()
|
||
c1 := bgetc(f)
|
||
c2 := bgetc(f)
|
||
c3 := bgetc(f)
|
||
c4 := bgetc(f)
|
||
f.MustSeek(start, 0)
|
||
|
||
unit := &sym.CompilationUnit{Lib: lib}
|
||
lib.Units = append(lib.Units, unit)
|
||
|
||
magic := uint32(c1)<<24 | uint32(c2)<<16 | uint32(c3)<<8 | uint32(c4)
|
||
if magic == 0x7f454c46 { // \x7F E L F
|
||
ldelf := func(ctxt *Link, f *bio.Reader, pkg string, length int64, pn string) {
|
||
textp, flags, err := loadelf.Load(ctxt.loader, ctxt.Arch, ctxt.Syms.IncVersion(), f, pkg, length, pn, ehdr.flags)
|
||
if err != nil {
|
||
Errorf(nil, "%v", err)
|
||
return
|
||
}
|
||
ehdr.flags = flags
|
||
ctxt.Textp2 = append(ctxt.Textp2, textp...)
|
||
}
|
||
return ldhostobj(ldelf, ctxt.HeadType, f, pkg, length, pn, file)
|
||
}
|
||
|
||
if magic&^1 == 0xfeedface || magic&^0x01000000 == 0xcefaedfe {
|
||
ldmacho := func(ctxt *Link, f *bio.Reader, pkg string, length int64, pn string) {
|
||
textp, err := loadmacho.Load(ctxt.loader, ctxt.Arch, ctxt.Syms.IncVersion(), f, pkg, length, pn)
|
||
if err != nil {
|
||
Errorf(nil, "%v", err)
|
||
return
|
||
}
|
||
ctxt.Textp2 = append(ctxt.Textp2, textp...)
|
||
}
|
||
return ldhostobj(ldmacho, ctxt.HeadType, f, pkg, length, pn, file)
|
||
}
|
||
|
||
if c1 == 0x4c && c2 == 0x01 || c1 == 0x64 && c2 == 0x86 {
|
||
ldpe := func(ctxt *Link, f *bio.Reader, pkg string, length int64, pn string) {
|
||
textp, rsrc, err := loadpe.Load(ctxt.loader, ctxt.Arch, ctxt.Syms.IncVersion(), f, pkg, length, pn)
|
||
if err != nil {
|
||
Errorf(nil, "%v", err)
|
||
return
|
||
}
|
||
if rsrc != 0 {
|
||
setpersrc(ctxt, rsrc)
|
||
}
|
||
ctxt.Textp2 = append(ctxt.Textp2, textp...)
|
||
}
|
||
return ldhostobj(ldpe, ctxt.HeadType, f, pkg, length, pn, file)
|
||
}
|
||
|
||
if c1 == 0x01 && (c2 == 0xD7 || c2 == 0xF7) {
|
||
ldxcoff := func(ctxt *Link, f *bio.Reader, pkg string, length int64, pn string) {
|
||
textp, err := loadxcoff.Load(ctxt.loader, ctxt.Arch, ctxt.Syms.IncVersion(), f, pkg, length, pn)
|
||
if err != nil {
|
||
Errorf(nil, "%v", err)
|
||
return
|
||
}
|
||
ctxt.Textp2 = append(ctxt.Textp2, textp...)
|
||
}
|
||
return ldhostobj(ldxcoff, ctxt.HeadType, f, pkg, length, pn, file)
|
||
}
|
||
|
||
/* check the header */
|
||
line, err := f.ReadString('\n')
|
||
if err != nil {
|
||
Errorf(nil, "truncated object file: %s: %v", pn, err)
|
||
return nil
|
||
}
|
||
|
||
if !strings.HasPrefix(line, "go object ") {
|
||
if strings.HasSuffix(pn, ".go") {
|
||
Exitf("%s: uncompiled .go source file", pn)
|
||
return nil
|
||
}
|
||
|
||
if line == ctxt.Arch.Name {
|
||
// old header format: just $GOOS
|
||
Errorf(nil, "%s: stale object file", pn)
|
||
return nil
|
||
}
|
||
|
||
Errorf(nil, "%s: not an object file", pn)
|
||
return nil
|
||
}
|
||
|
||
// First, check that the basic GOOS, GOARCH, and Version match.
|
||
t := fmt.Sprintf("%s %s %s ", objabi.GOOS, objabi.GOARCH, objabi.Version)
|
||
|
||
line = strings.TrimRight(line, "\n")
|
||
if !strings.HasPrefix(line[10:]+" ", t) && !*flagF {
|
||
Errorf(nil, "%s: object is [%s] expected [%s]", pn, line[10:], t)
|
||
return nil
|
||
}
|
||
|
||
// Second, check that longer lines match each other exactly,
|
||
// so that the Go compiler and write additional information
|
||
// that must be the same from run to run.
|
||
if len(line) >= len(t)+10 {
|
||
if theline == "" {
|
||
theline = line[10:]
|
||
} else if theline != line[10:] {
|
||
Errorf(nil, "%s: object is [%s] expected [%s]", pn, line[10:], theline)
|
||
return nil
|
||
}
|
||
}
|
||
|
||
// Skip over exports and other info -- ends with \n!\n.
|
||
//
|
||
// Note: It's possible for "\n!\n" to appear within the binary
|
||
// package export data format. To avoid truncating the package
|
||
// definition prematurely (issue 21703), we keep track of
|
||
// how many "$$" delimiters we've seen.
|
||
|
||
import0 := f.Offset()
|
||
|
||
c1 = '\n' // the last line ended in \n
|
||
c2 = bgetc(f)
|
||
c3 = bgetc(f)
|
||
markers := 0
|
||
for {
|
||
if c1 == '\n' {
|
||
if markers%2 == 0 && c2 == '!' && c3 == '\n' {
|
||
break
|
||
}
|
||
if c2 == '$' && c3 == '$' {
|
||
markers++
|
||
}
|
||
}
|
||
|
||
c1 = c2
|
||
c2 = c3
|
||
c3 = bgetc(f)
|
||
if c3 == -1 {
|
||
Errorf(nil, "truncated object file: %s", pn)
|
||
return nil
|
||
}
|
||
}
|
||
|
||
import1 := f.Offset()
|
||
|
||
f.MustSeek(import0, 0)
|
||
ldpkg(ctxt, f, lib, import1-import0-2, pn) // -2 for !\n
|
||
f.MustSeek(import1, 0)
|
||
|
||
fingerprint := ctxt.loader.Preload(ctxt.Syms, f, lib, unit, eof-f.Offset())
|
||
if !fingerprint.IsZero() { // Assembly objects don't have fingerprints. Ignore them.
|
||
// Check fingerprint, to ensure the importing and imported packages
|
||
// have consistent view of symbol indices.
|
||
// Normally the go command should ensure this. But in case something
|
||
// goes wrong, it could lead to obscure bugs like run-time crash.
|
||
// Check it here to be sure.
|
||
if lib.Fingerprint.IsZero() { // Not yet imported. Update its fingerprint.
|
||
lib.Fingerprint = fingerprint
|
||
}
|
||
checkFingerprint(lib, fingerprint, lib.Srcref, lib.Fingerprint)
|
||
}
|
||
|
||
addImports(ctxt, lib, pn)
|
||
return nil
|
||
}
|
||
|
||
func checkFingerprint(lib *sym.Library, libfp goobj2.FingerprintType, src string, srcfp goobj2.FingerprintType) {
|
||
if libfp != srcfp {
|
||
Exitf("fingerprint mismatch: %s has %x, import from %s expecting %x", lib, libfp, src, srcfp)
|
||
}
|
||
}
|
||
|
||
func readelfsymboldata(ctxt *Link, f *elf.File, sym *elf.Symbol) []byte {
|
||
data := make([]byte, sym.Size)
|
||
sect := f.Sections[sym.Section]
|
||
if sect.Type != elf.SHT_PROGBITS && sect.Type != elf.SHT_NOTE {
|
||
Errorf(nil, "reading %s from non-data section", sym.Name)
|
||
}
|
||
n, err := sect.ReadAt(data, int64(sym.Value-sect.Addr))
|
||
if uint64(n) != sym.Size {
|
||
Errorf(nil, "reading contents of %s: %v", sym.Name, err)
|
||
}
|
||
return data
|
||
}
|
||
|
||
func readwithpad(r io.Reader, sz int32) ([]byte, error) {
|
||
data := make([]byte, Rnd(int64(sz), 4))
|
||
_, err := io.ReadFull(r, data)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
data = data[:sz]
|
||
return data, nil
|
||
}
|
||
|
||
func readnote(f *elf.File, name []byte, typ int32) ([]byte, error) {
|
||
for _, sect := range f.Sections {
|
||
if sect.Type != elf.SHT_NOTE {
|
||
continue
|
||
}
|
||
r := sect.Open()
|
||
for {
|
||
var namesize, descsize, noteType int32
|
||
err := binary.Read(r, f.ByteOrder, &namesize)
|
||
if err != nil {
|
||
if err == io.EOF {
|
||
break
|
||
}
|
||
return nil, fmt.Errorf("read namesize failed: %v", err)
|
||
}
|
||
err = binary.Read(r, f.ByteOrder, &descsize)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("read descsize failed: %v", err)
|
||
}
|
||
err = binary.Read(r, f.ByteOrder, ¬eType)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("read type failed: %v", err)
|
||
}
|
||
noteName, err := readwithpad(r, namesize)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("read name failed: %v", err)
|
||
}
|
||
desc, err := readwithpad(r, descsize)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("read desc failed: %v", err)
|
||
}
|
||
if string(name) == string(noteName) && typ == noteType {
|
||
return desc, nil
|
||
}
|
||
}
|
||
}
|
||
return nil, nil
|
||
}
|
||
|
||
func findshlib(ctxt *Link, shlib string) string {
|
||
if filepath.IsAbs(shlib) {
|
||
return shlib
|
||
}
|
||
for _, libdir := range ctxt.Libdir {
|
||
libpath := filepath.Join(libdir, shlib)
|
||
if _, err := os.Stat(libpath); err == nil {
|
||
return libpath
|
||
}
|
||
}
|
||
Errorf(nil, "cannot find shared library: %s", shlib)
|
||
return ""
|
||
}
|
||
|
||
func ldshlibsyms(ctxt *Link, shlib string) {
|
||
var libpath string
|
||
if filepath.IsAbs(shlib) {
|
||
libpath = shlib
|
||
shlib = filepath.Base(shlib)
|
||
} else {
|
||
libpath = findshlib(ctxt, shlib)
|
||
if libpath == "" {
|
||
return
|
||
}
|
||
}
|
||
for _, processedlib := range ctxt.Shlibs {
|
||
if processedlib.Path == libpath {
|
||
return
|
||
}
|
||
}
|
||
if ctxt.Debugvlog > 1 {
|
||
ctxt.Logf("ldshlibsyms: found library with name %s at %s\n", shlib, libpath)
|
||
}
|
||
|
||
f, err := elf.Open(libpath)
|
||
if err != nil {
|
||
Errorf(nil, "cannot open shared library: %s", libpath)
|
||
return
|
||
}
|
||
defer f.Close()
|
||
|
||
hash, err := readnote(f, ELF_NOTE_GO_NAME, ELF_NOTE_GOABIHASH_TAG)
|
||
if err != nil {
|
||
Errorf(nil, "cannot read ABI hash from shared library %s: %v", libpath, err)
|
||
return
|
||
}
|
||
|
||
depsbytes, err := readnote(f, ELF_NOTE_GO_NAME, ELF_NOTE_GODEPS_TAG)
|
||
if err != nil {
|
||
Errorf(nil, "cannot read dep list from shared library %s: %v", libpath, err)
|
||
return
|
||
}
|
||
var deps []string
|
||
for _, dep := range strings.Split(string(depsbytes), "\n") {
|
||
if dep == "" {
|
||
continue
|
||
}
|
||
if !filepath.IsAbs(dep) {
|
||
// If the dep can be interpreted as a path relative to the shlib
|
||
// in which it was found, do that. Otherwise, we will leave it
|
||
// to be resolved by libdir lookup.
|
||
abs := filepath.Join(filepath.Dir(libpath), dep)
|
||
if _, err := os.Stat(abs); err == nil {
|
||
dep = abs
|
||
}
|
||
}
|
||
deps = append(deps, dep)
|
||
}
|
||
|
||
syms, err := f.DynamicSymbols()
|
||
if err != nil {
|
||
Errorf(nil, "cannot read symbols from shared library: %s", libpath)
|
||
return
|
||
}
|
||
gcdataLocations := make(map[uint64]loader.Sym)
|
||
for _, elfsym := range syms {
|
||
if elf.ST_TYPE(elfsym.Info) == elf.STT_NOTYPE || elf.ST_TYPE(elfsym.Info) == elf.STT_SECTION {
|
||
continue
|
||
}
|
||
|
||
// Symbols whose names start with "type." are compiler
|
||
// generated, so make functions with that prefix internal.
|
||
ver := 0
|
||
if elf.ST_TYPE(elfsym.Info) == elf.STT_FUNC && strings.HasPrefix(elfsym.Name, "type.") {
|
||
ver = sym.SymVerABIInternal
|
||
}
|
||
|
||
l := ctxt.loader
|
||
s := l.LookupOrCreateSym(elfsym.Name, ver)
|
||
|
||
// Because loadlib above loads all .a files before loading
|
||
// any shared libraries, any non-dynimport symbols we find
|
||
// that duplicate symbols already loaded should be ignored
|
||
// (the symbols from the .a files "win").
|
||
if l.SymType(s) != 0 && l.SymType(s) != sym.SDYNIMPORT {
|
||
continue
|
||
}
|
||
su := l.MakeSymbolUpdater(s)
|
||
su.SetType(sym.SDYNIMPORT)
|
||
l.SetSymElfType(s, elf.ST_TYPE(elfsym.Info))
|
||
su.SetSize(int64(elfsym.Size))
|
||
if elfsym.Section != elf.SHN_UNDEF {
|
||
// If it's not undefined, mark the symbol as reachable
|
||
// so as to protect it from dead code elimination,
|
||
// even if there aren't any explicit references to it.
|
||
// Under the previous sym.Symbol based regime this
|
||
// wasn't necessary, but for the loader-based deadcode
|
||
// it is definitely needed.
|
||
//
|
||
// FIXME: have a more general/flexible mechanism for this?
|
||
//
|
||
l.SetAttrReachable(s, true)
|
||
|
||
// Set .File for the library that actually defines the symbol.
|
||
l.SetSymPkg(s, libpath)
|
||
|
||
// The decodetype_* functions in decodetype.go need access to
|
||
// the type data.
|
||
sname := l.SymName(s)
|
||
if strings.HasPrefix(sname, "type.") && !strings.HasPrefix(sname, "type..") {
|
||
su.SetData(readelfsymboldata(ctxt, f, &elfsym))
|
||
gcdataLocations[elfsym.Value+2*uint64(ctxt.Arch.PtrSize)+8+1*uint64(ctxt.Arch.PtrSize)] = s
|
||
}
|
||
}
|
||
|
||
// For function symbols, we don't know what ABI is
|
||
// available, so alias it under both ABIs.
|
||
//
|
||
// TODO(austin): This is almost certainly wrong once
|
||
// the ABIs are actually different. We might have to
|
||
// mangle Go function names in the .so to include the
|
||
// ABI.
|
||
if elf.ST_TYPE(elfsym.Info) == elf.STT_FUNC && ver == 0 {
|
||
alias := ctxt.loader.LookupOrCreateSym(elfsym.Name, sym.SymVerABIInternal)
|
||
if l.SymType(alias) != 0 {
|
||
continue
|
||
}
|
||
su := l.MakeSymbolUpdater(alias)
|
||
su.SetType(sym.SABIALIAS)
|
||
su.AddReloc(loader.Reloc{Sym: s})
|
||
}
|
||
}
|
||
if ctxt.Arch.Family == sys.ARM64 {
|
||
for _, sect := range f.Sections {
|
||
if sect.Type == elf.SHT_RELA {
|
||
var rela elf.Rela64
|
||
rdr := sect.Open()
|
||
for {
|
||
err := binary.Read(rdr, f.ByteOrder, &rela)
|
||
if err == io.EOF {
|
||
break
|
||
} else if err != nil {
|
||
Errorf(nil, "reading relocation failed %v", err)
|
||
return
|
||
}
|
||
t := elf.R_AARCH64(rela.Info & 0xffff)
|
||
if t != elf.R_AARCH64_RELATIVE {
|
||
continue
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
ctxt.Shlibs = append(ctxt.Shlibs, Shlib{Path: libpath, Hash: hash, Deps: deps, File: f})
|
||
}
|
||
|
||
func addsection(ldr *loader.Loader, arch *sys.Arch, seg *sym.Segment, name string, rwx int) *sym.Section {
|
||
sect := ldr.NewSection()
|
||
sect.Rwx = uint8(rwx)
|
||
sect.Name = name
|
||
sect.Seg = seg
|
||
sect.Align = int32(arch.PtrSize) // everything is at least pointer-aligned
|
||
seg.Sections = append(seg.Sections, sect)
|
||
return sect
|
||
}
|
||
|
||
type chain struct {
|
||
sym loader.Sym
|
||
up *chain
|
||
limit int // limit on entry to sym
|
||
}
|
||
|
||
func haslinkregister(ctxt *Link) bool {
|
||
return ctxt.FixedFrameSize() != 0
|
||
}
|
||
|
||
func callsize(ctxt *Link) int {
|
||
if haslinkregister(ctxt) {
|
||
return 0
|
||
}
|
||
return ctxt.Arch.RegSize
|
||
}
|
||
|
||
type stkChk struct {
|
||
ldr *loader.Loader
|
||
ctxt *Link
|
||
morestack loader.Sym
|
||
done loader.Bitmap
|
||
}
|
||
|
||
// Walk the call tree and check that there is always enough stack space
|
||
// for the call frames, especially for a chain of nosplit functions.
|
||
func (ctxt *Link) dostkcheck() {
|
||
ldr := ctxt.loader
|
||
sc := stkChk{
|
||
ldr: ldr,
|
||
ctxt: ctxt,
|
||
morestack: ldr.Lookup("runtime.morestack", 0),
|
||
done: loader.MakeBitmap(ldr.NSym()),
|
||
}
|
||
|
||
// Every splitting function ensures that there are at least StackLimit
|
||
// bytes available below SP when the splitting prologue finishes.
|
||
// If the splitting function calls F, then F begins execution with
|
||
// at least StackLimit - callsize() bytes available.
|
||
// Check that every function behaves correctly with this amount
|
||
// of stack, following direct calls in order to piece together chains
|
||
// of non-splitting functions.
|
||
var ch chain
|
||
ch.limit = objabi.StackLimit - callsize(ctxt)
|
||
if objabi.GOARCH == "arm64" {
|
||
// need extra 8 bytes below SP to save FP
|
||
ch.limit -= 8
|
||
}
|
||
|
||
// Check every function, but do the nosplit functions in a first pass,
|
||
// to make the printed failure chains as short as possible.
|
||
for _, s := range ctxt.Textp2 {
|
||
if ldr.IsNoSplit(s) {
|
||
ch.sym = s
|
||
sc.check(&ch, 0)
|
||
}
|
||
}
|
||
|
||
for _, s := range ctxt.Textp2 {
|
||
if !ldr.IsNoSplit(s) {
|
||
ch.sym = s
|
||
sc.check(&ch, 0)
|
||
}
|
||
}
|
||
}
|
||
|
||
func (sc *stkChk) check(up *chain, depth int) int {
|
||
limit := up.limit
|
||
s := up.sym
|
||
ldr := sc.ldr
|
||
ctxt := sc.ctxt
|
||
|
||
// Don't duplicate work: only need to consider each
|
||
// function at top of safe zone once.
|
||
top := limit == objabi.StackLimit-callsize(ctxt)
|
||
if top {
|
||
if sc.done.Has(s) {
|
||
return 0
|
||
}
|
||
sc.done.Set(s)
|
||
}
|
||
|
||
if depth > 500 {
|
||
sc.ctxt.Errorf(s, "nosplit stack check too deep")
|
||
sc.broke(up, 0)
|
||
return -1
|
||
}
|
||
|
||
if ldr.AttrExternal(s) {
|
||
// external function.
|
||
// should never be called directly.
|
||
// onlyctxt.Diagnose the direct caller.
|
||
// TODO(mwhudson): actually think about this.
|
||
// TODO(khr): disabled for now. Calls to external functions can only happen on the g0 stack.
|
||
// See the trampolines in src/runtime/sys_darwin_$ARCH.go.
|
||
//if depth == 1 && ldr.SymType(s) != sym.SXREF && !ctxt.DynlinkingGo() &&
|
||
// ctxt.BuildMode != BuildModeCArchive && ctxt.BuildMode != BuildModePIE && ctxt.BuildMode != BuildModeCShared && ctxt.BuildMode != BuildModePlugin {
|
||
// Errorf(s, "call to external function")
|
||
//}
|
||
return -1
|
||
}
|
||
info := ldr.FuncInfo(s)
|
||
if !info.Valid() { // external function. see above.
|
||
return -1
|
||
}
|
||
|
||
if limit < 0 {
|
||
sc.broke(up, limit)
|
||
return -1
|
||
}
|
||
|
||
// morestack looks like it calls functions,
|
||
// but it switches the stack pointer first.
|
||
if s == sc.morestack {
|
||
return 0
|
||
}
|
||
|
||
var ch chain
|
||
ch.up = up
|
||
|
||
if !ldr.IsNoSplit(s) {
|
||
// Ensure we have enough stack to call morestack.
|
||
ch.limit = limit - callsize(ctxt)
|
||
ch.sym = sc.morestack
|
||
if sc.check(&ch, depth+1) < 0 {
|
||
return -1
|
||
}
|
||
if !top {
|
||
return 0
|
||
}
|
||
// Raise limit to allow frame.
|
||
locals := info.Locals()
|
||
limit = objabi.StackLimit + int(locals) + int(ctxt.FixedFrameSize())
|
||
}
|
||
|
||
// Walk through sp adjustments in function, consuming relocs.
|
||
relocs := ldr.Relocs(s)
|
||
var ch1 chain
|
||
pcsp := obj.NewPCIter(uint32(ctxt.Arch.MinLC))
|
||
ri := 0
|
||
for pcsp.Init(info.Pcsp()); !pcsp.Done; pcsp.Next() {
|
||
// pcsp.value is in effect for [pcsp.pc, pcsp.nextpc).
|
||
|
||
// Check stack size in effect for this span.
|
||
if int32(limit)-pcsp.Value < 0 {
|
||
sc.broke(up, int(int32(limit)-pcsp.Value))
|
||
return -1
|
||
}
|
||
|
||
// Process calls in this span.
|
||
for ; ri < relocs.Count(); ri++ {
|
||
r := relocs.At2(ri)
|
||
if uint32(r.Off()) >= pcsp.NextPC {
|
||
break
|
||
}
|
||
t := r.Type()
|
||
switch {
|
||
case t.IsDirectCall():
|
||
ch.limit = int(int32(limit) - pcsp.Value - int32(callsize(ctxt)))
|
||
ch.sym = r.Sym()
|
||
if sc.check(&ch, depth+1) < 0 {
|
||
return -1
|
||
}
|
||
|
||
// Indirect call. Assume it is a call to a splitting function,
|
||
// so we have to make sure it can call morestack.
|
||
// Arrange the data structures to report both calls, so that
|
||
// if there is an error, stkprint shows all the steps involved.
|
||
case t == objabi.R_CALLIND:
|
||
ch.limit = int(int32(limit) - pcsp.Value - int32(callsize(ctxt)))
|
||
ch.sym = 0
|
||
ch1.limit = ch.limit - callsize(ctxt) // for morestack in called prologue
|
||
ch1.up = &ch
|
||
ch1.sym = sc.morestack
|
||
if sc.check(&ch1, depth+2) < 0 {
|
||
return -1
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return 0
|
||
}
|
||
|
||
func (sc *stkChk) broke(ch *chain, limit int) {
|
||
sc.ctxt.Errorf(ch.sym, "nosplit stack overflow")
|
||
sc.print(ch, limit)
|
||
}
|
||
|
||
func (sc *stkChk) print(ch *chain, limit int) {
|
||
ldr := sc.ldr
|
||
ctxt := sc.ctxt
|
||
var name string
|
||
if ch.sym != 0 {
|
||
name = ldr.SymName(ch.sym)
|
||
if ldr.IsNoSplit(ch.sym) {
|
||
name += " (nosplit)"
|
||
}
|
||
} else {
|
||
name = "function pointer"
|
||
}
|
||
|
||
if ch.up == nil {
|
||
// top of chain. ch.sym != 0.
|
||
if ldr.IsNoSplit(ch.sym) {
|
||
fmt.Printf("\t%d\tassumed on entry to %s\n", ch.limit, name)
|
||
} else {
|
||
fmt.Printf("\t%d\tguaranteed after split check in %s\n", ch.limit, name)
|
||
}
|
||
} else {
|
||
sc.print(ch.up, ch.limit+callsize(ctxt))
|
||
if !haslinkregister(ctxt) {
|
||
fmt.Printf("\t%d\ton entry to %s\n", ch.limit, name)
|
||
}
|
||
}
|
||
|
||
if ch.limit != limit {
|
||
fmt.Printf("\t%d\tafter %s uses %d\n", limit, name, ch.limit-limit)
|
||
}
|
||
}
|
||
|
||
func usage() {
|
||
fmt.Fprintf(os.Stderr, "usage: link [options] main.o\n")
|
||
objabi.Flagprint(os.Stderr)
|
||
Exit(2)
|
||
}
|
||
|
||
type SymbolType int8
|
||
|
||
const (
|
||
// see also https://9p.io/magic/man2html/1/nm
|
||
TextSym SymbolType = 'T'
|
||
DataSym SymbolType = 'D'
|
||
BSSSym SymbolType = 'B'
|
||
UndefinedSym SymbolType = 'U'
|
||
TLSSym SymbolType = 't'
|
||
FrameSym SymbolType = 'm'
|
||
ParamSym SymbolType = 'p'
|
||
AutoSym SymbolType = 'a'
|
||
|
||
// Deleted auto (not a real sym, just placeholder for type)
|
||
DeletedAutoSym = 'x'
|
||
)
|
||
|
||
func genasmsym(ctxt *Link, put func(*Link, *sym.Symbol, string, SymbolType, int64)) {
|
||
// These symbols won't show up in the first loop below because we
|
||
// skip sym.STEXT symbols. Normal sym.STEXT symbols are emitted by walking textp.
|
||
s := ctxt.Syms.Lookup("runtime.text", 0)
|
||
if s.Type == sym.STEXT {
|
||
// We've already included this symbol in ctxt.Textp
|
||
// if ctxt.DynlinkingGo() && ctxt.HeadType == objabi.Hdarwin or
|
||
// on AIX with external linker.
|
||
// See data.go:/textaddress
|
||
if !(ctxt.DynlinkingGo() && ctxt.HeadType == objabi.Hdarwin) && !(ctxt.HeadType == objabi.Haix && ctxt.LinkMode == LinkExternal) {
|
||
put(ctxt, s, s.Name, TextSym, s.Value)
|
||
}
|
||
}
|
||
|
||
n := 0
|
||
|
||
// Generate base addresses for all text sections if there are multiple
|
||
for _, sect := range Segtext.Sections {
|
||
if n == 0 {
|
||
n++
|
||
continue
|
||
}
|
||
if sect.Name != ".text" || (ctxt.HeadType == objabi.Haix && ctxt.LinkMode == LinkExternal) {
|
||
// On AIX, runtime.text.X are symbols already in the symtab.
|
||
break
|
||
}
|
||
s = ctxt.Syms.ROLookup(fmt.Sprintf("runtime.text.%d", n), 0)
|
||
if s == nil {
|
||
break
|
||
}
|
||
if s.Type == sym.STEXT {
|
||
put(ctxt, s, s.Name, TextSym, s.Value)
|
||
}
|
||
n++
|
||
}
|
||
|
||
s = ctxt.Syms.Lookup("runtime.etext", 0)
|
||
if s.Type == sym.STEXT {
|
||
// We've already included this symbol in ctxt.Textp
|
||
// if ctxt.DynlinkingGo() && ctxt.HeadType == objabi.Hdarwin or
|
||
// on AIX with external linker.
|
||
// See data.go:/textaddress
|
||
if !(ctxt.DynlinkingGo() && ctxt.HeadType == objabi.Hdarwin) && !(ctxt.HeadType == objabi.Haix && ctxt.LinkMode == LinkExternal) {
|
||
put(ctxt, s, s.Name, TextSym, s.Value)
|
||
}
|
||
}
|
||
|
||
shouldBeInSymbolTable := func(s *sym.Symbol) bool {
|
||
if s.Attr.NotInSymbolTable() {
|
||
return false
|
||
}
|
||
if ctxt.HeadType == objabi.Haix && s.Name == ".go.buildinfo" {
|
||
// On AIX, .go.buildinfo must be in the symbol table as
|
||
// it has relocations.
|
||
return true
|
||
}
|
||
if (s.Name == "" || s.Name[0] == '.') && !s.IsFileLocal() && s.Name != ".rathole" && s.Name != ".TOC." {
|
||
return false
|
||
}
|
||
return true
|
||
}
|
||
|
||
for _, s := range ctxt.loader.Syms {
|
||
if s == nil {
|
||
continue
|
||
}
|
||
if !shouldBeInSymbolTable(s) {
|
||
continue
|
||
}
|
||
switch s.Type {
|
||
case sym.SCONST,
|
||
sym.SRODATA,
|
||
sym.SSYMTAB,
|
||
sym.SPCLNTAB,
|
||
sym.SINITARR,
|
||
sym.SDATA,
|
||
sym.SNOPTRDATA,
|
||
sym.SELFROSECT,
|
||
sym.SMACHOGOT,
|
||
sym.STYPE,
|
||
sym.SSTRING,
|
||
sym.SGOSTRING,
|
||
sym.SGOFUNC,
|
||
sym.SGCBITS,
|
||
sym.STYPERELRO,
|
||
sym.SSTRINGRELRO,
|
||
sym.SGOSTRINGRELRO,
|
||
sym.SGOFUNCRELRO,
|
||
sym.SGCBITSRELRO,
|
||
sym.SRODATARELRO,
|
||
sym.STYPELINK,
|
||
sym.SITABLINK,
|
||
sym.SWINDOWS:
|
||
if !s.Attr.Reachable() {
|
||
continue
|
||
}
|
||
put(ctxt, s, s.Name, DataSym, Symaddr(s))
|
||
|
||
case sym.SBSS, sym.SNOPTRBSS, sym.SLIBFUZZER_EXTRA_COUNTER:
|
||
if !s.Attr.Reachable() {
|
||
continue
|
||
}
|
||
if len(s.P) > 0 {
|
||
Errorf(s, "should not be bss (size=%d type=%v special=%v)", len(s.P), s.Type, s.Attr.Special())
|
||
}
|
||
put(ctxt, s, s.Name, BSSSym, Symaddr(s))
|
||
|
||
case sym.SUNDEFEXT:
|
||
if ctxt.HeadType == objabi.Hwindows || ctxt.HeadType == objabi.Haix || ctxt.IsELF {
|
||
put(ctxt, s, s.Name, UndefinedSym, s.Value)
|
||
}
|
||
|
||
case sym.SHOSTOBJ:
|
||
if !s.Attr.Reachable() {
|
||
continue
|
||
}
|
||
if ctxt.HeadType == objabi.Hwindows || ctxt.IsELF {
|
||
put(ctxt, s, s.Name, UndefinedSym, s.Value)
|
||
}
|
||
|
||
case sym.SDYNIMPORT:
|
||
if !s.Attr.Reachable() {
|
||
continue
|
||
}
|
||
put(ctxt, s, s.Extname(), UndefinedSym, 0)
|
||
|
||
case sym.STLSBSS:
|
||
if ctxt.LinkMode == LinkExternal {
|
||
put(ctxt, s, s.Name, TLSSym, Symaddr(s))
|
||
}
|
||
}
|
||
}
|
||
|
||
for _, s := range ctxt.Textp {
|
||
put(ctxt, s, s.Name, TextSym, s.Value)
|
||
}
|
||
|
||
if ctxt.Debugvlog != 0 || *flagN {
|
||
ctxt.Logf("symsize = %d\n", uint32(Symsize))
|
||
}
|
||
}
|
||
|
||
func Symaddr(s *sym.Symbol) int64 {
|
||
if !s.Attr.Reachable() {
|
||
Errorf(s, "unreachable symbol in symaddr")
|
||
}
|
||
return s.Value
|
||
}
|
||
|
||
func (ctxt *Link) xdefine(p string, t sym.SymKind, v int64) {
|
||
s := ctxt.Syms.Lookup(p, 0)
|
||
s.Type = t
|
||
s.Value = v
|
||
s.Attr |= sym.AttrReachable
|
||
s.Attr |= sym.AttrSpecial
|
||
s.Attr |= sym.AttrLocal
|
||
}
|
||
|
||
func (ctxt *Link) xdefine2(p string, t sym.SymKind, v int64) {
|
||
ldr := ctxt.loader
|
||
s := ldr.CreateSymForUpdate(p, 0)
|
||
s.SetType(t)
|
||
s.SetValue(v)
|
||
s.SetReachable(true)
|
||
s.SetSpecial(true)
|
||
s.SetLocal(true)
|
||
}
|
||
|
||
func datoff(s *sym.Symbol, addr int64) int64 {
|
||
if uint64(addr) >= Segdata.Vaddr {
|
||
return int64(uint64(addr) - Segdata.Vaddr + Segdata.Fileoff)
|
||
}
|
||
if uint64(addr) >= Segtext.Vaddr {
|
||
return int64(uint64(addr) - Segtext.Vaddr + Segtext.Fileoff)
|
||
}
|
||
Errorf(s, "invalid datoff %#x", addr)
|
||
return 0
|
||
}
|
||
|
||
func Entryvalue(ctxt *Link) int64 {
|
||
a := *flagEntrySymbol
|
||
if a[0] >= '0' && a[0] <= '9' {
|
||
return atolwhex(a)
|
||
}
|
||
s := ctxt.Syms.Lookup(a, 0)
|
||
if s.Type == 0 {
|
||
return *FlagTextAddr
|
||
}
|
||
if ctxt.HeadType != objabi.Haix && s.Type != sym.STEXT {
|
||
Errorf(s, "entry not text")
|
||
}
|
||
return s.Value
|
||
}
|
||
|
||
func (ctxt *Link) callgraph() {
|
||
if !*FlagC {
|
||
return
|
||
}
|
||
|
||
ldr := ctxt.loader
|
||
for _, s := range ctxt.Textp2 {
|
||
relocs := ldr.Relocs(s)
|
||
for i := 0; i < relocs.Count(); i++ {
|
||
r := relocs.At2(i)
|
||
rs := r.Sym()
|
||
if rs == 0 {
|
||
continue
|
||
}
|
||
if r.Type().IsDirectCall() && (ldr.SymType(rs) == sym.STEXT || ldr.SymType(rs) == sym.SABIALIAS) {
|
||
ctxt.Logf("%s calls %s\n", ldr.SymName(s), ldr.SymName(rs))
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
func Rnd(v int64, r int64) int64 {
|
||
if r <= 0 {
|
||
return v
|
||
}
|
||
v += r - 1
|
||
c := v % r
|
||
if c < 0 {
|
||
c += r
|
||
}
|
||
v -= c
|
||
return v
|
||
}
|
||
|
||
func bgetc(r *bio.Reader) int {
|
||
c, err := r.ReadByte()
|
||
if err != nil {
|
||
if err != io.EOF {
|
||
log.Fatalf("reading input: %v", err)
|
||
}
|
||
return -1
|
||
}
|
||
return int(c)
|
||
}
|
||
|
||
type markKind uint8 // for postorder traversal
|
||
const (
|
||
_ markKind = iota
|
||
visiting
|
||
visited
|
||
)
|
||
|
||
func postorder(libs []*sym.Library) []*sym.Library {
|
||
order := make([]*sym.Library, 0, len(libs)) // hold the result
|
||
mark := make(map[*sym.Library]markKind, len(libs))
|
||
for _, lib := range libs {
|
||
dfs(lib, mark, &order)
|
||
}
|
||
return order
|
||
}
|
||
|
||
func dfs(lib *sym.Library, mark map[*sym.Library]markKind, order *[]*sym.Library) {
|
||
if mark[lib] == visited {
|
||
return
|
||
}
|
||
if mark[lib] == visiting {
|
||
panic("found import cycle while visiting " + lib.Pkg)
|
||
}
|
||
mark[lib] = visiting
|
||
for _, i := range lib.Imports {
|
||
dfs(i, mark, order)
|
||
}
|
||
mark[lib] = visited
|
||
*order = append(*order, lib)
|
||
}
|
||
|
||
// addToTextp populates the context Textp slice.
|
||
func addToTextp(ctxt *Link) {
|
||
// Set up ctxt.Textp, based on ctxt.Textp2.
|
||
textp := make([]*sym.Symbol, 0, len(ctxt.Textp2))
|
||
haveshlibs := len(ctxt.Shlibs) > 0
|
||
for _, tsym := range ctxt.Textp2 {
|
||
sp := ctxt.loader.Syms[tsym]
|
||
if sp == nil || !ctxt.loader.AttrReachable(tsym) {
|
||
panic("should never happen")
|
||
}
|
||
if haveshlibs && sp.Type == sym.SDYNIMPORT {
|
||
continue
|
||
}
|
||
textp = append(textp, sp)
|
||
}
|
||
ctxt.Textp = textp
|
||
}
|
||
|
||
func (ctxt *Link) loadlibfull(symGroupType []sym.SymKind, needReloc, needExtReloc bool) {
|
||
// Load full symbol contents, resolve indexed references.
|
||
ctxt.loader.LoadFull(ctxt.Arch, ctxt.Syms, needReloc, needExtReloc)
|
||
|
||
// Convert ctxt.Moduledata2 to ctxt.Moduledata, etc
|
||
if ctxt.Moduledata2 != 0 {
|
||
ctxt.Moduledata = ctxt.loader.Syms[ctxt.Moduledata2]
|
||
ctxt.Tlsg = ctxt.loader.Syms[ctxt.Tlsg2]
|
||
}
|
||
|
||
// Pull the symbols out.
|
||
ctxt.loader.ExtractSymbols(ctxt.Syms)
|
||
ctxt.lookup = ctxt.Syms.ROLookup
|
||
|
||
// Recreate dynexp using *sym.Symbol instead of loader.Sym
|
||
genSymsForDynexp(ctxt)
|
||
|
||
// Drop the cgodata reference.
|
||
ctxt.cgodata = nil
|
||
|
||
addToTextp(ctxt)
|
||
|
||
// Set special global symbols.
|
||
ctxt.setArchSyms(AfterLoadlibFull)
|
||
|
||
// Populate dwarfp from dwarfp2. If we see a symbol index
|
||
// whose loader.Syms entry is nil, something went wrong.
|
||
for _, si := range dwarfp2 {
|
||
syms := make([]*sym.Symbol, 0, len(si.syms))
|
||
for _, symIdx := range si.syms {
|
||
s := ctxt.loader.Syms[symIdx]
|
||
if s == nil {
|
||
panic(fmt.Sprintf("nil sym for dwarfp2 element %d", symIdx))
|
||
}
|
||
s.Attr |= sym.AttrLocal
|
||
syms = append(syms, s)
|
||
}
|
||
dwarfp = append(dwarfp, dwarfSecInfo2{syms: syms})
|
||
}
|
||
|
||
// Populate datap from datap2
|
||
ctxt.datap = make([]*sym.Symbol, len(ctxt.datap2))
|
||
for i, symIdx := range ctxt.datap2 {
|
||
s := ctxt.loader.Syms[symIdx]
|
||
if s == nil {
|
||
panic(fmt.Sprintf("nil sym for datap2 element %d", symIdx))
|
||
}
|
||
ctxt.datap[i] = s
|
||
}
|
||
|
||
// Populate the sym.Section 'Sym' fields based on their 'Sym2'
|
||
// fields.
|
||
allSegments := []*sym.Segment{&Segtext, &Segrodata, &Segrelrodata, &Segdata, &Segdwarf}
|
||
for _, seg := range allSegments {
|
||
for _, sect := range seg.Sections {
|
||
if sect.Sym2 != 0 {
|
||
s := ctxt.loader.Syms[sect.Sym2]
|
||
if s == nil {
|
||
panic(fmt.Sprintf("nil sym for sect %s sym %d", sect.Name, sect.Sym2))
|
||
}
|
||
sect.Sym = s
|
||
}
|
||
}
|
||
}
|
||
|
||
// For now, overwrite symbol type with its "group" type, as dodata
|
||
// expected. Once we converted dodata, this will probably not be
|
||
// needed.
|
||
for i, t := range symGroupType {
|
||
if t != sym.Sxxx {
|
||
s := ctxt.loader.Syms[i]
|
||
if s == nil {
|
||
continue // in dwarfcompress we drop compressed DWARF symbols
|
||
}
|
||
s.Type = t
|
||
}
|
||
}
|
||
symGroupType = nil
|
||
|
||
if ctxt.Debugvlog > 1 {
|
||
// loadlibfull is likely a good place to dump.
|
||
// Only dump under -v=2 and above.
|
||
ctxt.dumpsyms()
|
||
}
|
||
}
|
||
|
||
func symPkg(ctxt *Link, s *sym.Symbol) string {
|
||
if s == nil {
|
||
return ""
|
||
}
|
||
return ctxt.loader.SymPkg(loader.Sym(s.SymIdx))
|
||
}
|
||
|
||
func ElfSymForReloc(ctxt *Link, s *sym.Symbol) int32 {
|
||
// If putelfsym created a local version of this symbol, use that in all
|
||
// relocations.
|
||
les := ctxt.loader.SymLocalElfSym(loader.Sym(s.SymIdx))
|
||
if les != 0 {
|
||
return les
|
||
} else {
|
||
return ctxt.loader.SymElfSym(loader.Sym(s.SymIdx))
|
||
}
|
||
}
|
||
|
||
func symSub(ctxt *Link, s *sym.Symbol) *sym.Symbol {
|
||
if lsub := ctxt.loader.SubSym(loader.Sym(s.SymIdx)); lsub != 0 {
|
||
return ctxt.loader.Syms[lsub]
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (ctxt *Link) dumpsyms() {
|
||
for _, s := range ctxt.loader.Syms {
|
||
if s == nil {
|
||
continue
|
||
}
|
||
fmt.Printf("%s %s reachable=%v onlist=%v outer=%v sub=%v\n", s, s.Type, s.Attr.Reachable(), s.Attr.OnList(), s.Outer, symSub(ctxt, s))
|
||
for i := range s.R {
|
||
fmt.Println("\t", s.R[i].Type, s.R[i].Sym)
|
||
}
|
||
}
|
||
}
|