src/cmd/link/internal/ld/lib.go

   1 // Inferno utils/8l/asm.c
   2 // https://bitbucket.org/inferno-os/inferno-os/src/default/utils/8l/asm.c
   3 //
   4 //      Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
   5 //      Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
   6 //      Portions Copyright © 1997-1999 Vita Nuova Limited
   7 //      Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
   8 //      Portions Copyright © 2004,2006 Bruce Ellis
   9 //      Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
  10 //      Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
  11 //      Portions Copyright © 2009 The Go Authors. All rights reserved.
  12 //
  13 // Permission is hereby granted, free of charge, to any person obtaining a copy
  14 // of this software and associated documentation files (the "Software"), to deal
  15 // in the Software without restriction, including without limitation the rights
  16 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  17 // copies of the Software, and to permit persons to whom the Software is
  18 // furnished to do so, subject to the following conditions:
  19 //
  20 // The above copyright notice and this permission notice shall be included in
  21 // all copies or substantial portions of the Software.
  22 //
  23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  24 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  25 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  26 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  27 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  28 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  29 // THE SOFTWARE.
  30
  31 package ld
  32
  33 import (
  34         "bufio"
  35         "bytes"
  36         "cmd/internal/bio"
  37         "cmd/internal/objabi"
  38         "cmd/internal/sys"
  39         "cmd/link/internal/loadelf"
  40         "cmd/link/internal/loadmacho"
  41         "cmd/link/internal/loadpe"
  42         "cmd/link/internal/objfile"
  43         "cmd/link/internal/sym"
  44         "crypto/sha1"
  45         "debug/elf"
  46         "encoding/base64"
  47         "encoding/binary"
  48         "encoding/hex"
  49         "fmt"
  50         "io"
  51         "io/ioutil"
  52         "log"
  53         "os"
  54         "os/exec"
  55         "path/filepath"
  56         "runtime"
  57         "strings"
  58         "sync"
  59 )
  60
  61 // Data layout and relocation.
  62
  63 // Derived from Inferno utils/6l/l.h
  64 // https://bitbucket.org/inferno-os/inferno-os/src/default/utils/6l/l.h
  65 //
  66 //      Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
  67 //      Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
  68 //      Portions Copyright © 1997-1999 Vita Nuova Limited
  69 //      Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
  70 //      Portions Copyright © 2004,2006 Bruce Ellis
  71 //      Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
  72 //      Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
  73 //      Portions Copyright © 2009 The Go Authors. All rights reserved.
  74 //
  75 // Permission is hereby granted, free of charge, to any person obtaining a copy
  76 // of this software and associated documentation files (the "Software"), to deal
  77 // in the Software without restriction, including without limitation the rights
  78 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  79 // copies of the Software, and to permit persons to whom the Software is
  80 // furnished to do so, subject to the following conditions:
  81 //
  82 // The above copyright notice and this permission notice shall be included in
  83 // all copies or substantial portions of the Software.
  84 //
  85 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  86 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  87 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  88 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  89 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  90 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  91 // THE SOFTWARE.
  92
  93 type Arch struct {
  94         Funcalign        int
  95         Maxalign         int
  96         Minalign         int
  97         Dwarfregsp       int
  98         Dwarfreglr       int
  99         Linuxdynld       string
 100         Freebsddynld     string
 101         Netbsddynld      string
 102         Openbsddynld     string
 103         Dragonflydynld   string
 104         Solarisdynld     string
 105         Adddynrel        func(*Link, *sym.Symbol, *sym.Reloc) bool
 106         Archinit         func(*Link)
 107         Archreloc        func(*Link, *sym.Reloc, *sym.Symbol, *int64) bool
 108         Archrelocvariant func(*Link, *sym.Reloc, *sym.Symbol, int64) int64
 109         Trampoline       func(*Link, *sym.Reloc, *sym.Symbol)
 110         Asmb             func(*Link)
 111         Elfreloc1        func(*Link, *sym.Reloc, int64) bool
 112         Elfsetupplt      func(*Link)
 113         Gentext          func(*Link)
 114         Machoreloc1      func(*sys.Arch, *OutBuf, *sym.Symbol, *sym.Reloc, int64) bool
 115         PEreloc1         func(*sys.Arch, *OutBuf, *sym.Symbol, *sym.Reloc, int64) bool
 116
 117         // TLSIEtoLE converts a TLS Initial Executable relocation to
 118         // a TLS Local Executable relocation.
 119         //
 120         // This is possible when a TLS IE relocation refers to a local
 121         // symbol in an executable, which is typical when internally
 122         // linking PIE binaries.
 123         TLSIEtoLE func(s *sym.Symbol, off, size int)
 124
 125         // optional override for assignAddress
 126         AssignAddress func(ctxt *Link, sect *sym.Section, n int, s *sym.Symbol, va uint64, isTramp bool) (*sym.Section, int, uint64)
 127 }
 128
 129 var (
 130         thearch Arch
 131         Lcsize  int32
 132         rpath   Rpath
 133         Spsize  int32
 134         Symsize int32
 135 )
 136
 137 const (
 138         MINFUNC = 16 // minimum size for a function
 139 )
 140
 141 // DynlinkingGo returns whether we are producing Go code that can live
 142 // in separate shared libraries linked together at runtime.
 143 func (ctxt *Link) DynlinkingGo() bool {
 144         if !ctxt.Loaded {
 145                 panic("DynlinkingGo called before all symbols loaded")
 146         }
 147         return ctxt.BuildMode == BuildModeShared || ctxt.linkShared || ctxt.BuildMode == BuildModePlugin || ctxt.CanUsePlugins()
 148 }
 149
 150 // CanUsePlugins returns whether a plugins can be used
 151 func (ctxt *Link) CanUsePlugins() bool {
 152         return ctxt.Syms.ROLookup("plugin.Open", 0) != nil
 153 }
 154
 155 // UseRelro returns whether to make use of "read only relocations" aka
 156 // relro.
 157 func (ctxt *Link) UseRelro() bool {
 158         switch ctxt.BuildMode {
 159         case BuildModeCArchive, BuildModeCShared, BuildModeShared, BuildModePIE, BuildModePlugin:
 160                 return ctxt.IsELF
 161         default:
 162                 return ctxt.linkShared
 163         }
 164 }
 165
 166 var (
 167         dynexp          []*sym.Symbol
 168         dynlib          []string
 169         ldflag          []string
 170         havedynamic     int
 171         Funcalign       int
 172         iscgo           bool
 173         elfglobalsymndx int
 174         interpreter     string
 175
 176         debug_s bool // backup old value of debug['s']
 177         HEADR   int32
 178
 179         nerrors  int
 180         liveness int64
 181 )
 182
 183 var (
 184         Segtext      sym.Segment
 185         Segrodata    sym.Segment
 186         Segrelrodata sym.Segment
 187         Segdata      sym.Segment
 188         Segdwarf     sym.Segment
 189 )
 190
 191 const pkgdef = "__.PKGDEF"
 192
 193 var (
 194         // Set if we see an object compiled by the host compiler that is not
 195         // from a package that is known to support internal linking mode.
 196         externalobj = false
 197         theline     string
 198 )
 199
 200 func Lflag(ctxt *Link, arg string) {
 201         ctxt.Libdir = append(ctxt.Libdir, arg)
 202 }
 203
 204 /*
 205  * Unix doesn't like it when we write to a running (or, sometimes,
 206  * recently run) binary, so remove the output file before writing it.
 207  * On Windows 7, remove() can force a subsequent create() to fail.
 208  * S_ISREG() does not exist on Plan 9.
 209  */
 210 func mayberemoveoutfile() {
 211         if fi, err := os.Lstat(*flagOutfile); err == nil && !fi.Mode().IsRegular() {
 212                 return
 213         }
 214         os.Remove(*flagOutfile)
 215 }
 216
 217 func libinit(ctxt *Link) {
 218         Funcalign = thearch.Funcalign
 219
 220         // add goroot to the end of the libdir list.
 221         suffix := ""
 222
 223         suffixsep := ""
 224         if *flagInstallSuffix != "" {
 225                 suffixsep = "_"
 226                 suffix = *flagInstallSuffix
 227         } else if *flagRace {
 228                 suffixsep = "_"
 229                 suffix = "race"
 230         } else if *flagMsan {
 231                 suffixsep = "_"
 232                 suffix = "msan"
 233         }
 234
 235         Lflag(ctxt, filepath.Join(objabi.GOROOT, "pkg", fmt.Sprintf("%s_%s%s%s", objabi.GOOS, objabi.GOARCH, suffixsep, suffix)))
 236
 237         mayberemoveoutfile()
 238         f, err := os.OpenFile(*flagOutfile, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0775)
 239         if err != nil {
 240                 Exitf("cannot create %s: %v", *flagOutfile, err)
 241         }
 242
 243         ctxt.Out.w = bufio.NewWriter(f)
 244         ctxt.Out.f = f
 245
 246         if *flagEntrySymbol == "" {
 247                 switch ctxt.BuildMode {
 248                 case BuildModeCShared, BuildModeCArchive:
 249                         *flagEntrySymbol = fmt.Sprintf("_rt0_%s_%s_lib", objabi.GOARCH, objabi.GOOS)
 250                 case BuildModeExe, BuildModePIE:
 251                         *flagEntrySymbol = fmt.Sprintf("_rt0_%s_%s", objabi.GOARCH, objabi.GOOS)
 252                 case BuildModeShared, BuildModePlugin:
 253                         // No *flagEntrySymbol for -buildmode=shared and plugin
 254                 default:
 255                         Errorf(nil, "unknown *flagEntrySymbol for buildmode %v", ctxt.BuildMode)
 256                 }
 257         }
 258 }
 259
 260 func errorexit() {
 261         if nerrors != 0 {
 262                 Exit(2)
 263         }
 264         Exit(0)
 265 }
 266
 267 func loadinternal(ctxt *Link, name string) *sym.Library {
 268         if ctxt.linkShared && ctxt.PackageShlib != nil {
 269                 if shlib := ctxt.PackageShlib[name]; shlib != "" {
 270                         return addlibpath(ctxt, "internal", "internal", "", name, shlib)
 271                 }
 272         }
 273         if ctxt.PackageFile != nil {
 274                 if pname := ctxt.PackageFile[name]; pname != "" {
 275                         return addlibpath(ctxt, "internal", "internal", pname, name, "")
 276                 }
 277                 ctxt.Logf("loadinternal: cannot find %s\n", name)
 278                 return nil
 279         }
 280
 281         for _, libdir := range ctxt.Libdir {
 282                 if ctxt.linkShared {
 283                         shlibname := filepath.Join(libdir, name+".shlibname")
 284                         if ctxt.Debugvlog != 0 {
 285                                 ctxt.Logf("searching for %s.a in %s\n", name, shlibname)
 286                         }
 287                         if _, err := os.Stat(shlibname); err == nil {
 288                                 return addlibpath(ctxt, "internal", "internal", "", name, shlibname)
 289                         }
 290                 }
 291                 pname := filepath.Join(libdir, name+".a")
 292                 if ctxt.Debugvlog != 0 {
 293                         ctxt.Logf("searching for %s.a in %s\n", name, pname)
 294                 }
 295                 if _, err := os.Stat(pname); err == nil {
 296                         return addlibpath(ctxt, "internal", "internal", pname, name, "")
 297                 }
 298         }
 299
 300         ctxt.Logf("warning: unable to find %s.a\n", name)
 301         return nil
 302 }
 303
 304 // findLibPathCmd uses cmd command to find gcc library libname.
 305 // It returns library full path if found, or "none" if not found.
 306 func (ctxt *Link) findLibPathCmd(cmd, libname string) string {
 307         if *flagExtld == "" {
 308                 *flagExtld = "gcc"
 309         }
 310         args := hostlinkArchArgs(ctxt.Arch)
 311         args = append(args, cmd)
 312         if ctxt.Debugvlog != 0 {
 313                 ctxt.Logf("%s %v\n", *flagExtld, args)
 314         }
 315         out, err := exec.Command(*flagExtld, args...).Output()
 316         if err != nil {
 317                 if ctxt.Debugvlog != 0 {
 318                         ctxt.Logf("not using a %s file because compiler failed\n%v\n%s\n", libname, err, out)
 319                 }
 320                 return "none"
 321         }
 322         return strings.TrimSpace(string(out))
 323 }
 324
 325 // findLibPath searches for library libname.
 326 // It returns library full path if found, or "none" if not found.
 327 func (ctxt *Link) findLibPath(libname string) string {
 328         return ctxt.findLibPathCmd("--print-file-name="+libname, libname)
 329 }
 330
 331 func (ctxt *Link) loadlib() {
 332         switch ctxt.BuildMode {
 333         case BuildModeCShared, BuildModePlugin:
 334                 s := ctxt.Syms.Lookup("runtime.islibrary", 0)
 335                 s.Attr |= sym.AttrDuplicateOK
 336                 s.AddUint8(1)
 337         case BuildModeCArchive:
 338                 s := ctxt.Syms.Lookup("runtime.isarchive", 0)
 339                 s.Attr |= sym.AttrDuplicateOK
 340                 s.AddUint8(1)
 341         }
 342
 343         loadinternal(ctxt, "runtime")
 344         if ctxt.Arch.Family == sys.ARM {
 345                 loadinternal(ctxt, "math")
 346         }
 347         if *flagRace {
 348                 loadinternal(ctxt, "runtime/race")
 349         }
 350         if *flagMsan {
 351                 loadinternal(ctxt, "runtime/msan")
 352         }
 353
 354         // ctxt.Library grows during the loop, so not a range loop.
 355         for i := 0; i < len(ctxt.Library); i++ {
 356                 lib := ctxt.Library[i]
 357                 if lib.Shlib == "" {
 358                         if ctxt.Debugvlog > 1 {
 359                                 ctxt.Logf("%5.2f autolib: %s (from %s)\n", Cputime(), lib.File, lib.Objref)
 360                         }
 361                         loadobjfile(ctxt, lib)
 362                 }
 363         }
 364
 365         for _, lib := range ctxt.Library {
 366                 if lib.Shlib != "" {
 367                         if ctxt.Debugvlog > 1 {
 368                                 ctxt.Logf("%5.2f autolib: %s (from %s)\n", Cputime(), lib.Shlib, lib.Objref)
 369                         }
 370                         ldshlibsyms(ctxt, lib.Shlib)
 371                 }
 372         }
 373
 374         iscgo = ctxt.Syms.ROLookup("x_cgo_init", 0) != nil
 375
 376         // We now have enough information to determine the link mode.
 377         determineLinkMode(ctxt)
 378
 379         // Recalculate pe parameters now that we have ctxt.LinkMode set.
 380         if ctxt.HeadType == objabi.Hwindows {
 381                 Peinit(ctxt)
 382         }
 383
 384         if ctxt.HeadType == objabi.Hdarwin && ctxt.LinkMode == LinkExternal {
 385                 *FlagTextAddr = 0
 386         }
 387
 388         if ctxt.LinkMode == LinkExternal && ctxt.Arch.Family == sys.PPC64 {
 389                 toc := ctxt.Syms.Lookup(".TOC.", 0)
 390                 toc.Type = sym.SDYNIMPORT
 391         }
 392
 393         if ctxt.LinkMode == LinkExternal && !iscgo && ctxt.LibraryByPkg["runtime/cgo"] == nil && !(objabi.GOOS == "darwin" && (ctxt.Arch.Family == sys.AMD64 || ctxt.Arch.Family == sys.I386)) {
 394                 // This indicates a user requested -linkmode=external.
 395                 // The startup code uses an import of runtime/cgo to decide
 396                 // whether to initialize the TLS.  So give it one. This could
 397                 // be handled differently but it's an unusual case.
 398                 if lib := loadinternal(ctxt, "runtime/cgo"); lib != nil {
 399                         if lib.Shlib != "" {
 400                                 ldshlibsyms(ctxt, lib.Shlib)
 401                         } else {
 402                                 if ctxt.BuildMode == BuildModeShared || ctxt.linkShared {
 403                                         Exitf("cannot implicitly include runtime/cgo in a shared library")
 404                                 }
 405                                 loadobjfile(ctxt, lib)
 406                         }
 407                 }
 408         }
 409
 410         if ctxt.LinkMode == LinkInternal {
 411                 // Drop all the cgo_import_static declarations.
 412                 // Turns out we won't be needing them.
 413                 for _, s := range ctxt.Syms.Allsym {
 414                         if s.Type == sym.SHOSTOBJ {
 415                                 // If a symbol was marked both
 416                                 // cgo_import_static and cgo_import_dynamic,
 417                                 // then we want to make it cgo_import_dynamic
 418                                 // now.
 419                                 if s.Extname != "" && s.Dynimplib != "" && !s.Attr.CgoExport() {
 420                                         s.Type = sym.SDYNIMPORT
 421                                 } else {
 422                                         s.Type = 0
 423                                 }
 424                         }
 425                 }
 426         }
 427
 428         tlsg := ctxt.Syms.Lookup("runtime.tlsg", 0)
 429
 430         // runtime.tlsg is used for external linking on platforms that do not define
 431         // a variable to hold g in assembly (currently only intel).
 432         if tlsg.Type == 0 {
 433                 tlsg.Type = sym.STLSBSS
 434                 tlsg.Size = int64(ctxt.Arch.PtrSize)
 435         } else if tlsg.Type != sym.SDYNIMPORT {
 436                 Errorf(nil, "runtime declared tlsg variable %v", tlsg.Type)
 437         }
 438         tlsg.Attr |= sym.AttrReachable
 439         ctxt.Tlsg = tlsg
 440
 441         var moduledata *sym.Symbol
 442         if ctxt.BuildMode == BuildModePlugin {
 443                 moduledata = ctxt.Syms.Lookup("local.pluginmoduledata", 0)
 444                 moduledata.Attr |= sym.AttrLocal
 445         } else {
 446                 moduledata = ctxt.Syms.Lookup("runtime.firstmoduledata", 0)
 447         }
 448         if moduledata.Type != 0 && moduledata.Type != sym.SDYNIMPORT {
 449                 // If the module (toolchain-speak for "executable or shared
 450                 // library") we are linking contains the runtime package, it
 451                 // will define the runtime.firstmoduledata symbol and we
 452                 // truncate it back to 0 bytes so we can define its entire
 453                 // contents in symtab.go:symtab().
 454                 moduledata.Size = 0
 455
 456                 // In addition, on ARM, the runtime depends on the linker
 457                 // recording the value of GOARM.
 458                 if ctxt.Arch.Family == sys.ARM {
 459                         s := ctxt.Syms.Lookup("runtime.goarm", 0)
 460                         s.Type = sym.SDATA
 461                         s.Size = 0
 462                         s.AddUint8(uint8(objabi.GOARM))
 463                 }
 464
 465                 if objabi.Framepointer_enabled(objabi.GOOS, objabi.GOARCH) {
 466                         s := ctxt.Syms.Lookup("runtime.framepointer_enabled", 0)
 467                         s.Type = sym.SDATA
 468                         s.Size = 0
 469                         s.AddUint8(1)
 470                 }
 471         } else {
 472                 // If OTOH the module does not contain the runtime package,
 473                 // create a local symbol for the moduledata.
 474                 moduledata = ctxt.Syms.Lookup("local.moduledata", 0)
 475                 moduledata.Attr |= sym.AttrLocal
 476         }
 477         // In all cases way we mark the moduledata as noptrdata to hide it from
 478         // the GC.
 479         moduledata.Type = sym.SNOPTRDATA
 480         moduledata.Attr |= sym.AttrReachable
 481         ctxt.Moduledata = moduledata
 482
 483         // Now that we know the link mode, trim the dynexp list.
 484         x := sym.AttrCgoExportDynamic
 485
 486         if ctxt.LinkMode == LinkExternal {
 487                 x = sym.AttrCgoExportStatic
 488         }
 489         w := 0
 490         for i := range dynexp {
 491                 if dynexp[i].Attr&x != 0 {
 492                         dynexp[w] = dynexp[i]
 493                         w++
 494                 }
 495         }
 496         dynexp = dynexp[:w]
 497
 498         // In internal link mode, read the host object files.
 499         if ctxt.LinkMode == LinkInternal {
 500                 hostobjs(ctxt)
 501
 502                 // If we have any undefined symbols in external
 503                 // objects, try to read them from the libgcc file.
 504                 any := false
 505                 for _, s := range ctxt.Syms.Allsym {
 506                         for _, r := range s.R {
 507                                 if r.Sym != nil && r.Sym.Type == sym.SXREF && r.Sym.Name != ".got" {
 508                                         any = true
 509                                         break
 510                                 }
 511                         }
 512                 }
 513                 if any {
 514                         if *flagLibGCC == "" {
 515                                 *flagLibGCC = ctxt.findLibPathCmd("--print-libgcc-file-name", "libgcc")
 516                         }
 517                         if *flagLibGCC != "none" {
 518                                 hostArchive(ctxt, *flagLibGCC)
 519                         }
 520                         if ctxt.HeadType == objabi.Hwindows {
 521                                 if p := ctxt.findLibPath("libmingwex.a"); p != "none" {
 522                                         hostArchive(ctxt, p)
 523                                 }
 524                                 if p := ctxt.findLibPath("libmingw32.a"); p != "none" {
 525                                         hostArchive(ctxt, p)
 526                                 }
 527                                 // TODO: maybe do something similar to peimporteddlls to collect all lib names
 528                                 // and try link them all to final exe just like libmingwex.a and libmingw32.a:
 529                                 /*
 530                                         for:
 531                                         #cgo windows LDFLAGS: -lmsvcrt -lm
 532                                         import:
 533                                         libmsvcrt.a libm.a
 534                                 */
 535                         }
 536                 }
 537         } else {
 538                 hostlinksetup(ctxt)
 539         }
 540
 541         // We've loaded all the code now.
 542         ctxt.Loaded = true
 543
 544         // If there are no dynamic libraries needed, gcc disables dynamic linking.
 545         // Because of this, glibc's dynamic ELF loader occasionally (like in version 2.13)
 546         // assumes that a dynamic binary always refers to at least one dynamic library.
 547         // Rather than be a source of test cases for glibc, disable dynamic linking
 548         // the same way that gcc would.
 549         //
 550         // Exception: on OS X, programs such as Shark only work with dynamic
 551         // binaries, so leave it enabled on OS X (Mach-O) binaries.
 552         // Also leave it enabled on Solaris which doesn't support
 553         // statically linked binaries.
 554         if ctxt.BuildMode == BuildModeExe {
 555                 if havedynamic == 0 && ctxt.HeadType != objabi.Hdarwin && ctxt.HeadType != objabi.Hsolaris {
 556                         *FlagD = true
 557                 }
 558         }
 559
 560         // If type. symbols are visible in the symbol table, rename them
 561         // using a SHA-1 prefix. This reduces binary size (the full
 562         // string of a type symbol can be multiple kilobytes) and removes
 563         // characters that upset external linkers.
 564         //
 565         // Keep the type.. prefix, which parts of the linker (like the
 566         // DWARF generator) know means the symbol is not decodable.
 567         //
 568         // Leave type.runtime. symbols alone, because other parts of
 569         // the linker manipulates them, and also symbols whose names
 570         // would not be shortened by this process.
 571         if typeSymbolMangling(ctxt) {
 572                 *FlagW = true // disable DWARF generation
 573                 for _, s := range ctxt.Syms.Allsym {
 574                         newName := typeSymbolMangle(s.Name)
 575                         if newName != s.Name {
 576                                 ctxt.Syms.Rename(s.Name, newName, int(s.Version))
 577                         }
 578                 }
 579         }
 580
 581         // If package versioning is required, generate a hash of the
 582         // packages used in the link.
 583         if ctxt.BuildMode == BuildModeShared || ctxt.BuildMode == BuildModePlugin || ctxt.CanUsePlugins() {
 584                 for _, lib := range ctxt.Library {
 585                         if lib.Shlib == "" {
 586                                 genhash(ctxt, lib)
 587                         }
 588                 }
 589         }
 590
 591         if ctxt.Arch == sys.Arch386 {
 592                 if (ctxt.BuildMode == BuildModeCArchive && ctxt.IsELF) || (ctxt.BuildMode == BuildModeCShared && ctxt.HeadType != objabi.Hwindows) || ctxt.BuildMode == BuildModePIE || ctxt.DynlinkingGo() {
 593                         got := ctxt.Syms.Lookup("_GLOBAL_OFFSET_TABLE_", 0)
 594                         got.Type = sym.SDYNIMPORT
 595                         got.Attr |= sym.AttrReachable
 596                 }
 597         }
 598
 599         importcycles()
 600
 601         // put symbols into Textp
 602         // do it in postorder so that packages are laid down in dependency order
 603         // internal first, then everything else
 604         ctxt.Library = postorder(ctxt.Library)
 605         for _, doInternal := range [2]bool{true, false} {
 606                 for _, lib := range ctxt.Library {
 607                         if isRuntimeDepPkg(lib.Pkg) != doInternal {
 608                                 continue
 609                         }
 610                         ctxt.Textp = append(ctxt.Textp, lib.Textp...)
 611                         for _, s := range lib.DupTextSyms {
 612                                 if !s.Attr.OnList() {
 613                                         ctxt.Textp = append(ctxt.Textp, s)
 614                                         s.Attr |= sym.AttrOnList
 615                                         // dupok symbols may be defined in multiple packages. its
 616                                         // associated package is chosen sort of arbitrarily (the
 617                                         // first containing package that the linker loads). canonicalize
 618                                         // it here to the package with which it will be laid down
 619                                         // in text.
 620                                         s.File = objabi.PathToPrefix(lib.Pkg)
 621                                 }
 622                         }
 623                 }
 624         }
 625
 626         if len(ctxt.Shlibs) > 0 {
 627                 // We might have overwritten some functions above (this tends to happen for the
 628                 // autogenerated type equality/hashing functions) and we don't want to generated
 629                 // pcln table entries for these any more so remove them from Textp.
 630                 textp := make([]*sym.Symbol, 0, len(ctxt.Textp))
 631                 for _, s := range ctxt.Textp {
 632                         if s.Type != sym.SDYNIMPORT {
 633                                 textp = append(textp, s)
 634                         }
 635                 }
 636                 ctxt.Textp = textp
 637         }
 638 }
 639
 640 // typeSymbolMangling reports whether the linker should shorten the
 641 // names of symbols that represent Go types.
 642 //
 643 // As the names of these symbols are derived from the string of
 644 // the type, they can run to many kilobytes long. So we shorten
 645 // them using a SHA-1 when the name appears in the final binary.
 646 //
 647 // These are the symbols that begin with the prefix 'type.' and
 648 // contain run-time type information used by the runtime and reflect
 649 // packages. All Go binaries contain these symbols, but only only
 650 // those programs loaded dynamically in multiple parts need these
 651 // symbols to have entries in the symbol table.
 652 func typeSymbolMangling(ctxt *Link) bool {
 653         return ctxt.BuildMode == BuildModeShared || ctxt.linkShared || ctxt.BuildMode == BuildModePlugin || ctxt.Syms.ROLookup("plugin.Open", 0) != nil
 654 }
 655
 656 // typeSymbolMangle mangles the given symbol name into something shorter.
 657 func typeSymbolMangle(name string) string {
 658         if !strings.HasPrefix(name, "type.") {
 659                 return name
 660         }
 661         if strings.HasPrefix(name, "type.runtime.") {
 662                 return name
 663         }
 664         if len(name) <= 14 && !strings.Contains(name, "@") { // Issue 19529
 665                 return name
 666         }
 667         hash := sha1.Sum([]byte(name))
 668         prefix := "type."
 669         if name[5] == '.' {
 670                 prefix = "type.."
 671         }
 672         return prefix + base64.StdEncoding.EncodeToString(hash[:6])
 673 }
 674
 675 /*
 676  * look for the next file in an archive.
 677  * adapted from libmach.
 678  */
 679 func nextar(bp *bio.Reader, off int64, a *ArHdr) int64 {
 680         if off&1 != 0 {
 681                 off++
 682         }
 683         bp.Seek(off, 0)
 684         var buf [SAR_HDR]byte
 685         if n, err := io.ReadFull(bp, buf[:]); err != nil {
 686                 if n == 0 && err != io.EOF {
 687                         return -1
 688                 }
 689                 return 0
 690         }
 691
 692         a.name = artrim(buf[0:16])
 693         a.date = artrim(buf[16:28])
 694         a.uid = artrim(buf[28:34])
 695         a.gid = artrim(buf[34:40])
 696         a.mode = artrim(buf[40:48])
 697         a.size = artrim(buf[48:58])
 698         a.fmag = artrim(buf[58:60])
 699
 700         arsize := atolwhex(a.size)
 701         if arsize&1 != 0 {
 702                 arsize++
 703         }
 704         return arsize + SAR_HDR
 705 }
 706
 707 func genhash(ctxt *Link, lib *sym.Library) {
 708         f, err := bio.Open(lib.File)
 709         if err != nil {
 710                 Errorf(nil, "cannot open file %s for hash generation: %v", lib.File, err)
 711                 return
 712         }
 713         defer f.Close()
 714
 715         var magbuf [len(ARMAG)]byte
 716         if _, err := io.ReadFull(f, magbuf[:]); err != nil {
 717                 Exitf("file %s too short", lib.File)
 718         }
 719
 720         if string(magbuf[:]) != ARMAG {
 721                 Exitf("%s is not an archive file", lib.File)
 722         }
 723
 724         var arhdr ArHdr
 725         l := nextar(f, f.Offset(), &arhdr)
 726         if l <= 0 {
 727                 Errorf(nil, "%s: short read on archive file symbol header", lib.File)
 728                 return
 729         }
 730         if arhdr.name != pkgdef {
 731                 Errorf(nil, "%s: missing package data entry", lib.File)
 732                 return
 733         }
 734
 735         h := sha1.New()
 736
 737         // To compute the hash of a package, we hash the first line of
 738         // __.PKGDEF (which contains the toolchain version and any
 739         // GOEXPERIMENT flags) and the export data (which is between
 740         // the first two occurrences of "\n$$").
 741
 742         pkgDefBytes := make([]byte, atolwhex(arhdr.size))
 743         _, err = io.ReadFull(f, pkgDefBytes)
 744         if err != nil {
 745                 Errorf(nil, "%s: error reading package data: %v", lib.File, err)
 746                 return
 747         }
 748         firstEOL := bytes.IndexByte(pkgDefBytes, '\n')
 749         if firstEOL < 0 {
 750                 Errorf(nil, "cannot parse package data of %s for hash generation, no newline found", lib.File)
 751                 return
 752         }
 753         firstDoubleDollar := bytes.Index(pkgDefBytes, []byte("\n$$"))
 754         if firstDoubleDollar < 0 {
 755                 Errorf(nil, "cannot parse package data of %s for hash generation, no \\n$$ found", lib.File)
 756                 return
 757         }
 758         secondDoubleDollar := bytes.Index(pkgDefBytes[firstDoubleDollar+1:], []byte("\n$$"))
 759         if secondDoubleDollar < 0 {
 760                 Errorf(nil, "cannot parse package data of %s for hash generation, only one \\n$$ found", lib.File)
 761                 return
 762         }
 763         h.Write(pkgDefBytes[0:firstEOL])
 764         h.Write(pkgDefBytes[firstDoubleDollar : firstDoubleDollar+secondDoubleDollar])
 765         lib.Hash = hex.EncodeToString(h.Sum(nil))
 766 }
 767
 768 func loadobjfile(ctxt *Link, lib *sym.Library) {
 769         pkg := objabi.PathToPrefix(lib.Pkg)
 770
 771         if ctxt.Debugvlog > 1 {
 772                 ctxt.Logf("%5.2f ldobj: %s (%s)\n", Cputime(), lib.File, pkg)
 773         }
 774         f, err := bio.Open(lib.File)
 775         if err != nil {
 776                 Exitf("cannot open file %s: %v", lib.File, err)
 777         }
 778         defer f.Close()
 779         defer func() {
 780                 if pkg == "main" && !lib.Main {
 781                         Exitf("%s: not package main", lib.File)
 782                 }
 783
 784                 // Ideally, we'd check that *all* object files within
 785                 // the archive were marked safe, but here we settle
 786                 // for *any*.
 787                 //
 788                 // Historically, cmd/link only checked the __.PKGDEF
 789                 // file, which in turn came from the first object
 790                 // file, typically produced by cmd/compile. The
 791                 // remaining object files are normally produced by
 792                 // cmd/asm, which doesn't support marking files as
 793                 // safe anyway. So at least in practice, this matches
 794                 // how safe mode has always worked.
 795                 if *flagU && !lib.Safe {
 796                         Exitf("%s: load of unsafe package %s", lib.File, pkg)
 797                 }
 798         }()
 799
 800         for i := 0; i < len(ARMAG); i++ {
 801                 if c, err := f.ReadByte(); err == nil && c == ARMAG[i] {
 802                         continue
 803                 }
 804
 805                 /* load it as a regular file */
 806                 l := f.Seek(0, 2)
 807                 f.Seek(0, 0)
 808                 ldobj(ctxt, f, lib, l, lib.File, lib.File)
 809                 return
 810         }
 811
 812         /*
 813          * load all the object files from the archive now.
 814          * this gives us sequential file access and keeps us
 815          * from needing to come back later to pick up more
 816          * objects.  it breaks the usual C archive model, but
 817          * this is Go, not C.  the common case in Go is that
 818          * we need to load all the objects, and then we throw away
 819          * the individual symbols that are unused.
 820          *
 821          * loading every object will also make it possible to
 822          * load foreign objects not referenced by __.PKGDEF.
 823          */
 824         var arhdr ArHdr
 825         off := f.Offset()
 826         for {
 827                 l := nextar(f, off, &arhdr)
 828                 if l == 0 {
 829                         break
 830                 }
 831                 if l < 0 {
 832                         Exitf("%s: malformed archive", lib.File)
 833                 }
 834                 off += l
 835
 836                 // __.PKGDEF isn't a real Go object file, and it's
 837                 // absent in -linkobj builds anyway. Skipping it
 838                 // ensures consistency between -linkobj and normal
 839                 // build modes.
 840                 if arhdr.name == pkgdef {
 841                         continue
 842                 }
 843
 844                 pname := fmt.Sprintf("%s(%s)", lib.File, arhdr.name)
 845                 l = atolwhex(arhdr.size)
 846                 ldobj(ctxt, f, lib, l, pname, lib.File)
 847         }
 848 }
 849
 850 type Hostobj struct {
 851         ld     func(*Link, *bio.Reader, string, int64, string)
 852         pkg    string
 853         pn     string
 854         file   string
 855         off    int64
 856         length int64
 857 }
 858
 859 var hostobj []Hostobj
 860
 861 // These packages can use internal linking mode.
 862 // Others trigger external mode.
 863 var internalpkg = []string{
 864         "crypto/internal/boring",
 865         "crypto/x509",
 866         "net",
 867         "os/user",
 868         "runtime/cgo",
 869         "runtime/race",
 870         "runtime/msan",
 871 }
 872
 873 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 {
 874         isinternal := false
 875         for _, intpkg := range internalpkg {
 876                 if pkg == intpkg {
 877                         isinternal = true
 878                         break
 879                 }
 880         }
 881
 882         // DragonFly declares errno with __thread, which results in a symbol
 883         // type of R_386_TLS_GD or R_X86_64_TLSGD. The Go linker does not
 884         // currently know how to handle TLS relocations, hence we have to
 885         // force external linking for any libraries that link in code that
 886         // uses errno. This can be removed if the Go linker ever supports
 887         // these relocation types.
 888         if headType == objabi.Hdragonfly {
 889                 if pkg == "net" || pkg == "os/user" {
 890                         isinternal = false
 891                 }
 892         }
 893
 894         if !isinternal {
 895                 externalobj = true
 896         }
 897
 898         hostobj = append(hostobj, Hostobj{})
 899         h := &hostobj[len(hostobj)-1]
 900         h.ld = ld
 901         h.pkg = pkg
 902         h.pn = pn
 903         h.file = file
 904         h.off = f.Offset()
 905         h.length = length
 906         return h
 907 }
 908
 909 func hostobjs(ctxt *Link) {
 910         var h *Hostobj
 911
 912         for i := 0; i < len(hostobj); i++ {
 913                 h = &hostobj[i]
 914                 f, err := bio.Open(h.file)
 915                 if err != nil {
 916                         Exitf("cannot reopen %s: %v", h.pn, err)
 917                 }
 918
 919                 f.Seek(h.off, 0)
 920                 h.ld(ctxt, f, h.pkg, h.length, h.pn)
 921                 f.Close()
 922         }
 923 }
 924
 925 func hostlinksetup(ctxt *Link) {
 926         if ctxt.LinkMode != LinkExternal {
 927                 return
 928         }
 929
 930         // For external link, record that we need to tell the external linker -s,
 931         // and turn off -s internally: the external linker needs the symbol
 932         // information for its final link.
 933         debug_s = *FlagS
 934         *FlagS = false
 935
 936         // create temporary directory and arrange cleanup
 937         if *flagTmpdir == "" {
 938                 dir, err := ioutil.TempDir("", "go-link-")
 939                 if err != nil {
 940                         log.Fatal(err)
 941                 }
 942                 *flagTmpdir = dir
 943                 AtExit(func() {
 944                         ctxt.Out.f.Close()
 945                         os.RemoveAll(*flagTmpdir)
 946                 })
 947         }
 948
 949         // change our output to temporary object file
 950         ctxt.Out.f.Close()
 951         mayberemoveoutfile()
 952
 953         p := filepath.Join(*flagTmpdir, "go.o")
 954         var err error
 955         f, err := os.OpenFile(p, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0775)
 956         if err != nil {
 957                 Exitf("cannot create %s: %v", p, err)
 958         }
 959
 960         ctxt.Out.w = bufio.NewWriter(f)
 961         ctxt.Out.f = f
 962         ctxt.Out.off = 0
 963 }
 964
 965 // hostobjCopy creates a copy of the object files in hostobj in a
 966 // temporary directory.
 967 func hostobjCopy() (paths []string) {
 968         var wg sync.WaitGroup
 969         sema := make(chan struct{}, runtime.NumCPU()) // limit open file descriptors
 970         for i, h := range hostobj {
 971                 h := h
 972                 dst := filepath.Join(*flagTmpdir, fmt.Sprintf("%06d.o", i))
 973                 paths = append(paths, dst)
 974
 975                 wg.Add(1)
 976                 go func() {
 977                         sema <- struct{}{}
 978                         defer func() {
 979                                 <-sema
 980                                 wg.Done()
 981                         }()
 982                         f, err := os.Open(h.file)
 983                         if err != nil {
 984                                 Exitf("cannot reopen %s: %v", h.pn, err)
 985                         }
 986                         if _, err := f.Seek(h.off, 0); err != nil {
 987                                 Exitf("cannot seek %s: %v", h.pn, err)
 988                         }
 989
 990                         w, err := os.Create(dst)
 991                         if err != nil {
 992                                 Exitf("cannot create %s: %v", dst, err)
 993                         }
 994                         if _, err := io.CopyN(w, f, h.length); err != nil {
 995                                 Exitf("cannot write %s: %v", dst, err)
 996                         }
 997                         if err := w.Close(); err != nil {
 998                                 Exitf("cannot close %s: %v", dst, err)
 999                         }
1000                 }()
1001         }
1002         wg.Wait()
1003         return paths
1004 }
1005
1006 // writeGDBLinkerScript creates gcc linker script file in temp
1007 // directory. writeGDBLinkerScript returns created file path.
1008 // The script is used to work around gcc bug
1009 // (see https://golang.org/issue/20183 for details).
1010 func writeGDBLinkerScript() string {
1011         name := "fix_debug_gdb_scripts.ld"
1012         path := filepath.Join(*flagTmpdir, name)
1013         src := `SECTIONS
1014 {
1015   .debug_gdb_scripts BLOCK(__section_alignment__) (NOLOAD) :
1016   {
1017     *(.debug_gdb_scripts)
1018   }
1019 }
1020 INSERT AFTER .debug_types;
1021 `
1022         err := ioutil.WriteFile(path, []byte(src), 0666)
1023         if err != nil {
1024                 Errorf(nil, "WriteFile %s failed: %v", name, err)
1025         }
1026         return path
1027 }
1028
1029 // archive builds a .a archive from the hostobj object files.
1030 func (ctxt *Link) archive() {
1031         if ctxt.BuildMode != BuildModeCArchive {
1032                 return
1033         }
1034
1035         if *flagExtar == "" {
1036                 *flagExtar = "ar"
1037         }
1038
1039         mayberemoveoutfile()
1040
1041         // Force the buffer to flush here so that external
1042         // tools will see a complete file.
1043         ctxt.Out.Flush()
1044         if err := ctxt.Out.f.Close(); err != nil {
1045                 Exitf("close: %v", err)
1046         }
1047         ctxt.Out.f = nil
1048
1049         argv := []string{*flagExtar, "-q", "-c", "-s", *flagOutfile}
1050         argv = append(argv, filepath.Join(*flagTmpdir, "go.o"))
1051         argv = append(argv, hostobjCopy()...)
1052
1053         if ctxt.Debugvlog != 0 {
1054                 ctxt.Logf("archive: %s\n", strings.Join(argv, " "))
1055         }
1056
1057         if out, err := exec.Command(argv[0], argv[1:]...).CombinedOutput(); err != nil {
1058                 Exitf("running %s failed: %v\n%s", argv[0], err, out)
1059         }
1060 }
1061
1062 func (ctxt *Link) hostlink() {
1063         if ctxt.LinkMode != LinkExternal || nerrors > 0 {
1064                 return
1065         }
1066         if ctxt.BuildMode == BuildModeCArchive {
1067                 return
1068         }
1069
1070         if *flagExtld == "" {
1071                 *flagExtld = "gcc"
1072         }
1073
1074         var argv []string
1075         argv = append(argv, *flagExtld)
1076         argv = append(argv, hostlinkArchArgs(ctxt.Arch)...)
1077
1078         if *FlagS || debug_s {
1079                 if ctxt.HeadType == objabi.Hdarwin {
1080                         // Recent versions of macOS print
1081                         //      ld: warning: option -s is obsolete and being ignored
1082                         // so do not pass any arguments.
1083                 } else {
1084                         argv = append(argv, "-s")
1085                 }
1086         }
1087
1088         switch ctxt.HeadType {
1089         case objabi.Hdarwin:
1090                 argv = append(argv, "-Wl,-headerpad,1144")
1091                 if ctxt.DynlinkingGo() {
1092                         argv = append(argv, "-Wl,-flat_namespace")
1093                 }
1094                 if ctxt.BuildMode == BuildModeExe && !ctxt.Arch.InFamily(sys.ARM64) {
1095                         argv = append(argv, "-Wl,-no_pie")
1096                 }
1097         case objabi.Hopenbsd:
1098                 argv = append(argv, "-Wl,-nopie")
1099         case objabi.Hwindows:
1100                 if windowsgui {
1101                         argv = append(argv, "-mwindows")
1102                 } else {
1103                         argv = append(argv, "-mconsole")
1104                 }
1105         }
1106
1107         switch ctxt.BuildMode {
1108         case BuildModeExe:
1109                 if ctxt.HeadType == objabi.Hdarwin {
1110                         if ctxt.Arch.Family == sys.ARM64 {
1111                                 // __PAGEZERO segment size determined empirically.
1112                                 // XCode 9.0.1 successfully uploads an iOS app with this value.
1113                                 argv = append(argv, "-Wl,-pagezero_size,100000000")
1114                         } else {
1115                                 argv = append(argv, "-Wl,-pagezero_size,4000000")
1116                         }
1117                 }
1118         case BuildModePIE:
1119                 // ELF.
1120                 if ctxt.HeadType != objabi.Hdarwin {
1121                         if ctxt.UseRelro() {
1122                                 argv = append(argv, "-Wl,-z,relro")
1123                         }
1124                         argv = append(argv, "-pie")
1125                 }
1126         case BuildModeCShared:
1127                 if ctxt.HeadType == objabi.Hdarwin {
1128                         argv = append(argv, "-dynamiclib")
1129                         if ctxt.Arch.Family != sys.AMD64 {
1130                                 argv = append(argv, "-Wl,-read_only_relocs,suppress")
1131                         }
1132                 } else {
1133                         // ELF.
1134                         argv = append(argv, "-Wl,-Bsymbolic")
1135                         if ctxt.UseRelro() {
1136                                 argv = append(argv, "-Wl,-z,relro")
1137                         }
1138                         argv = append(argv, "-shared")
1139                         if ctxt.HeadType != objabi.Hwindows {
1140                                 // Pass -z nodelete to mark the shared library as
1141                                 // non-closeable: a dlclose will do nothing.
1142                                 argv = append(argv, "-Wl,-z,nodelete")
1143                         }
1144                 }
1145         case BuildModeShared:
1146                 if ctxt.UseRelro() {
1147                         argv = append(argv, "-Wl,-z,relro")
1148                 }
1149                 argv = append(argv, "-shared")
1150         case BuildModePlugin:
1151                 if ctxt.HeadType == objabi.Hdarwin {
1152                         argv = append(argv, "-dynamiclib")
1153                 } else {
1154                         if ctxt.UseRelro() {
1155                                 argv = append(argv, "-Wl,-z,relro")
1156                         }
1157                         argv = append(argv, "-shared")
1158                 }
1159         }
1160
1161         if ctxt.IsELF && ctxt.DynlinkingGo() {
1162                 // We force all symbol resolution to be done at program startup
1163                 // because lazy PLT resolution can use large amounts of stack at
1164                 // times we cannot allow it to do so.
1165                 argv = append(argv, "-Wl,-znow")
1166
1167                 // Do not let the host linker generate COPY relocations. These
1168                 // can move symbols out of sections that rely on stable offsets
1169                 // from the beginning of the section (like sym.STYPE).
1170                 argv = append(argv, "-Wl,-znocopyreloc")
1171
1172                 if ctxt.Arch.InFamily(sys.ARM, sys.ARM64) {
1173                         // On ARM, the GNU linker will generate COPY relocations
1174                         // even with -znocopyreloc set.
1175                         // https://sourceware.org/bugzilla/show_bug.cgi?id=19962
1176                         //
1177                         // On ARM64, the GNU linker will fail instead of
1178                         // generating COPY relocations.
1179                         //
1180                         // In both cases, switch to gold.
1181                         argv = append(argv, "-fuse-ld=gold")
1182
1183                         // If gold is not installed, gcc will silently switch
1184                         // back to ld.bfd. So we parse the version information
1185                         // and provide a useful error if gold is missing.
1186                         cmd := exec.Command(*flagExtld, "-fuse-ld=gold", "-Wl,--version")
1187                         if out, err := cmd.CombinedOutput(); err == nil {
1188                                 if !bytes.Contains(out, []byte("GNU gold")) {
1189                                         log.Fatalf("ARM external linker must be gold (issue #15696), but is not: %s", out)
1190                                 }
1191                         }
1192                 }
1193         }
1194
1195         if ctxt.IsELF && len(buildinfo) > 0 {
1196                 argv = append(argv, fmt.Sprintf("-Wl,--build-id=0x%x", buildinfo))
1197         }
1198
1199         // On Windows, given -o foo, GCC will append ".exe" to produce
1200         // "foo.exe".  We have decided that we want to honor the -o
1201         // option. To make this work, we append a '.' so that GCC
1202         // will decide that the file already has an extension. We
1203         // only want to do this when producing a Windows output file
1204         // on a Windows host.
1205         outopt := *flagOutfile
1206         if objabi.GOOS == "windows" && runtime.GOOS == "windows" && filepath.Ext(outopt) == "" {
1207                 outopt += "."
1208         }
1209         argv = append(argv, "-o")
1210         argv = append(argv, outopt)
1211
1212         if rpath.val != "" {
1213                 argv = append(argv, fmt.Sprintf("-Wl,-rpath,%s", rpath.val))
1214         }
1215
1216         // Force global symbols to be exported for dlopen, etc.
1217         if ctxt.IsELF {
1218                 argv = append(argv, "-rdynamic")
1219         }
1220
1221         if strings.Contains(argv[0], "clang") {
1222                 argv = append(argv, "-Qunused-arguments")
1223         }
1224
1225         argv = append(argv, filepath.Join(*flagTmpdir, "go.o"))
1226         argv = append(argv, hostobjCopy()...)
1227
1228         if ctxt.linkShared {
1229                 seenDirs := make(map[string]bool)
1230                 seenLibs := make(map[string]bool)
1231                 addshlib := func(path string) {
1232                         dir, base := filepath.Split(path)
1233                         if !seenDirs[dir] {
1234                                 argv = append(argv, "-L"+dir)
1235                                 if !rpath.set {
1236                                         argv = append(argv, "-Wl,-rpath="+dir)
1237                                 }
1238                                 seenDirs[dir] = true
1239                         }
1240                         base = strings.TrimSuffix(base, ".so")
1241                         base = strings.TrimPrefix(base, "lib")
1242                         if !seenLibs[base] {
1243                                 argv = append(argv, "-l"+base)
1244                                 seenLibs[base] = true
1245                         }
1246                 }
1247                 for _, shlib := range ctxt.Shlibs {
1248                         addshlib(shlib.Path)
1249                         for _, dep := range shlib.Deps {
1250                                 if dep == "" {
1251                                         continue
1252                                 }
1253                                 libpath := findshlib(ctxt, dep)
1254                                 if libpath != "" {
1255                                         addshlib(libpath)
1256                                 }
1257                         }
1258                 }
1259         }
1260
1261         argv = append(argv, ldflag...)
1262
1263         // When building a program with the default -buildmode=exe the
1264         // gc compiler generates code requires DT_TEXTREL in a
1265         // position independent executable (PIE). On systems where the
1266         // toolchain creates PIEs by default, and where DT_TEXTREL
1267         // does not work, the resulting programs will not run. See
1268         // issue #17847. To avoid this problem pass -no-pie to the
1269         // toolchain if it is supported.
1270         if ctxt.BuildMode == BuildModeExe && !ctxt.linkShared {
1271                 src := filepath.Join(*flagTmpdir, "trivial.c")
1272                 if err := ioutil.WriteFile(src, []byte("int main() { return 0; }"), 0666); err != nil {
1273                         Errorf(nil, "WriteFile trivial.c failed: %v", err)
1274                 }
1275
1276                 // GCC uses -no-pie, clang uses -nopie.
1277                 for _, nopie := range []string{"-no-pie", "-nopie"} {
1278                         cmd := exec.Command(argv[0], nopie, "trivial.c")
1279                         cmd.Dir = *flagTmpdir
1280                         cmd.Env = append([]string{"LC_ALL=C"}, os.Environ()...)
1281                         out, err := cmd.CombinedOutput()
1282                         // GCC says "unrecognized command line option ‘-no-pie’"
1283                         // clang says "unknown argument: '-no-pie'"
1284                         supported := err == nil && !bytes.Contains(out, []byte("unrecognized")) && !bytes.Contains(out, []byte("unknown"))
1285                         if supported {
1286                                 argv = append(argv, nopie)
1287                                 break
1288                         }
1289                 }
1290         }
1291
1292         for _, p := range strings.Fields(*flagExtldflags) {
1293                 argv = append(argv, p)
1294
1295                 // clang, unlike GCC, passes -rdynamic to the linker
1296                 // even when linking with -static, causing a linker
1297                 // error when using GNU ld. So take out -rdynamic if
1298                 // we added it. We do it in this order, rather than
1299                 // only adding -rdynamic later, so that -*extldflags
1300                 // can override -rdynamic without using -static.
1301                 if ctxt.IsELF && p == "-static" {
1302                         for i := range argv {
1303                                 if argv[i] == "-rdynamic" {
1304                                         argv[i] = "-static"
1305                                 }
1306                         }
1307                 }
1308         }
1309         if ctxt.HeadType == objabi.Hwindows {
1310                 // use gcc linker script to work around gcc bug
1311                 // (see https://golang.org/issue/20183 for details).
1312                 p := writeGDBLinkerScript()
1313                 argv = append(argv, "-Wl,-T,"+p)
1314                 // libmingw32 and libmingwex have some inter-dependencies,
1315                 // so must use linker groups.
1316                 argv = append(argv, "-Wl,--start-group", "-lmingwex", "-lmingw32", "-Wl,--end-group")
1317                 argv = append(argv, peimporteddlls()...)
1318         }
1319
1320         if ctxt.Debugvlog != 0 {
1321                 ctxt.Logf("%5.2f host link:", Cputime())
1322                 for _, v := range argv {
1323                         ctxt.Logf(" %q", v)
1324                 }
1325                 ctxt.Logf("\n")
1326         }
1327
1328         if out, err := exec.Command(argv[0], argv[1:]...).CombinedOutput(); err != nil {
1329                 Exitf("running %s failed: %v\n%s", argv[0], err, out)
1330         } else if len(out) > 0 {
1331                 // always print external output even if the command is successful, so that we don't
1332                 // swallow linker warnings (see https://golang.org/issue/17935).
1333                 ctxt.Logf("%s", out)
1334         }
1335
1336         if !*FlagS && !*FlagW && !debug_s && ctxt.HeadType == objabi.Hdarwin {
1337                 dsym := filepath.Join(*flagTmpdir, "go.dwarf")
1338                 if out, err := exec.Command("dsymutil", "-f", *flagOutfile, "-o", dsym).CombinedOutput(); err != nil {
1339                         Exitf("%s: running dsymutil failed: %v\n%s", os.Args[0], err, out)
1340                 }
1341                 // Skip combining if `dsymutil` didn't generate a file. See #11994.
1342                 if _, err := os.Stat(dsym); os.IsNotExist(err) {
1343                         return
1344                 }
1345                 // For os.Rename to work reliably, must be in same directory as outfile.
1346                 combinedOutput := *flagOutfile + "~"
1347                 isIOS, err := machoCombineDwarf(*flagOutfile, dsym, combinedOutput, ctxt.BuildMode)
1348                 if err != nil {
1349                         Exitf("%s: combining dwarf failed: %v", os.Args[0], err)
1350                 }
1351                 if !isIOS {
1352                         os.Remove(*flagOutfile)
1353                         if err := os.Rename(combinedOutput, *flagOutfile); err != nil {
1354                                 Exitf("%s: %v", os.Args[0], err)
1355                         }
1356                 }
1357         }
1358 }
1359
1360 // hostlinkArchArgs returns arguments to pass to the external linker
1361 // based on the architecture.
1362 func hostlinkArchArgs(arch *sys.Arch) []string {
1363         switch arch.Family {
1364         case sys.I386:
1365                 return []string{"-m32"}
1366         case sys.AMD64, sys.PPC64, sys.S390X:
1367                 return []string{"-m64"}
1368         case sys.ARM:
1369                 return []string{"-marm"}
1370         case sys.ARM64:
1371                 // nothing needed
1372         case sys.MIPS64:
1373                 return []string{"-mabi=64"}
1374         case sys.MIPS:
1375                 return []string{"-mabi=32"}
1376         }
1377         return nil
1378 }
1379
1380 // ldobj loads an input object. If it is a host object (an object
1381 // compiled by a non-Go compiler) it returns the Hostobj pointer. If
1382 // it is a Go object, it returns nil.
1383 func ldobj(ctxt *Link, f *bio.Reader, lib *sym.Library, length int64, pn string, file string) *Hostobj {
1384         pkg := objabi.PathToPrefix(lib.Pkg)
1385
1386         eof := f.Offset() + length
1387         start := f.Offset()
1388         c1 := bgetc(f)
1389         c2 := bgetc(f)
1390         c3 := bgetc(f)
1391         c4 := bgetc(f)
1392         f.Seek(start, 0)
1393
1394         magic := uint32(c1)<<24 | uint32(c2)<<16 | uint32(c3)<<8 | uint32(c4)
1395         if magic == 0x7f454c46 { // \x7F E L F
1396                 ldelf := func(ctxt *Link, f *bio.Reader, pkg string, length int64, pn string) {
1397                         textp, flags, err := loadelf.Load(ctxt.Arch, ctxt.Syms, f, pkg, length, pn, ehdr.flags)
1398                         if err != nil {
1399                                 Errorf(nil, "%v", err)
1400                                 return
1401                         }
1402                         ehdr.flags = flags
1403                         ctxt.Textp = append(ctxt.Textp, textp...)
1404                 }
1405                 return ldhostobj(ldelf, ctxt.HeadType, f, pkg, length, pn, file)
1406         }
1407
1408         if magic&^1 == 0xfeedface || magic&^0x01000000 == 0xcefaedfe {
1409                 ldmacho := func(ctxt *Link, f *bio.Reader, pkg string, length int64, pn string) {
1410                         textp, err := loadmacho.Load(ctxt.Arch, ctxt.Syms, f, pkg, length, pn)
1411                         if err != nil {
1412                                 Errorf(nil, "%v", err)
1413                                 return
1414                         }
1415                         ctxt.Textp = append(ctxt.Textp, textp...)
1416                 }
1417                 return ldhostobj(ldmacho, ctxt.HeadType, f, pkg, length, pn, file)
1418         }
1419
1420         if c1 == 0x4c && c2 == 0x01 || c1 == 0x64 && c2 == 0x86 {
1421                 ldpe := func(ctxt *Link, f *bio.Reader, pkg string, length int64, pn string) {
1422                         textp, rsrc, err := loadpe.Load(ctxt.Arch, ctxt.Syms, f, pkg, length, pn)
1423                         if err != nil {
1424                                 Errorf(nil, "%v", err)
1425                                 return
1426                         }
1427                         if rsrc != nil {
1428                                 setpersrc(ctxt, rsrc)
1429                         }
1430                         ctxt.Textp = append(ctxt.Textp, textp...)
1431                 }
1432                 return ldhostobj(ldpe, ctxt.HeadType, f, pkg, length, pn, file)
1433         }
1434
1435         /* check the header */
1436         line, err := f.ReadString('\n')
1437         if err != nil {
1438                 Errorf(nil, "truncated object file: %s: %v", pn, err)
1439                 return nil
1440         }
1441
1442         if !strings.HasPrefix(line, "go object ") {
1443                 if strings.HasSuffix(pn, ".go") {
1444                         Exitf("%s: uncompiled .go source file", pn)
1445                         return nil
1446                 }
1447
1448                 if line == ctxt.Arch.Name {
1449                         // old header format: just $GOOS
1450                         Errorf(nil, "%s: stale object file", pn)
1451                         return nil
1452                 }
1453
1454                 Errorf(nil, "%s: not an object file", pn)
1455                 return nil
1456         }
1457
1458         // First, check that the basic GOOS, GOARCH, and Version match.
1459         t := fmt.Sprintf("%s %s %s ", objabi.GOOS, objabi.GOARCH, objabi.Version)
1460
1461         line = strings.TrimRight(line, "\n")
1462         if !strings.HasPrefix(line[10:]+" ", t) && !*flagF {
1463                 Errorf(nil, "%s: object is [%s] expected [%s]", pn, line[10:], t)
1464                 return nil
1465         }
1466
1467         // Second, check that longer lines match each other exactly,
1468         // so that the Go compiler and write additional information
1469         // that must be the same from run to run.
1470         if len(line) >= len(t)+10 {
1471                 if theline == "" {
1472                         theline = line[10:]
1473                 } else if theline != line[10:] {
1474                         Errorf(nil, "%s: object is [%s] expected [%s]", pn, line[10:], theline)
1475                         return nil
1476                 }
1477         }
1478
1479         // Skip over exports and other info -- ends with \n!\n.
1480         //
1481         // Note: It's possible for "\n!\n" to appear within the binary
1482         // package export data format. To avoid truncating the package
1483         // definition prematurely (issue 21703), we keep keep track of
1484         // how many "$$" delimiters we've seen.
1485
1486         import0 := f.Offset()
1487
1488         c1 = '\n' // the last line ended in \n
1489         c2 = bgetc(f)
1490         c3 = bgetc(f)
1491         markers := 0
1492         for {
1493                 if c1 == '\n' {
1494                         if markers%2 == 0 && c2 == '!' && c3 == '\n' {
1495                                 break
1496                         }
1497                         if c2 == '$' && c3 == '$' {
1498                                 markers++
1499                         }
1500                 }
1501
1502                 c1 = c2
1503                 c2 = c3
1504                 c3 = bgetc(f)
1505                 if c3 == -1 {
1506                         Errorf(nil, "truncated object file: %s", pn)
1507                         return nil
1508                 }
1509         }
1510
1511         import1 := f.Offset()
1512
1513         f.Seek(import0, 0)
1514         ldpkg(ctxt, f, lib, import1-import0-2, pn) // -2 for !\n
1515         f.Seek(import1, 0)
1516
1517         objfile.Load(ctxt.Arch, ctxt.Syms, f, lib, eof-f.Offset(), pn)
1518         addImports(ctxt, lib, pn)
1519         return nil
1520 }
1521
1522 func readelfsymboldata(ctxt *Link, f *elf.File, sym *elf.Symbol) []byte {
1523         data := make([]byte, sym.Size)
1524         sect := f.Sections[sym.Section]
1525         if sect.Type != elf.SHT_PROGBITS && sect.Type != elf.SHT_NOTE {
1526                 Errorf(nil, "reading %s from non-data section", sym.Name)
1527         }
1528         n, err := sect.ReadAt(data, int64(sym.Value-sect.Addr))
1529         if uint64(n) != sym.Size {
1530                 Errorf(nil, "reading contents of %s: %v", sym.Name, err)
1531         }
1532         return data
1533 }
1534
1535 func readwithpad(r io.Reader, sz int32) ([]byte, error) {
1536         data := make([]byte, Rnd(int64(sz), 4))
1537         _, err := io.ReadFull(r, data)
1538         if err != nil {
1539                 return nil, err
1540         }
1541         data = data[:sz]
1542         return data, nil
1543 }
1544
1545 func readnote(f *elf.File, name []byte, typ int32) ([]byte, error) {
1546         for _, sect := range f.Sections {
1547                 if sect.Type != elf.SHT_NOTE {
1548                         continue
1549                 }
1550                 r := sect.Open()
1551                 for {
1552                         var namesize, descsize, noteType int32
1553                         err := binary.Read(r, f.ByteOrder, &namesize)
1554                         if err != nil {
1555                                 if err == io.EOF {
1556                                         break
1557                                 }
1558                                 return nil, fmt.Errorf("read namesize failed: %v", err)
1559                         }
1560                         err = binary.Read(r, f.ByteOrder, &descsize)
1561                         if err != nil {
1562                                 return nil, fmt.Errorf("read descsize failed: %v", err)
1563                         }
1564                         err = binary.Read(r, f.ByteOrder, &noteType)
1565                         if err != nil {
1566                                 return nil, fmt.Errorf("read type failed: %v", err)
1567                         }
1568                         noteName, err := readwithpad(r, namesize)
1569                         if err != nil {
1570                                 return nil, fmt.Errorf("read name failed: %v", err)
1571                         }
1572                         desc, err := readwithpad(r, descsize)
1573                         if err != nil {
1574                                 return nil, fmt.Errorf("read desc failed: %v", err)
1575                         }
1576                         if string(name) == string(noteName) && typ == noteType {
1577                                 return desc, nil
1578                         }
1579                 }
1580         }
1581         return nil, nil
1582 }
1583
1584 func findshlib(ctxt *Link, shlib string) string {
1585         if filepath.IsAbs(shlib) {
1586                 return shlib
1587         }
1588         for _, libdir := range ctxt.Libdir {
1589                 libpath := filepath.Join(libdir, shlib)
1590                 if _, err := os.Stat(libpath); err == nil {
1591                         return libpath
1592                 }
1593         }
1594         Errorf(nil, "cannot find shared library: %s", shlib)
1595         return ""
1596 }
1597
1598 func ldshlibsyms(ctxt *Link, shlib string) {
1599         var libpath string
1600         if filepath.IsAbs(shlib) {
1601                 libpath = shlib
1602                 shlib = filepath.Base(shlib)
1603         } else {
1604                 libpath = findshlib(ctxt, shlib)
1605                 if libpath == "" {
1606                         return
1607                 }
1608         }
1609         for _, processedlib := range ctxt.Shlibs {
1610                 if processedlib.Path == libpath {
1611                         return
1612                 }
1613         }
1614         if ctxt.Debugvlog > 1 {
1615                 ctxt.Logf("%5.2f ldshlibsyms: found library with name %s at %s\n", Cputime(), shlib, libpath)
1616         }
1617
1618         f, err := elf.Open(libpath)
1619         if err != nil {
1620                 Errorf(nil, "cannot open shared library: %s", libpath)
1621                 return
1622         }
1623         defer f.Close()
1624
1625         hash, err := readnote(f, ELF_NOTE_GO_NAME, ELF_NOTE_GOABIHASH_TAG)
1626         if err != nil {
1627                 Errorf(nil, "cannot read ABI hash from shared library %s: %v", libpath, err)
1628                 return
1629         }
1630
1631         depsbytes, err := readnote(f, ELF_NOTE_GO_NAME, ELF_NOTE_GODEPS_TAG)
1632         if err != nil {
1633                 Errorf(nil, "cannot read dep list from shared library %s: %v", libpath, err)
1634                 return
1635         }
1636         var deps []string
1637         for _, dep := range strings.Split(string(depsbytes), "\n") {
1638                 if dep == "" {
1639                         continue
1640                 }
1641                 if !filepath.IsAbs(dep) {
1642                         // If the dep can be interpreted as a path relative to the shlib
1643                         // in which it was found, do that. Otherwise, we will leave it
1644                         // to be resolved by libdir lookup.
1645                         abs := filepath.Join(filepath.Dir(libpath), dep)
1646                         if _, err := os.Stat(abs); err == nil {
1647                                 dep = abs
1648                         }
1649                 }
1650                 deps = append(deps, dep)
1651         }
1652
1653         syms, err := f.DynamicSymbols()
1654         if err != nil {
1655                 Errorf(nil, "cannot read symbols from shared library: %s", libpath)
1656                 return
1657         }
1658         gcdataLocations := make(map[uint64]*sym.Symbol)
1659         for _, elfsym := range syms {
1660                 if elf.ST_TYPE(elfsym.Info) == elf.STT_NOTYPE || elf.ST_TYPE(elfsym.Info) == elf.STT_SECTION {
1661                         continue
1662                 }
1663                 lsym := ctxt.Syms.Lookup(elfsym.Name, 0)
1664                 // Because loadlib above loads all .a files before loading any shared
1665                 // libraries, any non-dynimport symbols we find that duplicate symbols
1666                 // already loaded should be ignored (the symbols from the .a files
1667                 // "win").
1668                 if lsym.Type != 0 && lsym.Type != sym.SDYNIMPORT {
1669                         continue
1670                 }
1671                 lsym.Type = sym.SDYNIMPORT
1672                 lsym.ElfType = elf.ST_TYPE(elfsym.Info)
1673                 lsym.Size = int64(elfsym.Size)
1674                 if elfsym.Section != elf.SHN_UNDEF {
1675                         // Set .File for the library that actually defines the symbol.
1676                         lsym.File = libpath
1677                         // The decodetype_* functions in decodetype.go need access to
1678                         // the type data.
1679                         if strings.HasPrefix(lsym.Name, "type.") && !strings.HasPrefix(lsym.Name, "type..") {
1680                                 lsym.P = readelfsymboldata(ctxt, f, &elfsym)
1681                                 gcdataLocations[elfsym.Value+2*uint64(ctxt.Arch.PtrSize)+8+1*uint64(ctxt.Arch.PtrSize)] = lsym
1682                         }
1683                 }
1684         }
1685         gcdataAddresses := make(map[*sym.Symbol]uint64)
1686         if ctxt.Arch.Family == sys.ARM64 {
1687                 for _, sect := range f.Sections {
1688                         if sect.Type == elf.SHT_RELA {
1689                                 var rela elf.Rela64
1690                                 rdr := sect.Open()
1691                                 for {
1692                                         err := binary.Read(rdr, f.ByteOrder, &rela)
1693                                         if err == io.EOF {
1694                                                 break
1695                                         } else if err != nil {
1696                                                 Errorf(nil, "reading relocation failed %v", err)
1697                                                 return
1698                                         }
1699                                         t := elf.R_AARCH64(rela.Info & 0xffff)
1700                                         if t != elf.R_AARCH64_RELATIVE {
1701                                                 continue
1702                                         }
1703                                         if lsym, ok := gcdataLocations[rela.Off]; ok {
1704                                                 gcdataAddresses[lsym] = uint64(rela.Addend)
1705                                         }
1706                                 }
1707                         }
1708                 }
1709         }
1710
1711         ctxt.Shlibs = append(ctxt.Shlibs, Shlib{Path: libpath, Hash: hash, Deps: deps, File: f, gcdataAddresses: gcdataAddresses})
1712 }
1713
1714 func addsection(arch *sys.Arch, seg *sym.Segment, name string, rwx int) *sym.Section {
1715         sect := new(sym.Section)
1716         sect.Rwx = uint8(rwx)
1717         sect.Name = name
1718         sect.Seg = seg
1719         sect.Align = int32(arch.PtrSize) // everything is at least pointer-aligned
1720         seg.Sections = append(seg.Sections, sect)
1721         return sect
1722 }
1723
1724 func Le16(b []byte) uint16 {
1725         return uint16(b[0]) | uint16(b[1])<<8
1726 }
1727
1728 func Le32(b []byte) uint32 {
1729         return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
1730 }
1731
1732 func Le64(b []byte) uint64 {
1733         return uint64(Le32(b)) | uint64(Le32(b[4:]))<<32
1734 }
1735
1736 func Be16(b []byte) uint16 {
1737         return uint16(b[0])<<8 | uint16(b[1])
1738 }
1739
1740 func Be32(b []byte) uint32 {
1741         return uint32(b[0])<<24 | uint32(b[1])<<16 | uint32(b[2])<<8 | uint32(b[3])
1742 }
1743
1744 type chain struct {
1745         sym   *sym.Symbol
1746         up    *chain
1747         limit int // limit on entry to sym
1748 }
1749
1750 var morestack *sym.Symbol
1751
1752 // TODO: Record enough information in new object files to
1753 // allow stack checks here.
1754
1755 func haslinkregister(ctxt *Link) bool {
1756         return ctxt.FixedFrameSize() != 0
1757 }
1758
1759 func callsize(ctxt *Link) int {
1760         if haslinkregister(ctxt) {
1761                 return 0
1762         }
1763         return ctxt.Arch.RegSize
1764 }
1765
1766 func (ctxt *Link) dostkcheck() {
1767         var ch chain
1768
1769         morestack = ctxt.Syms.Lookup("runtime.morestack", 0)
1770
1771         // Every splitting function ensures that there are at least StackLimit
1772         // bytes available below SP when the splitting prologue finishes.
1773         // If the splitting function calls F, then F begins execution with
1774         // at least StackLimit - callsize() bytes available.
1775         // Check that every function behaves correctly with this amount
1776         // of stack, following direct calls in order to piece together chains
1777         // of non-splitting functions.
1778         ch.up = nil
1779
1780         ch.limit = objabi.StackLimit - callsize(ctxt)
1781
1782         // Check every function, but do the nosplit functions in a first pass,
1783         // to make the printed failure chains as short as possible.
1784         for _, s := range ctxt.Textp {
1785                 // runtime.racesymbolizethunk is called from gcc-compiled C
1786                 // code running on the operating system thread stack.
1787                 // It uses more than the usual amount of stack but that's okay.
1788                 if s.Name == "runtime.racesymbolizethunk" {
1789                         continue
1790                 }
1791
1792                 if s.Attr.NoSplit() {
1793                         ch.sym = s
1794                         stkcheck(ctxt, &ch, 0)
1795                 }
1796         }
1797
1798         for _, s := range ctxt.Textp {
1799                 if !s.Attr.NoSplit() {
1800                         ch.sym = s
1801                         stkcheck(ctxt, &ch, 0)
1802                 }
1803         }
1804 }
1805
1806 func stkcheck(ctxt *Link, up *chain, depth int) int {
1807         limit := up.limit
1808         s := up.sym
1809
1810         // Don't duplicate work: only need to consider each
1811         // function at top of safe zone once.
1812         top := limit == objabi.StackLimit-callsize(ctxt)
1813         if top {
1814                 if s.Attr.StackCheck() {
1815                         return 0
1816                 }
1817                 s.Attr |= sym.AttrStackCheck
1818         }
1819
1820         if depth > 100 {
1821                 Errorf(s, "nosplit stack check too deep")
1822                 stkbroke(ctxt, up, 0)
1823                 return -1
1824         }
1825
1826         if s.Attr.External() || s.FuncInfo == nil {
1827                 // external function.
1828                 // should never be called directly.
1829                 // onlyctxt.Diagnose the direct caller.
1830                 // TODO(mwhudson): actually think about this.
1831                 // TODO(khr): disabled for now. Calls to external functions can only happen on the g0 stack.
1832                 // See the trampolines in src/runtime/sys_darwin_$ARCH.go.
1833                 if depth == 1 && s.Type != sym.SXREF && !ctxt.DynlinkingGo() &&
1834                         ctxt.BuildMode != BuildModeCArchive && ctxt.BuildMode != BuildModePIE && ctxt.BuildMode != BuildModeCShared && ctxt.BuildMode != BuildModePlugin {
1835                         //Errorf(s, "call to external function")
1836                 }
1837                 return -1
1838         }
1839
1840         if limit < 0 {
1841                 stkbroke(ctxt, up, limit)
1842                 return -1
1843         }
1844
1845         // morestack looks like it calls functions,
1846         // but it switches the stack pointer first.
1847         if s == morestack {
1848                 return 0
1849         }
1850
1851         var ch chain
1852         ch.up = up
1853
1854         if !s.Attr.NoSplit() {
1855                 // Ensure we have enough stack to call morestack.
1856                 ch.limit = limit - callsize(ctxt)
1857                 ch.sym = morestack
1858                 if stkcheck(ctxt, &ch, depth+1) < 0 {
1859                         return -1
1860                 }
1861                 if !top {
1862                         return 0
1863                 }
1864                 // Raise limit to allow frame.
1865                 locals := int32(0)
1866                 if s.FuncInfo != nil {
1867                         locals = s.FuncInfo.Locals
1868                 }
1869                 limit = int(objabi.StackLimit+locals) + int(ctxt.FixedFrameSize())
1870         }
1871
1872         // Walk through sp adjustments in function, consuming relocs.
1873         ri := 0
1874
1875         endr := len(s.R)
1876         var ch1 chain
1877         var pcsp Pciter
1878         var r *sym.Reloc
1879         for pciterinit(ctxt, &pcsp, &s.FuncInfo.Pcsp); pcsp.done == 0; pciternext(&pcsp) {
1880                 // pcsp.value is in effect for [pcsp.pc, pcsp.nextpc).
1881
1882                 // Check stack size in effect for this span.
1883                 if int32(limit)-pcsp.value < 0 {
1884                         stkbroke(ctxt, up, int(int32(limit)-pcsp.value))
1885                         return -1
1886                 }
1887
1888                 // Process calls in this span.
1889                 for ; ri < endr && uint32(s.R[ri].Off) < pcsp.nextpc; ri++ {
1890                         r = &s.R[ri]
1891                         switch r.Type {
1892                         // Direct call.
1893                         case objabi.R_CALL, objabi.R_CALLARM, objabi.R_CALLARM64, objabi.R_CALLPOWER, objabi.R_CALLMIPS:
1894                                 ch.limit = int(int32(limit) - pcsp.value - int32(callsize(ctxt)))
1895                                 ch.sym = r.Sym
1896                                 if stkcheck(ctxt, &ch, depth+1) < 0 {
1897                                         return -1
1898                                 }
1899
1900                         // Indirect call. Assume it is a call to a splitting function,
1901                         // so we have to make sure it can call morestack.
1902                         // Arrange the data structures to report both calls, so that
1903                         // if there is an error, stkprint shows all the steps involved.
1904                         case objabi.R_CALLIND:
1905                                 ch.limit = int(int32(limit) - pcsp.value - int32(callsize(ctxt)))
1906
1907                                 ch.sym = nil
1908                                 ch1.limit = ch.limit - callsize(ctxt) // for morestack in called prologue
1909                                 ch1.up = &ch
1910                                 ch1.sym = morestack
1911                                 if stkcheck(ctxt, &ch1, depth+2) < 0 {
1912                                         return -1
1913                                 }
1914                         }
1915                 }
1916         }
1917
1918         return 0
1919 }
1920
1921 func stkbroke(ctxt *Link, ch *chain, limit int) {
1922         Errorf(ch.sym, "nosplit stack overflow")
1923         stkprint(ctxt, ch, limit)
1924 }
1925
1926 func stkprint(ctxt *Link, ch *chain, limit int) {
1927         var name string
1928
1929         if ch.sym != nil {
1930                 name = ch.sym.Name
1931                 if ch.sym.Attr.NoSplit() {
1932                         name += " (nosplit)"
1933                 }
1934         } else {
1935                 name = "function pointer"
1936         }
1937
1938         if ch.up == nil {
1939                 // top of chain.  ch->sym != nil.
1940                 if ch.sym.Attr.NoSplit() {
1941                         fmt.Printf("\t%d\tassumed on entry to %s\n", ch.limit, name)
1942                 } else {
1943                         fmt.Printf("\t%d\tguaranteed after split check in %s\n", ch.limit, name)
1944                 }
1945         } else {
1946                 stkprint(ctxt, ch.up, ch.limit+callsize(ctxt))
1947                 if !haslinkregister(ctxt) {
1948                         fmt.Printf("\t%d\ton entry to %s\n", ch.limit, name)
1949                 }
1950         }
1951
1952         if ch.limit != limit {
1953                 fmt.Printf("\t%d\tafter %s uses %d\n", limit, name, ch.limit-limit)
1954         }
1955 }
1956
1957 func usage() {
1958         fmt.Fprintf(os.Stderr, "usage: link [options] main.o\n")
1959         objabi.Flagprint(os.Stderr)
1960         Exit(2)
1961 }
1962
1963 type SymbolType int8
1964
1965 const (
1966         // see also https://9p.io/magic/man2html/1/nm
1967         TextSym      SymbolType = 'T'
1968         DataSym      SymbolType = 'D'
1969         BSSSym       SymbolType = 'B'
1970         UndefinedSym SymbolType = 'U'
1971         TLSSym       SymbolType = 't'
1972         FrameSym     SymbolType = 'm'
1973         ParamSym     SymbolType = 'p'
1974         AutoSym      SymbolType = 'a'
1975
1976         // Deleted auto (not a real sym, just placeholder for type)
1977         DeletedAutoSym = 'x'
1978 )
1979
1980 func genasmsym(ctxt *Link, put func(*Link, *sym.Symbol, string, SymbolType, int64, *sym.Symbol)) {
1981         // These symbols won't show up in the first loop below because we
1982         // skip sym.STEXT symbols. Normal sym.STEXT symbols are emitted by walking textp.
1983         s := ctxt.Syms.Lookup("runtime.text", 0)
1984         if s.Type == sym.STEXT {
1985                 // We've already included this symbol in ctxt.Textp
1986                 // if ctxt.DynlinkingGo() && ctxt.HeadType == objabi.Hdarwin.
1987                 // See data.go:/textaddress
1988                 if !(ctxt.DynlinkingGo() && ctxt.HeadType == objabi.Hdarwin) {
1989                         put(ctxt, s, s.Name, TextSym, s.Value, nil)
1990                 }
1991         }
1992
1993         n := 0
1994
1995         // Generate base addresses for all text sections if there are multiple
1996         for _, sect := range Segtext.Sections {
1997                 if n == 0 {
1998                         n++
1999                         continue
2000                 }
2001                 if sect.Name != ".text" {
2002                         break
2003                 }
2004                 s = ctxt.Syms.ROLookup(fmt.Sprintf("runtime.text.%d", n), 0)
2005                 if s == nil {
2006                         break
2007                 }
2008                 if s.Type == sym.STEXT {
2009                         put(ctxt, s, s.Name, TextSym, s.Value, nil)
2010                 }
2011                 n++
2012         }
2013
2014         s = ctxt.Syms.Lookup("runtime.etext", 0)
2015         if s.Type == sym.STEXT {
2016                 // We've already included this symbol in ctxt.Textp
2017                 // if ctxt.DynlinkingGo() && ctxt.HeadType == objabi.Hdarwin.
2018                 // See data.go:/textaddress
2019                 if !(ctxt.DynlinkingGo() && ctxt.HeadType == objabi.Hdarwin) {
2020                         put(ctxt, s, s.Name, TextSym, s.Value, nil)
2021                 }
2022         }
2023
2024         for _, s := range ctxt.Syms.Allsym {
2025                 if s.Attr.NotInSymbolTable() {
2026                         continue
2027                 }
2028                 if (s.Name == "" || s.Name[0] == '.') && s.Version == 0 && s.Name != ".rathole" && s.Name != ".TOC." {
2029                         continue
2030                 }
2031                 switch s.Type {
2032                 case sym.SCONST,
2033                         sym.SRODATA,
2034                         sym.SSYMTAB,
2035                         sym.SPCLNTAB,
2036                         sym.SINITARR,
2037                         sym.SDATA,
2038                         sym.SNOPTRDATA,
2039                         sym.SELFROSECT,
2040                         sym.SMACHOGOT,
2041                         sym.STYPE,
2042                         sym.SSTRING,
2043                         sym.SGOSTRING,
2044                         sym.SGOFUNC,
2045                         sym.SGCBITS,
2046                         sym.STYPERELRO,
2047                         sym.SSTRINGRELRO,
2048                         sym.SGOSTRINGRELRO,
2049                         sym.SGOFUNCRELRO,
2050                         sym.SGCBITSRELRO,
2051                         sym.SRODATARELRO,
2052                         sym.STYPELINK,
2053                         sym.SITABLINK,
2054                         sym.SWINDOWS:
2055                         if !s.Attr.Reachable() {
2056                                 continue
2057                         }
2058                         put(ctxt, s, s.Name, DataSym, Symaddr(s), s.Gotype)
2059
2060                 case sym.SBSS, sym.SNOPTRBSS:
2061                         if !s.Attr.Reachable() {
2062                                 continue
2063                         }
2064                         if len(s.P) > 0 {
2065                                 Errorf(s, "should not be bss (size=%d type=%v special=%v)", len(s.P), s.Type, s.Attr.Special())
2066                         }
2067                         put(ctxt, s, s.Name, BSSSym, Symaddr(s), s.Gotype)
2068
2069                 case sym.SHOSTOBJ:
2070                         if ctxt.HeadType == objabi.Hwindows || ctxt.IsELF {
2071                                 put(ctxt, s, s.Name, UndefinedSym, s.Value, nil)
2072                         }
2073
2074                 case sym.SDYNIMPORT:
2075                         if !s.Attr.Reachable() {
2076                                 continue
2077                         }
2078                         put(ctxt, s, s.Extname, UndefinedSym, 0, nil)
2079
2080                 case sym.STLSBSS:
2081                         if ctxt.LinkMode == LinkExternal {
2082                                 put(ctxt, s, s.Name, TLSSym, Symaddr(s), s.Gotype)
2083                         }
2084                 }
2085         }
2086
2087         var off int32
2088         for _, s := range ctxt.Textp {
2089                 put(ctxt, s, s.Name, TextSym, s.Value, s.Gotype)
2090
2091                 locals := int32(0)
2092                 if s.FuncInfo != nil {
2093                         locals = s.FuncInfo.Locals
2094                 }
2095                 // NOTE(ality): acid can't produce a stack trace without .frame symbols
2096                 put(ctxt, nil, ".frame", FrameSym, int64(locals)+int64(ctxt.Arch.PtrSize), nil)
2097
2098                 if s.FuncInfo == nil {
2099                         continue
2100                 }
2101                 for _, a := range s.FuncInfo.Autom {
2102                         if a.Name == objabi.A_DELETED_AUTO {
2103                                 put(ctxt, nil, "", DeletedAutoSym, 0, a.Gotype)
2104                                 continue
2105                         }
2106
2107                         // Emit a or p according to actual offset, even if label is wrong.
2108                         // This avoids negative offsets, which cannot be encoded.
2109                         if a.Name != objabi.A_AUTO && a.Name != objabi.A_PARAM {
2110                                 continue
2111                         }
2112
2113                         // compute offset relative to FP
2114                         if a.Name == objabi.A_PARAM {
2115                                 off = a.Aoffset
2116                         } else {
2117                                 off = a.Aoffset - int32(ctxt.Arch.PtrSize)
2118                         }
2119
2120                         // FP
2121                         if off >= 0 {
2122                                 put(ctxt, nil, a.Asym.Name, ParamSym, int64(off), a.Gotype)
2123                                 continue
2124                         }
2125
2126                         // SP
2127                         if off <= int32(-ctxt.Arch.PtrSize) {
2128                                 put(ctxt, nil, a.Asym.Name, AutoSym, -(int64(off) + int64(ctxt.Arch.PtrSize)), a.Gotype)
2129                                 continue
2130                         }
2131                         // Otherwise, off is addressing the saved program counter.
2132                         // Something underhanded is going on. Say nothing.
2133                 }
2134         }
2135
2136         if ctxt.Debugvlog != 0 || *flagN {
2137                 ctxt.Logf("%5.2f symsize = %d\n", Cputime(), uint32(Symsize))
2138         }
2139 }
2140
2141 func Symaddr(s *sym.Symbol) int64 {
2142         if !s.Attr.Reachable() {
2143                 Errorf(s, "unreachable symbol in symaddr")
2144         }
2145         return s.Value
2146 }
2147
2148 func (ctxt *Link) xdefine(p string, t sym.SymKind, v int64) {
2149         s := ctxt.Syms.Lookup(p, 0)
2150         s.Type = t
2151         s.Value = v
2152         s.Attr |= sym.AttrReachable
2153         s.Attr |= sym.AttrSpecial
2154         s.Attr |= sym.AttrLocal
2155 }
2156
2157 func datoff(s *sym.Symbol, addr int64) int64 {
2158         if uint64(addr) >= Segdata.Vaddr {
2159                 return int64(uint64(addr) - Segdata.Vaddr + Segdata.Fileoff)
2160         }
2161         if uint64(addr) >= Segtext.Vaddr {
2162                 return int64(uint64(addr) - Segtext.Vaddr + Segtext.Fileoff)
2163         }
2164         Errorf(s, "invalid datoff %#x", addr)
2165         return 0
2166 }
2167
2168 func Entryvalue(ctxt *Link) int64 {
2169         a := *flagEntrySymbol
2170         if a[0] >= '0' && a[0] <= '9' {
2171                 return atolwhex(a)
2172         }
2173         s := ctxt.Syms.Lookup(a, 0)
2174         if s.Type == 0 {
2175                 return *FlagTextAddr
2176         }
2177         if s.Type != sym.STEXT {
2178                 Errorf(s, "entry not text")
2179         }
2180         return s.Value
2181 }
2182
2183 func undefsym(ctxt *Link, s *sym.Symbol) {
2184         var r *sym.Reloc
2185
2186         for i := 0; i < len(s.R); i++ {
2187                 r = &s.R[i]
2188                 if r.Sym == nil { // happens for some external ARM relocs
2189                         continue
2190                 }
2191                 // TODO(mwhudson): the test of VisibilityHidden here probably doesn't make
2192                 // sense and should be removed when someone has thought about it properly.
2193                 if (r.Sym.Type == sym.Sxxx || r.Sym.Type == sym.SXREF) && !r.Sym.Attr.VisibilityHidden() {
2194                         Errorf(s, "undefined: %q", r.Sym.Name)
2195                 }
2196                 if !r.Sym.Attr.Reachable() && r.Type != objabi.R_WEAKADDROFF {
2197                         Errorf(s, "relocation target %q", r.Sym.Name)
2198                 }
2199         }
2200 }
2201
2202 func (ctxt *Link) undef() {
2203         // undefsym performs checks (almost) identical to checks
2204         // that report undefined relocations in relocsym.
2205         // Both undefsym and relocsym can report same symbol as undefined,
2206         // which results in error message duplication (see #10978).
2207         //
2208         // The undef is run after Arch.Asmb and could detect some
2209         // programming errors there, but if object being linked is already
2210         // failed with errors, it is better to avoid duplicated errors.
2211         if nerrors > 0 {
2212                 return
2213         }
2214
2215         for _, s := range ctxt.Textp {
2216                 undefsym(ctxt, s)
2217         }
2218         for _, s := range datap {
2219                 undefsym(ctxt, s)
2220         }
2221         if nerrors > 0 {
2222                 errorexit()
2223         }
2224 }
2225
2226 func (ctxt *Link) callgraph() {
2227         if !*FlagC {
2228                 return
2229         }
2230
2231         var i int
2232         var r *sym.Reloc
2233         for _, s := range ctxt.Textp {
2234                 for i = 0; i < len(s.R); i++ {
2235                         r = &s.R[i]
2236                         if r.Sym == nil {
2237                                 continue
2238                         }
2239                         if (r.Type == objabi.R_CALL || r.Type == objabi.R_CALLARM || r.Type == objabi.R_CALLPOWER || r.Type == objabi.R_CALLMIPS) && r.Sym.Type == sym.STEXT {
2240                                 ctxt.Logf("%s calls %s\n", s.Name, r.Sym.Name)
2241                         }
2242                 }
2243         }
2244 }
2245
2246 func Rnd(v int64, r int64) int64 {
2247         if r <= 0 {
2248                 return v
2249         }
2250         v += r - 1
2251         c := v % r
2252         if c < 0 {
2253                 c += r
2254         }
2255         v -= c
2256         return v
2257 }
2258
2259 func bgetc(r *bio.Reader) int {
2260         c, err := r.ReadByte()
2261         if err != nil {
2262                 if err != io.EOF {
2263                         log.Fatalf("reading input: %v", err)
2264                 }
2265                 return -1
2266         }
2267         return int(c)
2268 }
2269
2270 type markKind uint8 // for postorder traversal
2271 const (
2272         _ markKind = iota
2273         visiting
2274         visited
2275 )
2276
2277 func postorder(libs []*sym.Library) []*sym.Library {
2278         order := make([]*sym.Library, 0, len(libs)) // hold the result
2279         mark := make(map[*sym.Library]markKind, len(libs))
2280         for _, lib := range libs {
2281                 dfs(lib, mark, &order)
2282         }
2283         return order
2284 }
2285
2286 func dfs(lib *sym.Library, mark map[*sym.Library]markKind, order *[]*sym.Library) {
2287         if mark[lib] == visited {
2288                 return
2289         }
2290         if mark[lib] == visiting {
2291                 panic("found import cycle while visiting " + lib.Pkg)
2292         }
2293         mark[lib] = visiting
2294         for _, i := range lib.Imports {
2295                 dfs(i, mark, order)
2296         }
2297         mark[lib] = visited
2298         *order = append(*order, lib)
2299 }