1 // Inferno utils/8l/asm.c
2 // https://bitbucket.org/inferno-os/inferno-os/src/master/utils/8l/asm.c
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.
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:
20 // The above copyright notice and this permission notice shall be included in
21 // all copies or substantial portions of the Software.
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
53 "cmd/internal/notsha256"
56 "cmd/link/internal/loadelf"
57 "cmd/link/internal/loader"
58 "cmd/link/internal/loadmacho"
59 "cmd/link/internal/loadpe"
60 "cmd/link/internal/loadxcoff"
61 "cmd/link/internal/sym"
64 // Data layout and relocation.
66 // Derived from Inferno utils/6l/l.h
67 // https://bitbucket.org/inferno-os/inferno-os/src/master/utils/6l/l.h
69 // Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved.
70 // Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
71 // Portions Copyright © 1997-1999 Vita Nuova Limited
72 // Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
73 // Portions Copyright © 2004,2006 Bruce Ellis
74 // Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
75 // Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
76 // Portions Copyright © 2009 The Go Authors. All rights reserved.
78 // Permission is hereby granted, free of charge, to any person obtaining a copy
79 // of this software and associated documentation files (the "Software"), to deal
80 // in the Software without restriction, including without limitation the rights
81 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
82 // copies of the Software, and to permit persons to whom the Software is
83 // furnished to do so, subject to the following conditions:
85 // The above copyright notice and this permission notice shall be included in
86 // all copies or substantial portions of the Software.
88 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
89 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
90 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
91 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
92 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
93 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
96 // ArchSyms holds a number of architecture specific symbols used during
97 // relocation. Rather than allowing them universal access to all symbols,
98 // we keep a subset for relocation application.
99 type ArchSyms struct {
105 LinkEditGOT loader.Sym
106 LinkEditPLT loader.Sym
109 DotTOC []loader.Sym // for each version
122 unreachableMethod loader.Sym
124 // Symbol containing a list of all the inittasks that need
125 // to be run at startup.
126 mainInittasks loader.Sym
129 // mkArchSym is a helper for setArchSyms, to set up a special symbol.
130 func (ctxt *Link) mkArchSym(name string, ver int, ls *loader.Sym) {
131 *ls = ctxt.loader.LookupOrCreateSym(name, ver)
132 ctxt.loader.SetAttrReachable(*ls, true)
135 // mkArchSymVec is similar to setArchSyms, but operates on elements within
136 // a slice, where each element corresponds to some symbol version.
137 func (ctxt *Link) mkArchSymVec(name string, ver int, ls []loader.Sym) {
138 ls[ver] = ctxt.loader.LookupOrCreateSym(name, ver)
139 ctxt.loader.SetAttrReachable(ls[ver], true)
142 // setArchSyms sets up the ArchSyms structure, and must be called before
143 // relocations are applied.
144 func (ctxt *Link) setArchSyms() {
145 ctxt.mkArchSym(".got", 0, &ctxt.GOT)
146 ctxt.mkArchSym(".plt", 0, &ctxt.PLT)
147 ctxt.mkArchSym(".got.plt", 0, &ctxt.GOTPLT)
148 ctxt.mkArchSym(".dynamic", 0, &ctxt.Dynamic)
149 ctxt.mkArchSym(".dynsym", 0, &ctxt.DynSym)
150 ctxt.mkArchSym(".dynstr", 0, &ctxt.DynStr)
151 ctxt.mkArchSym("runtime.unreachableMethod", abiInternalVer, &ctxt.unreachableMethod)
154 ctxt.mkArchSym("TOC", 0, &ctxt.TOC)
156 ctxt.DotTOC = make([]loader.Sym, ctxt.MaxVersion()+1)
157 for i := 0; i <= ctxt.MaxVersion(); i++ {
158 if i >= sym.SymVerABICount && i < sym.SymVerStatic { // these versions are not used currently
161 ctxt.mkArchSymVec(".TOC.", i, ctxt.DotTOC)
165 ctxt.mkArchSym(".rel", 0, &ctxt.Rel)
166 ctxt.mkArchSym(".rela", 0, &ctxt.Rela)
167 ctxt.mkArchSym(".rel.plt", 0, &ctxt.RelPLT)
168 ctxt.mkArchSym(".rela.plt", 0, &ctxt.RelaPLT)
171 ctxt.mkArchSym(".linkedit.got", 0, &ctxt.LinkEditGOT)
172 ctxt.mkArchSym(".linkedit.plt", 0, &ctxt.LinkEditPLT)
183 // Threshold of total text size, used for trampoline insertion. If the total
184 // text size is smaller than TrampLimit, we won't need to insert trampolines.
185 // It is pretty close to the offset range of a direct CALL machine instruction.
186 // We leave some room for extra stuff like PLT stubs.
189 // Empty spaces between codeblocks will be padded with this value.
190 // For example an architecture might want to pad with a trap instruction to
191 // catch wayward programs. Architectures that do not define a padding value
192 // are padded with zeros.
199 Adddynrel func(*Target, *loader.Loader, *ArchSyms, loader.Sym, loader.Reloc, int) bool
201 // Archreloc is an arch-specific hook that assists in relocation processing
202 // (invoked by 'relocsym'); it handles target-specific relocation tasks.
203 // Here "rel" is the current relocation being examined, "sym" is the symbol
204 // containing the chunk of data to which the relocation applies, and "off"
205 // is the contents of the to-be-relocated data item (from sym.P). Return
206 // value is the appropriately relocated value (to be written back to the
207 // same spot in sym.P), number of external _host_ relocations needed (i.e.
208 // ELF/Mach-O/etc. relocations, not Go relocations, this must match ELF.Reloc1,
209 // etc.), and a boolean indicating success/failure (a failing value indicates
211 Archreloc func(*Target, *loader.Loader, *ArchSyms, loader.Reloc, loader.Sym,
212 int64) (relocatedOffset int64, nExtReloc int, ok bool)
213 // Archrelocvariant is a second arch-specific hook used for
214 // relocation processing; it handles relocations where r.Type is
215 // insufficient to describe the relocation (r.Variant !=
216 // sym.RV_NONE). Here "rel" is the relocation being applied, "sym"
217 // is the symbol containing the chunk of data to which the
218 // relocation applies, and "off" is the contents of the
219 // to-be-relocated data item (from sym.P). Return is an updated
221 Archrelocvariant func(target *Target, ldr *loader.Loader, rel loader.Reloc,
222 rv sym.RelocVariant, sym loader.Sym, offset int64, data []byte) (relocatedOffset int64)
224 // Generate a trampoline for a call from s to rs if necessary. ri is
225 // index of the relocation.
226 Trampoline func(ctxt *Link, ldr *loader.Loader, ri int, rs, s loader.Sym)
228 // Assembling the binary breaks into two phases, writing the code/data/
229 // dwarf information (which is rather generic), and some more architecture
230 // specific work like setting up the elf headers/dynamic relocations, etc.
231 // The phases are called "Asmb" and "Asmb2". Asmb2 needs to be defined for
232 // every architecture, but only if architecture has an Asmb function will
233 // it be used for assembly. Otherwise a generic assembly Asmb function is
235 Asmb func(*Link, *loader.Loader)
236 Asmb2 func(*Link, *loader.Loader)
238 // Extreloc is an arch-specific hook that converts a Go relocation to an
239 // external relocation. Return the external relocation and whether it is
241 Extreloc func(*Target, *loader.Loader, loader.Reloc, loader.Sym) (loader.ExtReloc, bool)
243 Gentext func(*Link, *loader.Loader) // Generate text before addressing has been performed.
244 Machoreloc1 func(*sys.Arch, *OutBuf, *loader.Loader, loader.Sym, loader.ExtReloc, int64) bool
245 MachorelocSize uint32 // size of an Mach-O relocation record, must match Machoreloc1.
246 PEreloc1 func(*sys.Arch, *OutBuf, *loader.Loader, loader.Sym, loader.ExtReloc, int64) bool
247 Xcoffreloc1 func(*sys.Arch, *OutBuf, *loader.Loader, loader.Sym, loader.ExtReloc, int64) bool
249 // Generate additional symbols for the native symbol table just prior to
251 GenSymsLate func(*Link, *loader.Loader)
253 // TLSIEtoLE converts a TLS Initial Executable relocation to
254 // a TLS Local Executable relocation.
256 // This is possible when a TLS IE relocation refers to a local
257 // symbol in an executable, which is typical when internally
258 // linking PIE binaries.
259 TLSIEtoLE func(P []byte, off, size int)
261 // optional override for assignAddress
262 AssignAddress func(ldr *loader.Loader, sect *sym.Section, n int, s loader.Sym, va uint64, isTramp bool) (*sym.Section, int, uint64)
264 // ELF specific information.
277 MINFUNC = 16 // minimum size for a function
280 // Symbol version of ABIInternal symbols. It is sym.SymVerABIInternal if ABI wrappers
281 // are used, 0 otherwise.
282 var abiInternalVer = sym.SymVerABIInternal
284 // DynlinkingGo reports whether we are producing Go code that can live
285 // in separate shared libraries linked together at runtime.
286 func (ctxt *Link) DynlinkingGo() bool {
288 panic("DynlinkingGo called before all symbols loaded")
290 return ctxt.BuildMode == BuildModeShared || ctxt.linkShared || ctxt.BuildMode == BuildModePlugin || ctxt.canUsePlugins
293 // CanUsePlugins reports whether a plugins can be used
294 func (ctxt *Link) CanUsePlugins() bool {
296 panic("CanUsePlugins called before all symbols loaded")
298 return ctxt.canUsePlugins
301 // NeedCodeSign reports whether we need to code-sign the output binary.
302 func (ctxt *Link) NeedCodeSign() bool {
303 return ctxt.IsDarwin() && ctxt.IsARM64()
315 debug_s bool // backup old value of debug['s']
319 liveness int64 // size of liveness data (funcdata), printed if -v
321 // See -strictdups command line flag.
322 checkStrictDups int // 0=off 1=warning 2=error
323 strictDupMsgCount int
328 Segrodata sym.Segment
329 Segrelrodata sym.Segment
332 Segpdata sym.Segment // windows-only
333 Segxdata sym.Segment // windows-only
335 Segments = []*sym.Segment{&Segtext, &Segrodata, &Segrelrodata, &Segdata, &Segdwarf, &Segpdata, &Segxdata}
338 const pkgdef = "__.PKGDEF"
341 // externalobj is set to true if we see an object compiled by
342 // the host compiler that is not from a package that is known
343 // to support internal linking mode.
346 // dynimportfail is a list of packages for which generating
347 // the dynimport file, _cgo_import.go, failed. If there are
348 // any of these objects, we must link externally. Issue 52863.
349 dynimportfail []string
351 // preferlinkext is a list of packages for which the Go command
352 // noticed use of peculiar C flags. If we see any of these,
353 // default to linking externally unless overridden by the
354 // user. See issues #58619, #58620, and #58848.
355 preferlinkext []string
357 // unknownObjFormat is set to true if we see an object whose
358 // format we don't recognize.
359 unknownObjFormat = false
364 func Lflag(ctxt *Link, arg string) {
365 ctxt.Libdir = append(ctxt.Libdir, arg)
369 * Unix doesn't like it when we write to a running (or, sometimes,
370 * recently run) binary, so remove the output file before writing it.
371 * On Windows 7, remove() can force a subsequent create() to fail.
372 * S_ISREG() does not exist on Plan 9.
374 func mayberemoveoutfile() {
375 if fi, err := os.Lstat(*flagOutfile); err == nil && !fi.Mode().IsRegular() {
378 os.Remove(*flagOutfile)
381 func libinit(ctxt *Link) {
382 Funcalign = thearch.Funcalign
384 // add goroot to the end of the libdir list.
388 if *flagInstallSuffix != "" {
390 suffix = *flagInstallSuffix
391 } else if *flagRace {
394 } else if *flagMsan {
397 } else if *flagAsan {
402 if buildcfg.GOROOT != "" {
403 Lflag(ctxt, filepath.Join(buildcfg.GOROOT, "pkg", fmt.Sprintf("%s_%s%s%s", buildcfg.GOOS, buildcfg.GOARCH, suffixsep, suffix)))
408 if err := ctxt.Out.Open(*flagOutfile); err != nil {
409 Exitf("cannot create %s: %v", *flagOutfile, err)
412 if *flagEntrySymbol == "" {
413 switch ctxt.BuildMode {
414 case BuildModeCShared, BuildModeCArchive:
415 *flagEntrySymbol = fmt.Sprintf("_rt0_%s_%s_lib", buildcfg.GOARCH, buildcfg.GOOS)
416 case BuildModeExe, BuildModePIE:
417 *flagEntrySymbol = fmt.Sprintf("_rt0_%s_%s", buildcfg.GOARCH, buildcfg.GOOS)
418 case BuildModeShared, BuildModePlugin:
419 // No *flagEntrySymbol for -buildmode=shared and plugin
421 Errorf(nil, "unknown *flagEntrySymbol for buildmode %v", ctxt.BuildMode)
426 func exitIfErrors() {
427 if nerrors != 0 || checkStrictDups > 1 && strictDupMsgCount > 0 {
439 func loadinternal(ctxt *Link, name string) *sym.Library {
440 zerofp := goobj.FingerprintType{}
441 if ctxt.linkShared && ctxt.PackageShlib != nil {
442 if shlib := ctxt.PackageShlib[name]; shlib != "" {
443 return addlibpath(ctxt, "internal", "internal", "", name, shlib, zerofp)
446 if ctxt.PackageFile != nil {
447 if pname := ctxt.PackageFile[name]; pname != "" {
448 return addlibpath(ctxt, "internal", "internal", pname, name, "", zerofp)
450 ctxt.Logf("loadinternal: cannot find %s\n", name)
454 for _, libdir := range ctxt.Libdir {
456 shlibname := filepath.Join(libdir, name+".shlibname")
457 if ctxt.Debugvlog != 0 {
458 ctxt.Logf("searching for %s.a in %s\n", name, shlibname)
460 if _, err := os.Stat(shlibname); err == nil {
461 return addlibpath(ctxt, "internal", "internal", "", name, shlibname, zerofp)
464 pname := filepath.Join(libdir, name+".a")
465 if ctxt.Debugvlog != 0 {
466 ctxt.Logf("searching for %s.a in %s\n", name, pname)
468 if _, err := os.Stat(pname); err == nil {
469 return addlibpath(ctxt, "internal", "internal", pname, name, "", zerofp)
473 if name == "runtime" {
474 Exitf("error: unable to find runtime.a")
476 ctxt.Logf("warning: unable to find %s.a\n", name)
480 // extld returns the current external linker.
481 func (ctxt *Link) extld() []string {
482 if len(flagExtld) == 0 {
483 // Return the default external linker for the platform.
484 // This only matters when link tool is called directly without explicit -extld,
485 // go tool already passes the correct linker in other cases.
486 switch buildcfg.GOOS {
487 case "darwin", "freebsd", "openbsd":
488 flagExtld = []string{"clang"}
490 flagExtld = []string{"gcc"}
496 // findLibPathCmd uses cmd command to find gcc library libname.
497 // It returns library full path if found, or "none" if not found.
498 func (ctxt *Link) findLibPathCmd(cmd, libname string) string {
499 extld := ctxt.extld()
500 name, args := extld[0], extld[1:]
501 args = append(args, hostlinkArchArgs(ctxt.Arch)...)
502 args = append(args, cmd)
503 if ctxt.Debugvlog != 0 {
504 ctxt.Logf("%s %v\n", extld, args)
506 out, err := exec.Command(name, args...).Output()
508 if ctxt.Debugvlog != 0 {
509 ctxt.Logf("not using a %s file because compiler failed\n%v\n%s\n", libname, err, out)
513 return strings.TrimSpace(string(out))
516 // findLibPath searches for library libname.
517 // It returns library full path if found, or "none" if not found.
518 func (ctxt *Link) findLibPath(libname string) string {
519 return ctxt.findLibPathCmd("--print-file-name="+libname, libname)
522 func (ctxt *Link) loadlib() {
524 switch *FlagStrictDups {
528 flags |= loader.FlagStrictDups
530 log.Fatalf("invalid -strictdups flag value %d", *FlagStrictDups)
532 ctxt.loader = loader.NewLoader(flags, &ctxt.ErrorReporter.ErrorReporter)
533 ctxt.ErrorReporter.SymName = func(s loader.Sym) string {
534 return ctxt.loader.SymName(s)
537 // ctxt.Library grows during the loop, so not a range loop.
539 for ; i < len(ctxt.Library); i++ {
540 lib := ctxt.Library[i]
542 if ctxt.Debugvlog > 1 {
543 ctxt.Logf("autolib: %s (from %s)\n", lib.File, lib.Objref)
545 loadobjfile(ctxt, lib)
549 // load internal packages, if not already
551 loadinternal(ctxt, "runtime/race")
554 loadinternal(ctxt, "runtime/msan")
557 loadinternal(ctxt, "runtime/asan")
559 loadinternal(ctxt, "runtime")
560 for ; i < len(ctxt.Library); i++ {
561 lib := ctxt.Library[i]
563 loadobjfile(ctxt, lib)
566 // At this point, the Go objects are "preloaded". Not all the symbols are
567 // added to the symbol table (only defined package symbols are). Looking
568 // up symbol by name may not get expected result.
570 iscgo = ctxt.LibraryByPkg["runtime/cgo"] != nil
572 // Plugins a require cgo support to function. Similarly, plugins may require additional
573 // internal linker support on some platforms which may not be implemented.
574 ctxt.canUsePlugins = ctxt.LibraryByPkg["plugin"] != nil && iscgo
576 // We now have enough information to determine the link mode.
577 determineLinkMode(ctxt)
579 if ctxt.LinkMode == LinkExternal && !iscgo && !(buildcfg.GOOS == "darwin" && ctxt.BuildMode != BuildModePlugin && ctxt.Arch.Family == sys.AMD64) {
580 // This indicates a user requested -linkmode=external.
581 // The startup code uses an import of runtime/cgo to decide
582 // whether to initialize the TLS. So give it one. This could
583 // be handled differently but it's an unusual case.
584 if lib := loadinternal(ctxt, "runtime/cgo"); lib != nil && lib.Shlib == "" {
585 if ctxt.BuildMode == BuildModeShared || ctxt.linkShared {
586 Exitf("cannot implicitly include runtime/cgo in a shared library")
588 for ; i < len(ctxt.Library); i++ {
589 lib := ctxt.Library[i]
591 loadobjfile(ctxt, lib)
597 // Add non-package symbols and references of externally defined symbols.
598 ctxt.loader.LoadSyms(ctxt.Arch)
600 // Load symbols from shared libraries, after all Go object symbols are loaded.
601 for _, lib := range ctxt.Library {
603 if ctxt.Debugvlog > 1 {
604 ctxt.Logf("autolib: %s (from %s)\n", lib.Shlib, lib.Objref)
606 ldshlibsyms(ctxt, lib.Shlib)
610 // Process cgo directives (has to be done before host object loading).
611 ctxt.loadcgodirectives()
613 // Conditionally load host objects, or setup for external linking.
617 if ctxt.LinkMode == LinkInternal && len(hostobj) != 0 {
618 // If we have any undefined symbols in external
619 // objects, try to read them from the libgcc file.
621 undefs, froms := ctxt.loader.UndefinedRelocTargets(1)
624 if ctxt.Debugvlog > 1 {
625 ctxt.Logf("loadlib: first unresolved is %s [%d] from %s [%d]\n",
626 ctxt.loader.SymName(undefs[0]), undefs[0],
627 ctxt.loader.SymName(froms[0]), froms[0])
631 if *flagLibGCC == "" {
632 *flagLibGCC = ctxt.findLibPathCmd("--print-libgcc-file-name", "libgcc")
634 if runtime.GOOS == "openbsd" && *flagLibGCC == "libgcc.a" {
635 // On OpenBSD `clang --print-libgcc-file-name` returns "libgcc.a".
636 // In this case we fail to load libgcc.a and can encounter link
637 // errors - see if we can find libcompiler_rt.a instead.
638 *flagLibGCC = ctxt.findLibPathCmd("--print-file-name=libcompiler_rt.a", "libcompiler_rt")
640 if ctxt.HeadType == objabi.Hwindows {
641 loadWindowsHostArchives(ctxt)
643 if *flagLibGCC != "none" {
644 hostArchive(ctxt, *flagLibGCC)
646 // For glibc systems, the linker setup used by GCC
649 // GROUP ( /lib/x86_64-linux-gnu/libc.so.6
650 // /usr/lib/x86_64-linux-gnu/libc_nonshared.a
651 // AS_NEEDED ( /lib64/ld-linux-x86-64.so.2 ) )
653 // where libc_nonshared.a contains a small set of
654 // symbols including "__stack_chk_fail_local" and a
655 // few others. Thus if we are doing internal linking
656 // and "__stack_chk_fail_local" is unresolved (most
657 // likely due to the use of -fstack-protector), try
658 // loading libc_nonshared.a to resolve it.
660 // On Alpine Linux (musl-based), the library providing
661 // this symbol is called libssp_nonshared.a.
662 isunresolved := symbolsAreUnresolved(ctxt, []string{"__stack_chk_fail_local"})
664 if p := ctxt.findLibPath("libc_nonshared.a"); p != "none" {
667 if p := ctxt.findLibPath("libssp_nonshared.a"); p != "none" {
674 // We've loaded all the code now.
677 strictDupMsgCount = ctxt.loader.NStrictDupMsgs()
680 // loadWindowsHostArchives loads in host archives and objects when
681 // doing internal linking on windows. Older toolchains seem to require
682 // just a single pass through the various archives, but some modern
683 // toolchains when linking a C program with mingw pass library paths
684 // multiple times to the linker, e.g. "... -lmingwex -lmingw32 ...
685 // -lmingwex -lmingw32 ...". To accommodate this behavior, we make two
686 // passes over the host archives below.
687 func loadWindowsHostArchives(ctxt *Link) {
689 for i := 0; any && i < 2; i++ {
690 // Link crt2.o (if present) to resolve "atexit" when
691 // using LLVM-based compilers.
692 isunresolved := symbolsAreUnresolved(ctxt, []string{"atexit"})
694 if p := ctxt.findLibPath("crt2.o"); p != "none" {
695 hostObject(ctxt, "crt2", p)
699 if p := ctxt.findLibPath("libsynchronization.a"); p != "none" {
703 if p := ctxt.findLibPath("libmingwex.a"); p != "none" {
706 if p := ctxt.findLibPath("libmingw32.a"); p != "none" {
709 // Link libmsvcrt.a to resolve '__acrt_iob_func' symbol
710 // (see https://golang.org/issue/23649 for details).
711 if p := ctxt.findLibPath("libmsvcrt.a"); p != "none" {
715 undefs, froms := ctxt.loader.UndefinedRelocTargets(1)
718 if ctxt.Debugvlog > 1 {
719 ctxt.Logf("loadWindowsHostArchives: remaining unresolved is %s [%d] from %s [%d]\n",
720 ctxt.loader.SymName(undefs[0]), undefs[0],
721 ctxt.loader.SymName(froms[0]), froms[0])
725 // If needed, create the __CTOR_LIST__ and __DTOR_LIST__
726 // symbols (referenced by some of the mingw support library
727 // routines). Creation of these symbols is normally done by the
728 // linker if not already present.
729 want := []string{"__CTOR_LIST__", "__DTOR_LIST__"}
730 isunresolved := symbolsAreUnresolved(ctxt, want)
731 for k, w := range want {
733 sb := ctxt.loader.CreateSymForUpdate(w, 0)
734 sb.SetType(sym.SDATA)
735 sb.AddUint64(ctxt.Arch, 0)
736 sb.SetReachable(true)
737 ctxt.loader.SetAttrSpecial(sb.Sym(), true)
741 // Fix up references to DLL import symbols now that we're done
742 // pulling in new objects.
743 if err := loadpe.PostProcessImports(); err != nil {
744 Errorf(nil, "%v", err)
747 // TODO: maybe do something similar to peimporteddlls to collect
748 // all lib names and try link them all to final exe just like
749 // libmingwex.a and libmingw32.a:
752 #cgo windows LDFLAGS: -lmsvcrt -lm
758 // loadcgodirectives reads the previously discovered cgo directives, creating
759 // symbols in preparation for host object loading or use later in the link.
760 func (ctxt *Link) loadcgodirectives() {
762 hostObjSyms := make(map[loader.Sym]struct{})
763 for _, d := range ctxt.cgodata {
764 setCgoAttr(ctxt, d.file, d.pkg, d.directives, hostObjSyms)
768 if ctxt.LinkMode == LinkInternal {
769 // Drop all the cgo_import_static declarations.
770 // Turns out we won't be needing them.
771 for symIdx := range hostObjSyms {
772 if l.SymType(symIdx) == sym.SHOSTOBJ {
773 // If a symbol was marked both
774 // cgo_import_static and cgo_import_dynamic,
775 // then we want to make it cgo_import_dynamic
777 su := l.MakeSymbolUpdater(symIdx)
778 if l.SymExtname(symIdx) != "" && l.SymDynimplib(symIdx) != "" && !(l.AttrCgoExportStatic(symIdx) || l.AttrCgoExportDynamic(symIdx)) {
779 su.SetType(sym.SDYNIMPORT)
788 // Set up flags and special symbols depending on the platform build mode.
789 // This version works with loader.Loader.
790 func (ctxt *Link) linksetup() {
791 switch ctxt.BuildMode {
792 case BuildModeCShared, BuildModePlugin:
793 symIdx := ctxt.loader.LookupOrCreateSym("runtime.islibrary", 0)
794 sb := ctxt.loader.MakeSymbolUpdater(symIdx)
795 sb.SetType(sym.SNOPTRDATA)
797 case BuildModeCArchive:
798 symIdx := ctxt.loader.LookupOrCreateSym("runtime.isarchive", 0)
799 sb := ctxt.loader.MakeSymbolUpdater(symIdx)
800 sb.SetType(sym.SNOPTRDATA)
804 // Recalculate pe parameters now that we have ctxt.LinkMode set.
805 if ctxt.HeadType == objabi.Hwindows {
809 if ctxt.LinkMode == LinkExternal {
810 // When external linking, we are creating an object file. The
811 // absolute address is irrelevant.
815 // If there are no dynamic libraries needed, gcc disables dynamic linking.
816 // Because of this, glibc's dynamic ELF loader occasionally (like in version 2.13)
817 // assumes that a dynamic binary always refers to at least one dynamic library.
818 // Rather than be a source of test cases for glibc, disable dynamic linking
819 // the same way that gcc would.
821 // Exception: on OS X, programs such as Shark only work with dynamic
822 // binaries, so leave it enabled on OS X (Mach-O) binaries.
823 // Also leave it enabled on Solaris which doesn't support
824 // statically linked binaries.
825 if ctxt.BuildMode == BuildModeExe {
826 if havedynamic == 0 && ctxt.HeadType != objabi.Hdarwin && ctxt.HeadType != objabi.Hsolaris {
831 if ctxt.LinkMode == LinkExternal && ctxt.Arch.Family == sys.PPC64 && buildcfg.GOOS != "aix" {
832 toc := ctxt.loader.LookupOrCreateSym(".TOC.", 0)
833 sb := ctxt.loader.MakeSymbolUpdater(toc)
834 sb.SetType(sym.SDYNIMPORT)
837 // The Android Q linker started to complain about underalignment of the our TLS
838 // section. We don't actually use the section on android, so don't
840 if buildcfg.GOOS != "android" {
841 tlsg := ctxt.loader.LookupOrCreateSym("runtime.tlsg", 0)
842 sb := ctxt.loader.MakeSymbolUpdater(tlsg)
844 // runtime.tlsg is used for external linking on platforms that do not define
845 // a variable to hold g in assembly (currently only intel).
847 sb.SetType(sym.STLSBSS)
848 sb.SetSize(int64(ctxt.Arch.PtrSize))
849 } else if sb.Type() != sym.SDYNIMPORT {
850 Errorf(nil, "runtime declared tlsg variable %v", sb.Type())
852 ctxt.loader.SetAttrReachable(tlsg, true)
856 var moduledata loader.Sym
857 var mdsb *loader.SymbolBuilder
858 if ctxt.BuildMode == BuildModePlugin {
859 moduledata = ctxt.loader.LookupOrCreateSym("local.pluginmoduledata", 0)
860 mdsb = ctxt.loader.MakeSymbolUpdater(moduledata)
861 ctxt.loader.SetAttrLocal(moduledata, true)
863 moduledata = ctxt.loader.LookupOrCreateSym("runtime.firstmoduledata", 0)
864 mdsb = ctxt.loader.MakeSymbolUpdater(moduledata)
866 if mdsb.Type() != 0 && mdsb.Type() != sym.SDYNIMPORT {
867 // If the module (toolchain-speak for "executable or shared
868 // library") we are linking contains the runtime package, it
869 // will define the runtime.firstmoduledata symbol and we
870 // truncate it back to 0 bytes so we can define its entire
871 // contents in symtab.go:symtab().
874 // In addition, on ARM, the runtime depends on the linker
875 // recording the value of GOARM.
876 if ctxt.Arch.Family == sys.ARM {
877 goarm := ctxt.loader.LookupOrCreateSym("runtime.goarm", 0)
878 sb := ctxt.loader.MakeSymbolUpdater(goarm)
879 sb.SetType(sym.SDATA)
881 sb.AddUint8(uint8(buildcfg.GOARM))
884 // Set runtime.disableMemoryProfiling bool if
885 // runtime.MemProfile is not retained in the binary after
886 // deadcode (and we're not dynamically linking).
887 memProfile := ctxt.loader.Lookup("runtime.MemProfile", abiInternalVer)
888 if memProfile != 0 && !ctxt.loader.AttrReachable(memProfile) && !ctxt.DynlinkingGo() {
889 memProfSym := ctxt.loader.LookupOrCreateSym("runtime.disableMemoryProfiling", 0)
890 sb := ctxt.loader.MakeSymbolUpdater(memProfSym)
891 sb.SetType(sym.SDATA)
893 sb.AddUint8(1) // true bool
896 // If OTOH the module does not contain the runtime package,
897 // create a local symbol for the moduledata.
898 moduledata = ctxt.loader.LookupOrCreateSym("local.moduledata", 0)
899 mdsb = ctxt.loader.MakeSymbolUpdater(moduledata)
900 ctxt.loader.SetAttrLocal(moduledata, true)
902 // In all cases way we mark the moduledata as noptrdata to hide it from
904 mdsb.SetType(sym.SNOPTRDATA)
905 ctxt.loader.SetAttrReachable(moduledata, true)
906 ctxt.Moduledata = moduledata
908 if ctxt.Arch == sys.Arch386 && ctxt.HeadType != objabi.Hwindows {
909 if (ctxt.BuildMode == BuildModeCArchive && ctxt.IsELF) || ctxt.BuildMode == BuildModeCShared || ctxt.BuildMode == BuildModePIE || ctxt.DynlinkingGo() {
910 got := ctxt.loader.LookupOrCreateSym("_GLOBAL_OFFSET_TABLE_", 0)
911 sb := ctxt.loader.MakeSymbolUpdater(got)
912 sb.SetType(sym.SDYNIMPORT)
913 ctxt.loader.SetAttrReachable(got, true)
917 // DWARF-gen and other phases require that the unit Textp slices
918 // be populated, so that it can walk the functions in each unit.
919 // Call into the loader to do this (requires that we collect the
920 // set of internal libraries first). NB: might be simpler if we
921 // moved isRuntimeDepPkg to cmd/internal and then did the test in
922 // loader.AssignTextSymbolOrder.
923 ctxt.Library = postorder(ctxt.Library)
925 for _, lib := range ctxt.Library {
926 intlibs = append(intlibs, isRuntimeDepPkg(lib.Pkg))
928 ctxt.Textp = ctxt.loader.AssignTextSymbolOrder(ctxt.Library, intlibs, ctxt.Textp)
931 // mangleTypeSym shortens the names of symbols that represent Go types
932 // if they are visible in the symbol table.
934 // As the names of these symbols are derived from the string of
935 // the type, they can run to many kilobytes long. So we shorten
936 // them using a SHA-1 when the name appears in the final binary.
937 // This also removes characters that upset external linkers.
939 // These are the symbols that begin with the prefix 'type.' and
940 // contain run-time type information used by the runtime and reflect
941 // packages. All Go binaries contain these symbols, but only
942 // those programs loaded dynamically in multiple parts need these
943 // symbols to have entries in the symbol table.
944 func (ctxt *Link) mangleTypeSym() {
945 if ctxt.BuildMode != BuildModeShared && !ctxt.linkShared && ctxt.BuildMode != BuildModePlugin && !ctxt.CanUsePlugins() {
950 for s := loader.Sym(1); s < loader.Sym(ldr.NSym()); s++ {
951 if !ldr.AttrReachable(s) && !ctxt.linkShared {
952 // If -linkshared, the GCProg generation code may need to reach
953 // out to the shared library for the type descriptor's data, even
954 // the type descriptor itself is not actually needed at run time
955 // (therefore not reachable). We still need to mangle its name,
956 // so it is consistent with the one stored in the shared library.
959 name := ldr.SymName(s)
960 newName := typeSymbolMangle(name)
962 ldr.SetSymExtname(s, newName)
964 // When linking against a shared library, the Go object file may
965 // have reference to the original symbol name whereas the shared
966 // library provides a symbol with the mangled name. We need to
967 // copy the payload of mangled to original.
968 // XXX maybe there is a better way to do this.
969 dup := ldr.Lookup(newName, ldr.SymVersion(s))
972 dt := ldr.SymType(dup)
973 if st == sym.Sxxx && dt != sym.Sxxx {
981 // typeSymbolMangle mangles the given symbol name into something shorter.
983 // Keep the type:. prefix, which parts of the linker (like the
984 // DWARF generator) know means the symbol is not decodable.
985 // Leave type:runtime. symbols alone, because other parts of
986 // the linker manipulates them.
987 func typeSymbolMangle(name string) string {
988 isType := strings.HasPrefix(name, "type:")
989 if !isType && !strings.Contains(name, "@") {
990 // Issue 58800: instantiated symbols may include a type name, which may contain "@"
993 if strings.HasPrefix(name, "type:runtime.") {
996 if strings.HasPrefix(name, "go:string.") {
997 // String symbols will be grouped to a single go:string.* symbol.
998 // No need to mangle individual symbol names.
1001 if len(name) <= 14 && !strings.Contains(name, "@") { // Issue 19529
1005 hash := notsha256.Sum256([]byte(name[5:]))
1010 return prefix + base64.StdEncoding.EncodeToString(hash[:6])
1012 // instantiated symbol, replace type name in []
1013 i := strings.IndexByte(name, '[')
1014 j := strings.LastIndexByte(name, ']')
1015 if j == -1 || j <= i {
1018 hash := notsha256.Sum256([]byte(name[i+1 : j]))
1019 return name[:i+1] + base64.StdEncoding.EncodeToString(hash[:6]) + name[j:]
1023 * look for the next file in an archive.
1024 * adapted from libmach.
1026 func nextar(bp *bio.Reader, off int64, a *ArHdr) int64 {
1031 var buf [SAR_HDR]byte
1032 if n, err := io.ReadFull(bp, buf[:]); err != nil {
1033 if n == 0 && err != io.EOF {
1039 a.name = artrim(buf[0:16])
1040 a.date = artrim(buf[16:28])
1041 a.uid = artrim(buf[28:34])
1042 a.gid = artrim(buf[34:40])
1043 a.mode = artrim(buf[40:48])
1044 a.size = artrim(buf[48:58])
1045 a.fmag = artrim(buf[58:60])
1047 arsize := atolwhex(a.size)
1051 return arsize + SAR_HDR
1054 func loadobjfile(ctxt *Link, lib *sym.Library) {
1055 pkg := objabi.PathToPrefix(lib.Pkg)
1057 if ctxt.Debugvlog > 1 {
1058 ctxt.Logf("ldobj: %s (%s)\n", lib.File, pkg)
1060 f, err := bio.Open(lib.File)
1062 Exitf("cannot open file %s: %v", lib.File, err)
1066 if pkg == "main" && !lib.Main {
1067 Exitf("%s: not package main", lib.File)
1071 for i := 0; i < len(ARMAG); i++ {
1072 if c, err := f.ReadByte(); err == nil && c == ARMAG[i] {
1076 /* load it as a regular file */
1077 l := f.MustSeek(0, 2)
1079 ldobj(ctxt, f, lib, l, lib.File, lib.File)
1084 * load all the object files from the archive now.
1085 * this gives us sequential file access and keeps us
1086 * from needing to come back later to pick up more
1087 * objects. it breaks the usual C archive model, but
1088 * this is Go, not C. the common case in Go is that
1089 * we need to load all the objects, and then we throw away
1090 * the individual symbols that are unused.
1092 * loading every object will also make it possible to
1093 * load foreign objects not referenced by __.PKGDEF.
1098 l := nextar(f, off, &arhdr)
1103 Exitf("%s: malformed archive", lib.File)
1107 // __.PKGDEF isn't a real Go object file, and it's
1108 // absent in -linkobj builds anyway. Skipping it
1109 // ensures consistency between -linkobj and normal
1111 if arhdr.name == pkgdef {
1115 if arhdr.name == "dynimportfail" {
1116 dynimportfail = append(dynimportfail, lib.Pkg)
1118 if arhdr.name == "preferlinkext" {
1119 // Ignore this directive if -linkmode has been
1121 if ctxt.LinkMode == LinkAuto {
1122 preferlinkext = append(preferlinkext, lib.Pkg)
1126 // Skip other special (non-object-file) sections that
1127 // build tools may have added. Such sections must have
1128 // short names so that the suffix is not truncated.
1129 if len(arhdr.name) < 16 {
1130 if ext := filepath.Ext(arhdr.name); ext != ".o" && ext != ".syso" {
1135 pname := fmt.Sprintf("%s(%s)", lib.File, arhdr.name)
1136 l = atolwhex(arhdr.size)
1137 ldobj(ctxt, f, lib, l, pname, lib.File)
1141 type Hostobj struct {
1142 ld func(*Link, *bio.Reader, string, int64, string)
1150 var hostobj []Hostobj
1152 // These packages can use internal linking mode.
1153 // Others trigger external mode.
1154 var internalpkg = []string{
1155 "crypto/internal/boring",
1156 "crypto/internal/boring/syso",
1162 "runtime/race/internal/amd64v1",
1163 "runtime/race/internal/amd64v3",
1168 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 {
1170 for _, intpkg := range internalpkg {
1177 // DragonFly declares errno with __thread, which results in a symbol
1178 // type of R_386_TLS_GD or R_X86_64_TLSGD. The Go linker does not
1179 // currently know how to handle TLS relocations, hence we have to
1180 // force external linking for any libraries that link in code that
1181 // uses errno. This can be removed if the Go linker ever supports
1182 // these relocation types.
1183 if headType == objabi.Hdragonfly {
1184 if pkg == "net" || pkg == "os/user" {
1193 hostobj = append(hostobj, Hostobj{})
1194 h := &hostobj[len(hostobj)-1]
1204 func hostobjs(ctxt *Link) {
1205 if ctxt.LinkMode != LinkInternal {
1210 for i := 0; i < len(hostobj); i++ {
1212 f, err := bio.Open(h.file)
1214 Exitf("cannot reopen %s: %v", h.pn, err)
1216 f.MustSeek(h.off, 0)
1218 Errorf(nil, "%s: unrecognized object file format", h.pn)
1221 h.ld(ctxt, f, h.pkg, h.length, h.pn)
1222 if *flagCaptureHostObjs != "" {
1229 func hostlinksetup(ctxt *Link) {
1230 if ctxt.LinkMode != LinkExternal {
1234 // For external link, record that we need to tell the external linker -s,
1235 // and turn off -s internally: the external linker needs the symbol
1236 // information for its final link.
1240 // create temporary directory and arrange cleanup
1241 if *flagTmpdir == "" {
1242 dir, err := os.MkdirTemp("", "go-link-")
1249 os.RemoveAll(*flagTmpdir)
1253 // change our output to temporary object file
1254 if err := ctxt.Out.Close(); err != nil {
1255 Exitf("error closing output file")
1257 mayberemoveoutfile()
1259 p := filepath.Join(*flagTmpdir, "go.o")
1260 if err := ctxt.Out.Open(p); err != nil {
1261 Exitf("cannot create %s: %v", p, err)
1265 // hostobjCopy creates a copy of the object files in hostobj in a
1266 // temporary directory.
1267 func (ctxt *Link) hostobjCopy() (paths []string) {
1268 var wg sync.WaitGroup
1269 sema := make(chan struct{}, runtime.NumCPU()) // limit open file descriptors
1270 for i, h := range hostobj {
1272 dst := filepath.Join(*flagTmpdir, fmt.Sprintf("%06d.o", i))
1273 paths = append(paths, dst)
1274 if ctxt.Debugvlog != 0 {
1275 ctxt.Logf("host obj copy: %s from pkg %s -> %s\n", h.pn, h.pkg, dst)
1285 f, err := os.Open(h.file)
1287 Exitf("cannot reopen %s: %v", h.pn, err)
1290 if _, err := f.Seek(h.off, 0); err != nil {
1291 Exitf("cannot seek %s: %v", h.pn, err)
1294 w, err := os.Create(dst)
1296 Exitf("cannot create %s: %v", dst, err)
1298 if _, err := io.CopyN(w, f, h.length); err != nil {
1299 Exitf("cannot write %s: %v", dst, err)
1301 if err := w.Close(); err != nil {
1302 Exitf("cannot close %s: %v", dst, err)
1310 // writeGDBLinkerScript creates gcc linker script file in temp
1311 // directory. writeGDBLinkerScript returns created file path.
1312 // The script is used to work around gcc bug
1313 // (see https://golang.org/issue/20183 for details).
1314 func writeGDBLinkerScript() string {
1315 name := "fix_debug_gdb_scripts.ld"
1316 path := filepath.Join(*flagTmpdir, name)
1319 .debug_gdb_scripts BLOCK(__section_alignment__) (NOLOAD) :
1321 *(.debug_gdb_scripts)
1324 INSERT AFTER .debug_types;
1326 err := os.WriteFile(path, []byte(src), 0666)
1328 Errorf(nil, "WriteFile %s failed: %v", name, err)
1333 // archive builds a .a archive from the hostobj object files.
1334 func (ctxt *Link) archive() {
1335 if ctxt.BuildMode != BuildModeCArchive {
1341 if *flagExtar == "" {
1345 mayberemoveoutfile()
1347 // Force the buffer to flush here so that external
1348 // tools will see a complete file.
1349 if err := ctxt.Out.Close(); err != nil {
1350 Exitf("error closing %v", *flagOutfile)
1353 argv := []string{*flagExtar, "-q", "-c", "-s"}
1354 if ctxt.HeadType == objabi.Haix {
1355 argv = append(argv, "-X64")
1357 argv = append(argv, *flagOutfile)
1358 argv = append(argv, filepath.Join(*flagTmpdir, "go.o"))
1359 argv = append(argv, ctxt.hostobjCopy()...)
1361 if ctxt.Debugvlog != 0 {
1362 ctxt.Logf("archive: %s\n", strings.Join(argv, " "))
1365 // If supported, use syscall.Exec() to invoke the archive command,
1366 // which should be the final remaining step needed for the link.
1367 // This will reduce peak RSS for the link (and speed up linking of
1368 // large applications), since when the archive command runs we
1369 // won't be holding onto all of the linker's live memory.
1370 if syscallExecSupported && !ownTmpDir {
1372 ctxt.execArchive(argv)
1373 panic("should not get here")
1376 // Otherwise invoke 'ar' in the usual way (fork + exec).
1377 if out, err := exec.Command(argv[0], argv[1:]...).CombinedOutput(); err != nil {
1378 Exitf("running %s failed: %v\n%s", argv[0], err, out)
1382 func (ctxt *Link) hostlink() {
1383 if ctxt.LinkMode != LinkExternal || nerrors > 0 {
1386 if ctxt.BuildMode == BuildModeCArchive {
1391 argv = append(argv, ctxt.extld()...)
1392 argv = append(argv, hostlinkArchArgs(ctxt.Arch)...)
1394 if *FlagS || debug_s {
1395 if ctxt.HeadType == objabi.Hdarwin {
1396 // Recent versions of macOS print
1397 // ld: warning: option -s is obsolete and being ignored
1398 // so do not pass any arguments (but we strip symbols below).
1400 argv = append(argv, "-s")
1404 // On darwin, whether to combine DWARF into executable.
1405 // Only macOS supports unmapped segments such as our __DWARF segment.
1406 combineDwarf := ctxt.IsDarwin() && !*FlagW && machoPlatform == PLATFORM_MACOS
1408 switch ctxt.HeadType {
1409 case objabi.Hdarwin:
1411 // Leave room for DWARF combining.
1412 // -headerpad is incompatible with -fembed-bitcode.
1413 argv = append(argv, "-Wl,-headerpad,1144")
1415 if ctxt.DynlinkingGo() && buildcfg.GOOS != "ios" {
1416 // -flat_namespace is deprecated on iOS.
1417 // It is useful for supporting plugins. We don't support plugins on iOS.
1418 // -flat_namespace may cause the dynamic linker to hang at forkExec when
1419 // resolving a lazy binding. See issue 38824.
1420 // Force eager resolution to work around.
1421 argv = append(argv, "-Wl,-flat_namespace", "-Wl,-bind_at_load")
1424 argv = append(argv, "-Wl,-S") // suppress STAB (symbolic debugging) symbols
1426 // We are generating a binary with symbol table suppressed.
1427 // Suppress local symbols. We need to keep dynamically exported
1428 // and referenced symbols so the dynamic linker can resolve them.
1429 argv = append(argv, "-Wl,-x")
1432 case objabi.Hopenbsd:
1433 argv = append(argv, "-Wl,-nopie")
1434 argv = append(argv, "-pthread")
1435 if ctxt.Arch.InFamily(sys.ARM64) {
1436 // Disable execute-only on openbsd/arm64 - the Go arm64 assembler
1437 // currently stores constants in the text section rather than in rodata.
1438 // See issue #59615.
1439 argv = append(argv, "-Wl,--no-execute-only")
1441 case objabi.Hwindows:
1443 argv = append(argv, "-mwindows")
1445 argv = append(argv, "-mconsole")
1447 // Mark as having awareness of terminal services, to avoid
1448 // ancient compatibility hacks.
1449 argv = append(argv, "-Wl,--tsaware")
1452 argv = append(argv, "-Wl,--nxcompat")
1454 argv = append(argv, fmt.Sprintf("-Wl,--major-os-version=%d", PeMinimumTargetMajorVersion))
1455 argv = append(argv, fmt.Sprintf("-Wl,--minor-os-version=%d", PeMinimumTargetMinorVersion))
1456 argv = append(argv, fmt.Sprintf("-Wl,--major-subsystem-version=%d", PeMinimumTargetMajorVersion))
1457 argv = append(argv, fmt.Sprintf("-Wl,--minor-subsystem-version=%d", PeMinimumTargetMinorVersion))
1459 argv = append(argv, "-pthread")
1460 // prevent ld to reorder .text functions to keep the same
1461 // first/last functions for moduledata.
1462 argv = append(argv, "-Wl,-bnoobjreorder")
1463 // mcmodel=large is needed for every gcc generated files, but
1464 // ld still need -bbigtoc in order to allow larger TOC.
1465 argv = append(argv, "-mcmodel=large")
1466 argv = append(argv, "-Wl,-bbigtoc")
1469 // On PPC64, verify the external toolchain supports Power10. This is needed when
1470 // PC relative relocations might be generated by Go. Only targets compiling ELF
1471 // binaries might generate these relocations.
1472 if ctxt.IsPPC64() && ctxt.IsElf() && buildcfg.GOPPC64 >= 10 {
1473 if !linkerFlagSupported(ctxt.Arch, argv[0], "", "-mcpu=power10") {
1474 Exitf("The external toolchain does not support -mcpu=power10. " +
1475 " This is required to externally link GOPPC64 >= power10")
1479 // Enable/disable ASLR on Windows.
1480 addASLRargs := func(argv []string, val bool) []string {
1481 // Old/ancient versions of GCC support "--dynamicbase" and
1482 // "--high-entropy-va" but don't enable it by default. In
1483 // addition, they don't accept "--disable-dynamicbase" or
1484 // "--no-dynamicbase", so the only way to disable ASLR is to
1485 // not pass any flags at all.
1487 // More modern versions of GCC (and also clang) enable ASLR
1488 // by default. With these compilers, however you can turn it
1489 // off if you want using "--disable-dynamicbase" or
1490 // "--no-dynamicbase".
1492 // The strategy below is to try using "--disable-dynamicbase";
1493 // if this succeeds, then assume we're working with more
1494 // modern compilers and act accordingly. If it fails, assume
1495 // an ancient compiler with ancient defaults.
1498 dbon := "--dynamicbase"
1499 heon := "--high-entropy-va"
1500 dboff := "--disable-dynamicbase"
1501 heoff := "--disable-high-entropy-va"
1506 // Test to see whether "--disable-dynamicbase" works.
1507 newer := linkerFlagSupported(ctxt.Arch, argv[0], "", "-Wl,"+dboff)
1509 // Newer compiler, which supports both on/off options.
1513 // older toolchain: we have to say nothing in order to
1514 // get a no-ASLR binary.
1520 argv = append(argv, "-Wl,"+dbopt)
1522 // enable high-entropy ASLR on 64-bit.
1523 if ctxt.Arch.PtrSize >= 8 && heopt != "" {
1524 argv = append(argv, "-Wl,"+heopt)
1529 switch ctxt.BuildMode {
1531 if ctxt.HeadType == objabi.Hdarwin {
1532 if machoPlatform == PLATFORM_MACOS && ctxt.IsAMD64() {
1533 argv = append(argv, "-Wl,-no_pie")
1536 if *flagRace && ctxt.HeadType == objabi.Hwindows {
1537 // Current windows/amd64 race detector tsan support
1538 // library can't handle PIE mode (see #53539 for more details).
1539 // For now, explicitly disable PIE (since some compilers
1540 // default to it) if -race is in effect.
1541 argv = addASLRargs(argv, false)
1544 switch ctxt.HeadType {
1545 case objabi.Hdarwin, objabi.Haix:
1546 case objabi.Hwindows:
1547 if *flagAslr && *flagRace {
1548 // Current windows/amd64 race detector tsan support
1549 // library can't handle PIE mode (see #53539 for more details).
1550 // Disable alsr if -race in effect.
1553 argv = addASLRargs(argv, *flagAslr)
1556 if ctxt.UseRelro() {
1557 argv = append(argv, "-Wl,-z,relro")
1559 argv = append(argv, "-pie")
1561 case BuildModeCShared:
1562 if ctxt.HeadType == objabi.Hdarwin {
1563 argv = append(argv, "-dynamiclib")
1565 if ctxt.UseRelro() {
1566 argv = append(argv, "-Wl,-z,relro")
1568 argv = append(argv, "-shared")
1569 if ctxt.HeadType == objabi.Hwindows {
1570 argv = addASLRargs(argv, *flagAslr)
1572 // Pass -z nodelete to mark the shared library as
1573 // non-closeable: a dlclose will do nothing.
1574 argv = append(argv, "-Wl,-z,nodelete")
1575 // Only pass Bsymbolic on non-Windows.
1576 argv = append(argv, "-Wl,-Bsymbolic")
1579 case BuildModeShared:
1580 if ctxt.UseRelro() {
1581 argv = append(argv, "-Wl,-z,relro")
1583 argv = append(argv, "-shared")
1584 case BuildModePlugin:
1585 if ctxt.HeadType == objabi.Hdarwin {
1586 argv = append(argv, "-dynamiclib")
1588 if ctxt.UseRelro() {
1589 argv = append(argv, "-Wl,-z,relro")
1591 argv = append(argv, "-shared")
1595 var altLinker string
1596 if ctxt.IsELF && ctxt.DynlinkingGo() {
1597 // We force all symbol resolution to be done at program startup
1598 // because lazy PLT resolution can use large amounts of stack at
1599 // times we cannot allow it to do so.
1600 argv = append(argv, "-Wl,-z,now")
1602 // Do not let the host linker generate COPY relocations. These
1603 // can move symbols out of sections that rely on stable offsets
1604 // from the beginning of the section (like sym.STYPE).
1605 argv = append(argv, "-Wl,-z,nocopyreloc")
1607 if buildcfg.GOOS == "android" {
1608 // Use lld to avoid errors from default linker (issue #38838)
1612 if ctxt.Arch.InFamily(sys.ARM64) && buildcfg.GOOS == "linux" {
1613 // On ARM64, the GNU linker will fail with
1614 // -znocopyreloc if it thinks a COPY relocation is
1615 // required. Switch to gold.
1616 // https://sourceware.org/bugzilla/show_bug.cgi?id=19962
1617 // https://go.dev/issue/22040
1620 // If gold is not installed, gcc will silently switch
1621 // back to ld.bfd. So we parse the version information
1622 // and provide a useful error if gold is missing.
1623 name, args := flagExtld[0], flagExtld[1:]
1624 args = append(args, "-fuse-ld=gold", "-Wl,--version")
1625 cmd := exec.Command(name, args...)
1626 if out, err := cmd.CombinedOutput(); err == nil {
1627 if !bytes.Contains(out, []byte("GNU gold")) {
1628 log.Fatalf("ARM64 external linker must be gold (issue #15696, 22040), but is not: %s", out)
1633 if ctxt.Arch.Family == sys.ARM64 && buildcfg.GOOS == "freebsd" {
1634 // Switch to ld.bfd on freebsd/arm64.
1637 // Provide a useful error if ld.bfd is missing.
1638 name, args := flagExtld[0], flagExtld[1:]
1639 args = append(args, "-fuse-ld=bfd", "-Wl,--version")
1640 cmd := exec.Command(name, args...)
1641 if out, err := cmd.CombinedOutput(); err == nil {
1642 if !bytes.Contains(out, []byte("GNU ld")) {
1643 log.Fatalf("ARM64 external linker must be ld.bfd (issue #35197), please install devel/binutils")
1647 if altLinker != "" {
1648 argv = append(argv, "-fuse-ld="+altLinker)
1651 if ctxt.IsELF && len(buildinfo) > 0 {
1652 argv = append(argv, fmt.Sprintf("-Wl,--build-id=0x%x", buildinfo))
1655 // On Windows, given -o foo, GCC will append ".exe" to produce
1656 // "foo.exe". We have decided that we want to honor the -o
1657 // option. To make this work, we append a '.' so that GCC
1658 // will decide that the file already has an extension. We
1659 // only want to do this when producing a Windows output file
1660 // on a Windows host.
1661 outopt := *flagOutfile
1662 if buildcfg.GOOS == "windows" && runtime.GOOS == "windows" && filepath.Ext(outopt) == "" {
1665 argv = append(argv, "-o")
1666 argv = append(argv, outopt)
1668 if rpath.val != "" {
1669 argv = append(argv, fmt.Sprintf("-Wl,-rpath,%s", rpath.val))
1672 if *flagInterpreter != "" {
1673 // Many linkers support both -I and the --dynamic-linker flags
1674 // to set the ELF interpreter, but lld only supports
1675 // --dynamic-linker so prefer that (ld on very old Solaris only
1676 // supports -I but that seems less important).
1677 argv = append(argv, fmt.Sprintf("-Wl,--dynamic-linker,%s", *flagInterpreter))
1680 // Force global symbols to be exported for dlopen, etc.
1682 if ctxt.DynlinkingGo() || ctxt.BuildMode == BuildModeCShared || !linkerFlagSupported(ctxt.Arch, argv[0], altLinker, "-Wl,--export-dynamic-symbol=main") {
1683 argv = append(argv, "-rdynamic")
1685 var exports []string
1686 ctxt.loader.ForAllCgoExportDynamic(func(s loader.Sym) {
1687 exports = append(exports, "-Wl,--export-dynamic-symbol="+ctxt.loader.SymExtname(s))
1689 sort.Strings(exports)
1690 argv = append(argv, exports...)
1693 if ctxt.HeadType == objabi.Haix {
1694 fileName := xcoffCreateExportFile(ctxt)
1695 argv = append(argv, "-Wl,-bE:"+fileName)
1698 const unusedArguments = "-Qunused-arguments"
1699 if linkerFlagSupported(ctxt.Arch, argv[0], altLinker, unusedArguments) {
1700 argv = append(argv, unusedArguments)
1703 if ctxt.IsWindows() {
1704 // Suppress generation of the PE file header timestamp,
1705 // so as to avoid spurious build ID differences between
1706 // linked binaries that are otherwise identical other than
1707 // the date/time they were linked.
1708 const noTimeStamp = "-Wl,--no-insert-timestamp"
1709 if linkerFlagSupported(ctxt.Arch, argv[0], altLinker, noTimeStamp) {
1710 argv = append(argv, noTimeStamp)
1714 const compressDWARF = "-Wl,--compress-debug-sections=zlib"
1715 if ctxt.compressDWARF && linkerFlagSupported(ctxt.Arch, argv[0], altLinker, compressDWARF) {
1716 argv = append(argv, compressDWARF)
1719 argv = append(argv, filepath.Join(*flagTmpdir, "go.o"))
1720 argv = append(argv, ctxt.hostobjCopy()...)
1721 if ctxt.HeadType == objabi.Haix {
1722 // We want to have C files after Go files to remove
1723 // trampolines csects made by ld.
1724 argv = append(argv, "-nostartfiles")
1725 argv = append(argv, "/lib/crt0_64.o")
1727 extld := ctxt.extld()
1728 name, args := extld[0], extld[1:]
1729 // Get starting files.
1730 getPathFile := func(file string) string {
1731 args := append(args, "-maix64", "--print-file-name="+file)
1732 out, err := exec.Command(name, args...).CombinedOutput()
1734 log.Fatalf("running %s failed: %v\n%s", extld, err, out)
1736 return strings.Trim(string(out), "\n")
1738 // Since GCC version 11, the 64-bit version of GCC starting files
1739 // are now suffixed by "_64". Even under "-maix64" multilib directory
1740 // "crtcxa.o" is 32-bit.
1741 crtcxa := getPathFile("crtcxa_64.o")
1742 if !filepath.IsAbs(crtcxa) {
1743 crtcxa = getPathFile("crtcxa.o")
1745 crtdbase := getPathFile("crtdbase_64.o")
1746 if !filepath.IsAbs(crtdbase) {
1747 crtdbase = getPathFile("crtdbase.o")
1749 argv = append(argv, crtcxa)
1750 argv = append(argv, crtdbase)
1753 if ctxt.linkShared {
1754 seenDirs := make(map[string]bool)
1755 seenLibs := make(map[string]bool)
1756 addshlib := func(path string) {
1757 dir, base := filepath.Split(path)
1759 argv = append(argv, "-L"+dir)
1761 argv = append(argv, "-Wl,-rpath="+dir)
1763 seenDirs[dir] = true
1765 base = strings.TrimSuffix(base, ".so")
1766 base = strings.TrimPrefix(base, "lib")
1767 if !seenLibs[base] {
1768 argv = append(argv, "-l"+base)
1769 seenLibs[base] = true
1772 for _, shlib := range ctxt.Shlibs {
1773 addshlib(shlib.Path)
1774 for _, dep := range shlib.Deps {
1778 libpath := findshlib(ctxt, dep)
1786 // clang, unlike GCC, passes -rdynamic to the linker
1787 // even when linking with -static, causing a linker
1788 // error when using GNU ld. So take out -rdynamic if
1789 // we added it. We do it in this order, rather than
1790 // only adding -rdynamic later, so that -extldflags
1791 // can override -rdynamic without using -static.
1792 // Similarly for -Wl,--dynamic-linker.
1793 checkStatic := func(arg string) {
1794 if ctxt.IsELF && arg == "-static" {
1795 for i := range argv {
1796 if argv[i] == "-rdynamic" || strings.HasPrefix(argv[i], "-Wl,--dynamic-linker,") {
1803 for _, p := range ldflag {
1804 argv = append(argv, p)
1808 // When building a program with the default -buildmode=exe the
1809 // gc compiler generates code requires DT_TEXTREL in a
1810 // position independent executable (PIE). On systems where the
1811 // toolchain creates PIEs by default, and where DT_TEXTREL
1812 // does not work, the resulting programs will not run. See
1813 // issue #17847. To avoid this problem pass -no-pie to the
1814 // toolchain if it is supported.
1815 if ctxt.BuildMode == BuildModeExe && !ctxt.linkShared && !(ctxt.IsDarwin() && ctxt.IsARM64()) {
1816 // GCC uses -no-pie, clang uses -nopie.
1817 for _, nopie := range []string{"-no-pie", "-nopie"} {
1818 if linkerFlagSupported(ctxt.Arch, argv[0], altLinker, nopie) {
1819 argv = append(argv, nopie)
1825 for _, p := range flagExtldflags {
1826 argv = append(argv, p)
1829 if ctxt.HeadType == objabi.Hwindows {
1830 // Determine which linker we're using. Add in the extldflags in
1831 // case used has specified "-fuse-ld=...".
1832 extld := ctxt.extld()
1833 name, args := extld[0], extld[1:]
1834 args = append(args, trimLinkerArgv(flagExtldflags)...)
1835 args = append(args, "-Wl,--version")
1836 cmd := exec.Command(name, args...)
1838 if out, err := cmd.CombinedOutput(); err == nil {
1839 if bytes.Contains(out, []byte("LLD ")) {
1844 // use gcc linker script to work around gcc bug
1845 // (see https://golang.org/issue/20183 for details).
1847 p := writeGDBLinkerScript()
1848 argv = append(argv, "-Wl,-T,"+p)
1851 if p := ctxt.findLibPath("libsynchronization.a"); p != "libsynchronization.a" {
1852 argv = append(argv, "-lsynchronization")
1855 // libmingw32 and libmingwex have some inter-dependencies,
1856 // so must use linker groups.
1857 argv = append(argv, "-Wl,--start-group", "-lmingwex", "-lmingw32", "-Wl,--end-group")
1858 argv = append(argv, peimporteddlls()...)
1861 argv = ctxt.passLongArgsInResponseFile(argv, altLinker)
1863 if ctxt.Debugvlog != 0 {
1864 ctxt.Logf("host link:")
1865 for _, v := range argv {
1871 out, err := exec.Command(argv[0], argv[1:]...).CombinedOutput()
1873 Exitf("running %s failed: %v\n%s", argv[0], err, out)
1876 // Filter out useless linker warnings caused by bugs outside Go.
1877 // See also cmd/go/internal/work/exec.go's gccld method.
1880 for _, line := range bytes.SplitAfter(out, []byte("\n")) {
1881 // golang.org/issue/26073 - Apple Xcode bug
1882 if bytes.Contains(line, []byte("ld: warning: text-based stub file")) {
1891 // Remove TOC overflow warning on AIX.
1892 if bytes.Contains(line, []byte("ld: 0711-783")) {
1897 save = append(save, line)
1899 out = bytes.Join(save, nil)
1902 // always print external output even if the command is successful, so that we don't
1903 // swallow linker warnings (see https://golang.org/issue/17935).
1904 if ctxt.IsDarwin() && ctxt.IsAMD64() {
1905 const noPieWarning = "ld: warning: -no_pie is deprecated when targeting new OS versions\n"
1906 if i := bytes.Index(out, []byte(noPieWarning)); i >= 0 {
1907 // swallow -no_pie deprecation warning, issue 54482
1908 out = append(out[:i], out[i+len(noPieWarning):]...)
1911 if ctxt.IsDarwin() {
1912 const bindAtLoadWarning = "ld: warning: -bind_at_load is deprecated on macOS\n"
1913 if i := bytes.Index(out, []byte(bindAtLoadWarning)); i >= 0 {
1914 // -bind_at_load is deprecated with ld-prime, but needed for
1915 // correctness with older versions of ld64. Swallow the warning.
1916 // TODO: maybe pass -bind_at_load conditionally based on C
1918 out = append(out[:i], out[i+len(bindAtLoadWarning):]...)
1921 ctxt.Logf("%s", out)
1925 // Find "dsymutils" and "strip" tools using CC --print-prog-name.
1927 cc = append(cc, ctxt.extld()...)
1928 cc = append(cc, hostlinkArchArgs(ctxt.Arch)...)
1929 cc = append(cc, "--print-prog-name", "dsymutil")
1930 out, err := exec.Command(cc[0], cc[1:]...).CombinedOutput()
1932 Exitf("%s: finding dsymutil failed: %v\n%s", os.Args[0], err, out)
1934 dsymutilCmd := strings.TrimSuffix(string(out), "\n")
1936 cc[len(cc)-1] = "strip"
1937 out, err = exec.Command(cc[0], cc[1:]...).CombinedOutput()
1939 Exitf("%s: finding strip failed: %v\n%s", os.Args[0], err, out)
1941 stripCmd := strings.TrimSuffix(string(out), "\n")
1943 dsym := filepath.Join(*flagTmpdir, "go.dwarf")
1944 cmd := exec.Command(dsymutilCmd, "-f", *flagOutfile, "-o", dsym)
1945 // dsymutil may not clean up its temp directory at exit.
1946 // Set DSYMUTIL_REPRODUCER_PATH to work around. see issue 59026.
1947 cmd.Env = append(os.Environ(), "DSYMUTIL_REPRODUCER_PATH="+*flagTmpdir)
1948 if ctxt.Debugvlog != 0 {
1949 ctxt.Logf("host link dsymutil:")
1950 for _, v := range cmd.Args {
1955 if out, err := cmd.CombinedOutput(); err != nil {
1956 Exitf("%s: running dsymutil failed: %v\n%s", os.Args[0], err, out)
1958 // Remove STAB (symbolic debugging) symbols after we are done with them (by dsymutil).
1959 // They contain temporary file paths and make the build not reproducible.
1960 var stripArgs = []string{"-S"}
1962 // We are generating a binary with symbol table suppressed.
1963 // Suppress local symbols. We need to keep dynamically exported
1964 // and referenced symbols so the dynamic linker can resolve them.
1965 stripArgs = append(stripArgs, "-x")
1967 stripArgs = append(stripArgs, *flagOutfile)
1968 if ctxt.Debugvlog != 0 {
1969 ctxt.Logf("host link strip: %q", stripCmd)
1970 for _, v := range stripArgs {
1975 if out, err := exec.Command(stripCmd, stripArgs...).CombinedOutput(); err != nil {
1976 Exitf("%s: running strip failed: %v\n%s", os.Args[0], err, out)
1978 // Skip combining if `dsymutil` didn't generate a file. See #11994.
1979 if _, err := os.Stat(dsym); os.IsNotExist(err) {
1982 // For os.Rename to work reliably, must be in same directory as outfile.
1983 combinedOutput := *flagOutfile + "~"
1984 exef, err := os.Open(*flagOutfile)
1986 Exitf("%s: combining dwarf failed: %v", os.Args[0], err)
1989 exem, err := macho.NewFile(exef)
1991 Exitf("%s: parsing Mach-O header failed: %v", os.Args[0], err)
1993 if err := machoCombineDwarf(ctxt, exef, exem, dsym, combinedOutput); err != nil {
1994 Exitf("%s: combining dwarf failed: %v", os.Args[0], err)
1996 os.Remove(*flagOutfile)
1997 if err := os.Rename(combinedOutput, *flagOutfile); err != nil {
1998 Exitf("%s: %v", os.Args[0], err)
2001 if ctxt.NeedCodeSign() {
2002 err := machoCodeSign(ctxt, *flagOutfile)
2004 Exitf("%s: code signing failed: %v", os.Args[0], err)
2009 // passLongArgsInResponseFile writes the arguments into a file if they
2011 func (ctxt *Link) passLongArgsInResponseFile(argv []string, altLinker string) []string {
2013 for _, arg := range argv {
2017 if c < sys.ExecArgLengthLimit {
2021 // Only use response files if they are supported.
2022 response := filepath.Join(*flagTmpdir, "response")
2023 if err := os.WriteFile(response, nil, 0644); err != nil {
2024 log.Fatalf("failed while testing response file: %v", err)
2026 if !linkerFlagSupported(ctxt.Arch, argv[0], altLinker, "@"+response) {
2027 if ctxt.Debugvlog != 0 {
2028 ctxt.Logf("not using response file because linker does not support one")
2033 var buf bytes.Buffer
2034 for _, arg := range argv[1:] {
2035 // The external linker response file supports quoted strings.
2036 fmt.Fprintf(&buf, "%q\n", arg)
2038 if err := os.WriteFile(response, buf.Bytes(), 0644); err != nil {
2039 log.Fatalf("failed while writing response file: %v", err)
2041 if ctxt.Debugvlog != 0 {
2042 ctxt.Logf("response file %s contents:\n%s", response, buf.Bytes())
2050 var createTrivialCOnce sync.Once
2052 func linkerFlagSupported(arch *sys.Arch, linker, altLinker, flag string) bool {
2053 createTrivialCOnce.Do(func() {
2054 src := filepath.Join(*flagTmpdir, "trivial.c")
2055 if err := os.WriteFile(src, []byte("int main() { return 0; }"), 0666); err != nil {
2056 Errorf(nil, "WriteFile trivial.c failed: %v", err)
2060 flags := hostlinkArchArgs(arch)
2062 moreFlags := trimLinkerArgv(append(flagExtldflags, ldflag...))
2063 flags = append(flags, moreFlags...)
2065 if altLinker != "" {
2066 flags = append(flags, "-fuse-ld="+altLinker)
2068 trivialPath := filepath.Join(*flagTmpdir, "trivial.c")
2069 outPath := filepath.Join(*flagTmpdir, "a.out")
2070 flags = append(flags, "-o", outPath, flag, trivialPath)
2072 cmd := exec.Command(linker, flags...)
2073 cmd.Env = append([]string{"LC_ALL=C"}, os.Environ()...)
2074 out, err := cmd.CombinedOutput()
2075 // GCC says "unrecognized command line option ‘-no-pie’"
2076 // clang says "unknown argument: '-no-pie'"
2077 return err == nil && !bytes.Contains(out, []byte("unrecognized")) && !bytes.Contains(out, []byte("unknown"))
2080 // trimLinkerArgv returns a new copy of argv that does not include flags
2081 // that are not relevant for testing whether some linker option works.
2082 func trimLinkerArgv(argv []string) []string {
2083 flagsWithNextArgSkip := []string{
2092 flagsWithNextArgKeep := []string{
2098 prefixesToKeep := []string{
2112 for _, f := range argv {
2114 flags = append(flags, f)
2118 } else if f == "" || f[0] != '-' {
2119 } else if contains(flagsWithNextArgSkip, f) {
2121 } else if contains(flagsWithNextArgKeep, f) {
2122 flags = append(flags, f)
2125 for _, p := range prefixesToKeep {
2126 if strings.HasPrefix(f, p) {
2127 flags = append(flags, f)
2136 // hostlinkArchArgs returns arguments to pass to the external linker
2137 // based on the architecture.
2138 func hostlinkArchArgs(arch *sys.Arch) []string {
2139 switch arch.Family {
2141 return []string{"-m32"}
2143 if buildcfg.GOOS == "darwin" {
2144 return []string{"-arch", "x86_64", "-m64"}
2146 return []string{"-m64"}
2148 return []string{"-m64"}
2150 return []string{"-marm"}
2152 if buildcfg.GOOS == "darwin" {
2153 return []string{"-arch", "arm64"}
2156 return []string{"-mabi=lp64d"}
2158 return []string{"-mabi=64"}
2160 return []string{"-mabi=32"}
2162 if buildcfg.GOOS == "aix" {
2163 return []string{"-maix64"}
2165 return []string{"-m64"}
2172 var wantHdr = objabi.HeaderString()
2174 // ldobj loads an input object. If it is a host object (an object
2175 // compiled by a non-Go compiler) it returns the Hostobj pointer. If
2176 // it is a Go object, it returns nil.
2177 func ldobj(ctxt *Link, f *bio.Reader, lib *sym.Library, length int64, pn string, file string) *Hostobj {
2178 pkg := objabi.PathToPrefix(lib.Pkg)
2180 eof := f.Offset() + length
2186 f.MustSeek(start, 0)
2188 unit := &sym.CompilationUnit{Lib: lib}
2189 lib.Units = append(lib.Units, unit)
2191 magic := uint32(c1)<<24 | uint32(c2)<<16 | uint32(c3)<<8 | uint32(c4)
2192 if magic == 0x7f454c46 { // \x7F E L F
2193 ldelf := func(ctxt *Link, f *bio.Reader, pkg string, length int64, pn string) {
2194 textp, flags, err := loadelf.Load(ctxt.loader, ctxt.Arch, ctxt.IncVersion(), f, pkg, length, pn, ehdr.Flags)
2196 Errorf(nil, "%v", err)
2200 ctxt.Textp = append(ctxt.Textp, textp...)
2202 return ldhostobj(ldelf, ctxt.HeadType, f, pkg, length, pn, file)
2205 if magic&^1 == 0xfeedface || magic&^0x01000000 == 0xcefaedfe {
2206 ldmacho := func(ctxt *Link, f *bio.Reader, pkg string, length int64, pn string) {
2207 textp, err := loadmacho.Load(ctxt.loader, ctxt.Arch, ctxt.IncVersion(), f, pkg, length, pn)
2209 Errorf(nil, "%v", err)
2212 ctxt.Textp = append(ctxt.Textp, textp...)
2214 return ldhostobj(ldmacho, ctxt.HeadType, f, pkg, length, pn, file)
2222 ldpe := func(ctxt *Link, f *bio.Reader, pkg string, length int64, pn string) {
2223 textp, rsrc, err := loadpe.Load(ctxt.loader, ctxt.Arch, ctxt.IncVersion(), f, pkg, length, pn)
2225 Errorf(nil, "%v", err)
2229 setpersrc(ctxt, rsrc)
2231 ctxt.Textp = append(ctxt.Textp, textp...)
2233 return ldhostobj(ldpe, ctxt.HeadType, f, pkg, length, pn, file)
2236 if c1 == 0x01 && (c2 == 0xD7 || c2 == 0xF7) {
2237 ldxcoff := func(ctxt *Link, f *bio.Reader, pkg string, length int64, pn string) {
2238 textp, err := loadxcoff.Load(ctxt.loader, ctxt.Arch, ctxt.IncVersion(), f, pkg, length, pn)
2240 Errorf(nil, "%v", err)
2243 ctxt.Textp = append(ctxt.Textp, textp...)
2245 return ldhostobj(ldxcoff, ctxt.HeadType, f, pkg, length, pn, file)
2248 if c1 != 'g' || c2 != 'o' || c3 != ' ' || c4 != 'o' {
2249 // An unrecognized object is just passed to the external linker.
2250 // If we try to read symbols from this object, we will
2251 // report an error at that time.
2252 unknownObjFormat = true
2253 return ldhostobj(nil, ctxt.HeadType, f, pkg, length, pn, file)
2256 /* check the header */
2257 line, err := f.ReadString('\n')
2259 Errorf(nil, "truncated object file: %s: %v", pn, err)
2263 if !strings.HasPrefix(line, "go object ") {
2264 if strings.HasSuffix(pn, ".go") {
2265 Exitf("%s: uncompiled .go source file", pn)
2269 if line == ctxt.Arch.Name {
2270 // old header format: just $GOOS
2271 Errorf(nil, "%s: stale object file", pn)
2275 Errorf(nil, "%s: not an object file: @%d %q", pn, start, line)
2279 // First, check that the basic GOOS, GOARCH, and Version match.
2280 if line != wantHdr {
2281 Errorf(nil, "%s: linked object header mismatch:\nhave %q\nwant %q\n", pn, line, wantHdr)
2284 // Skip over exports and other info -- ends with \n!\n.
2286 // Note: It's possible for "\n!\n" to appear within the binary
2287 // package export data format. To avoid truncating the package
2288 // definition prematurely (issue 21703), we keep track of
2289 // how many "$$" delimiters we've seen.
2291 import0 := f.Offset()
2293 c1 = '\n' // the last line ended in \n
2299 if markers%2 == 0 && c2 == '!' && c3 == '\n' {
2302 if c2 == '$' && c3 == '$' {
2311 Errorf(nil, "truncated object file: %s", pn)
2316 import1 := f.Offset()
2318 f.MustSeek(import0, 0)
2319 ldpkg(ctxt, f, lib, import1-import0-2, pn) // -2 for !\n
2320 f.MustSeek(import1, 0)
2322 fingerprint := ctxt.loader.Preload(ctxt.IncVersion(), f, lib, unit, eof-f.Offset())
2323 if !fingerprint.IsZero() { // Assembly objects don't have fingerprints. Ignore them.
2324 // Check fingerprint, to ensure the importing and imported packages
2325 // have consistent view of symbol indices.
2326 // Normally the go command should ensure this. But in case something
2327 // goes wrong, it could lead to obscure bugs like run-time crash.
2328 // Check it here to be sure.
2329 if lib.Fingerprint.IsZero() { // Not yet imported. Update its fingerprint.
2330 lib.Fingerprint = fingerprint
2332 checkFingerprint(lib, fingerprint, lib.Srcref, lib.Fingerprint)
2335 addImports(ctxt, lib, pn)
2339 // symbolsAreUnresolved scans through the loader's list of unresolved
2340 // symbols and checks to see whether any of them match the names of the
2341 // symbols in 'want'. Return value is a list of bools, with list[K] set
2342 // to true if there is an unresolved reference to the symbol in want[K].
2343 func symbolsAreUnresolved(ctxt *Link, want []string) []bool {
2344 returnAllUndefs := -1
2345 undefs, _ := ctxt.loader.UndefinedRelocTargets(returnAllUndefs)
2346 seen := make(map[loader.Sym]struct{})
2347 rval := make([]bool, len(want))
2348 wantm := make(map[string]int)
2349 for k, w := range want {
2353 for _, s := range undefs {
2354 if _, ok := seen[s]; ok {
2357 seen[s] = struct{}{}
2358 if k, ok := wantm[ctxt.loader.SymName(s)]; ok {
2361 if count == len(want) {
2369 // hostObject reads a single host object file (compare to "hostArchive").
2370 // This is used as part of internal linking when we need to pull in
2371 // files such as "crt?.o".
2372 func hostObject(ctxt *Link, objname string, path string) {
2373 if ctxt.Debugvlog > 1 {
2374 ctxt.Logf("hostObject(%s)\n", path)
2376 objlib := sym.Library{
2379 f, err := bio.Open(path)
2381 Exitf("cannot open host object %q file %s: %v", objname, path, err)
2384 h := ldobj(ctxt, f, &objlib, 0, path, path)
2386 Exitf("unrecognized object file format in %s", path)
2389 h.length = f.MustSeek(0, 2)
2390 f.MustSeek(h.off, 0)
2391 h.ld(ctxt, f, h.pkg, h.length, h.pn)
2392 if *flagCaptureHostObjs != "" {
2397 func checkFingerprint(lib *sym.Library, libfp goobj.FingerprintType, src string, srcfp goobj.FingerprintType) {
2399 Exitf("fingerprint mismatch: %s has %x, import from %s expecting %x", lib, libfp, src, srcfp)
2403 func readelfsymboldata(ctxt *Link, f *elf.File, sym *elf.Symbol) []byte {
2404 data := make([]byte, sym.Size)
2405 sect := f.Sections[sym.Section]
2406 if sect.Type != elf.SHT_PROGBITS && sect.Type != elf.SHT_NOTE {
2407 Errorf(nil, "reading %s from non-data section", sym.Name)
2409 n, err := sect.ReadAt(data, int64(sym.Value-sect.Addr))
2410 if uint64(n) != sym.Size {
2411 Errorf(nil, "reading contents of %s: %v", sym.Name, err)
2416 func readwithpad(r io.Reader, sz int32) ([]byte, error) {
2417 data := make([]byte, Rnd(int64(sz), 4))
2418 _, err := io.ReadFull(r, data)
2426 func readnote(f *elf.File, name []byte, typ int32) ([]byte, error) {
2427 for _, sect := range f.Sections {
2428 if sect.Type != elf.SHT_NOTE {
2433 var namesize, descsize, noteType int32
2434 err := binary.Read(r, f.ByteOrder, &namesize)
2439 return nil, fmt.Errorf("read namesize failed: %v", err)
2441 err = binary.Read(r, f.ByteOrder, &descsize)
2443 return nil, fmt.Errorf("read descsize failed: %v", err)
2445 err = binary.Read(r, f.ByteOrder, ¬eType)
2447 return nil, fmt.Errorf("read type failed: %v", err)
2449 noteName, err := readwithpad(r, namesize)
2451 return nil, fmt.Errorf("read name failed: %v", err)
2453 desc, err := readwithpad(r, descsize)
2455 return nil, fmt.Errorf("read desc failed: %v", err)
2457 if string(name) == string(noteName) && typ == noteType {
2465 func findshlib(ctxt *Link, shlib string) string {
2466 if filepath.IsAbs(shlib) {
2469 for _, libdir := range ctxt.Libdir {
2470 libpath := filepath.Join(libdir, shlib)
2471 if _, err := os.Stat(libpath); err == nil {
2475 Errorf(nil, "cannot find shared library: %s", shlib)
2479 func ldshlibsyms(ctxt *Link, shlib string) {
2481 if filepath.IsAbs(shlib) {
2483 shlib = filepath.Base(shlib)
2485 libpath = findshlib(ctxt, shlib)
2490 for _, processedlib := range ctxt.Shlibs {
2491 if processedlib.Path == libpath {
2495 if ctxt.Debugvlog > 1 {
2496 ctxt.Logf("ldshlibsyms: found library with name %s at %s\n", shlib, libpath)
2499 f, err := elf.Open(libpath)
2501 Errorf(nil, "cannot open shared library: %s", libpath)
2504 // Keep the file open as decodetypeGcprog needs to read from it.
2505 // TODO: fix. Maybe mmap the file.
2508 hash, err := readnote(f, ELF_NOTE_GO_NAME, ELF_NOTE_GOABIHASH_TAG)
2510 Errorf(nil, "cannot read ABI hash from shared library %s: %v", libpath, err)
2514 depsbytes, err := readnote(f, ELF_NOTE_GO_NAME, ELF_NOTE_GODEPS_TAG)
2516 Errorf(nil, "cannot read dep list from shared library %s: %v", libpath, err)
2520 for _, dep := range strings.Split(string(depsbytes), "\n") {
2524 if !filepath.IsAbs(dep) {
2525 // If the dep can be interpreted as a path relative to the shlib
2526 // in which it was found, do that. Otherwise, we will leave it
2527 // to be resolved by libdir lookup.
2528 abs := filepath.Join(filepath.Dir(libpath), dep)
2529 if _, err := os.Stat(abs); err == nil {
2533 deps = append(deps, dep)
2536 syms, err := f.DynamicSymbols()
2538 Errorf(nil, "cannot read symbols from shared library: %s", libpath)
2542 for _, elfsym := range syms {
2543 if elf.ST_TYPE(elfsym.Info) == elf.STT_NOTYPE || elf.ST_TYPE(elfsym.Info) == elf.STT_SECTION {
2547 // Symbols whose names start with "type:" are compiler generated,
2548 // so make functions with that prefix internal.
2550 symname := elfsym.Name // (unmangled) symbol name
2551 if elf.ST_TYPE(elfsym.Info) == elf.STT_FUNC && strings.HasPrefix(elfsym.Name, "type:") {
2552 ver = abiInternalVer
2553 } else if buildcfg.Experiment.RegabiWrappers && elf.ST_TYPE(elfsym.Info) == elf.STT_FUNC {
2554 // Demangle the ABI name. Keep in sync with symtab.go:mangleABIName.
2555 if strings.HasSuffix(elfsym.Name, ".abiinternal") {
2556 ver = sym.SymVerABIInternal
2557 symname = strings.TrimSuffix(elfsym.Name, ".abiinternal")
2558 } else if strings.HasSuffix(elfsym.Name, ".abi0") {
2560 symname = strings.TrimSuffix(elfsym.Name, ".abi0")
2565 s := l.LookupOrCreateSym(symname, ver)
2567 // Because loadlib above loads all .a files before loading
2568 // any shared libraries, any non-dynimport symbols we find
2569 // that duplicate symbols already loaded should be ignored
2570 // (the symbols from the .a files "win").
2571 if l.SymType(s) != 0 && l.SymType(s) != sym.SDYNIMPORT {
2574 su := l.MakeSymbolUpdater(s)
2575 su.SetType(sym.SDYNIMPORT)
2576 l.SetSymElfType(s, elf.ST_TYPE(elfsym.Info))
2577 su.SetSize(int64(elfsym.Size))
2578 if elfsym.Section != elf.SHN_UNDEF {
2579 // Set .File for the library that actually defines the symbol.
2580 l.SetSymPkg(s, libpath)
2582 // The decodetype_* functions in decodetype.go need access to
2584 sname := l.SymName(s)
2585 if strings.HasPrefix(sname, "type:") && !strings.HasPrefix(sname, "type:.") {
2586 su.SetData(readelfsymboldata(ctxt, f, &elfsym))
2590 if symname != elfsym.Name {
2591 l.SetSymExtname(s, elfsym.Name)
2594 ctxt.Shlibs = append(ctxt.Shlibs, Shlib{Path: libpath, Hash: hash, Deps: deps, File: f})
2597 func addsection(ldr *loader.Loader, arch *sys.Arch, seg *sym.Segment, name string, rwx int) *sym.Section {
2598 sect := ldr.NewSection()
2599 sect.Rwx = uint8(rwx)
2602 sect.Align = int32(arch.PtrSize) // everything is at least pointer-aligned
2603 seg.Sections = append(seg.Sections, sect)
2608 fmt.Fprintf(os.Stderr, "usage: link [options] main.o\n")
2609 objabi.Flagprint(os.Stderr)
2613 type SymbolType int8 // TODO: after genasmsym is gone, maybe rename to plan9typeChar or something
2616 // see also https://9p.io/magic/man2html/1/nm
2617 TextSym SymbolType = 'T'
2618 DataSym SymbolType = 'D'
2619 BSSSym SymbolType = 'B'
2620 UndefinedSym SymbolType = 'U'
2621 TLSSym SymbolType = 't'
2622 FrameSym SymbolType = 'm'
2623 ParamSym SymbolType = 'p'
2624 AutoSym SymbolType = 'a'
2626 // Deleted auto (not a real sym, just placeholder for type)
2627 DeletedAutoSym = 'x'
2630 // defineInternal defines a symbol used internally by the go runtime.
2631 func (ctxt *Link) defineInternal(p string, t sym.SymKind) loader.Sym {
2632 s := ctxt.loader.CreateSymForUpdate(p, 0)
2639 func (ctxt *Link) xdefine(p string, t sym.SymKind, v int64) loader.Sym {
2640 s := ctxt.defineInternal(p, t)
2641 ctxt.loader.SetSymValue(s, v)
2645 func datoff(ldr *loader.Loader, s loader.Sym, addr int64) int64 {
2646 if uint64(addr) >= Segdata.Vaddr {
2647 return int64(uint64(addr) - Segdata.Vaddr + Segdata.Fileoff)
2649 if uint64(addr) >= Segtext.Vaddr {
2650 return int64(uint64(addr) - Segtext.Vaddr + Segtext.Fileoff)
2652 ldr.Errorf(s, "invalid datoff %#x", addr)
2656 func Entryvalue(ctxt *Link) int64 {
2657 a := *flagEntrySymbol
2658 if a[0] >= '0' && a[0] <= '9' {
2662 s := ldr.Lookup(a, 0)
2664 Errorf(nil, "missing entry symbol %q", a)
2667 st := ldr.SymType(s)
2669 return *FlagTextAddr
2671 if !ctxt.IsAIX() && st != sym.STEXT {
2672 ldr.Errorf(s, "entry not text")
2674 return ldr.SymValue(s)
2677 func (ctxt *Link) callgraph() {
2683 for _, s := range ctxt.Textp {
2684 relocs := ldr.Relocs(s)
2685 for i := 0; i < relocs.Count(); i++ {
2691 if r.Type().IsDirectCall() && ldr.SymType(rs) == sym.STEXT {
2692 ctxt.Logf("%s calls %s\n", ldr.SymName(s), ldr.SymName(rs))
2698 func Rnd(v int64, r int64) int64 {
2711 func bgetc(r *bio.Reader) int {
2712 c, err := r.ReadByte()
2715 log.Fatalf("reading input: %v", err)
2722 type markKind uint8 // for postorder traversal
2729 func postorder(libs []*sym.Library) []*sym.Library {
2730 order := make([]*sym.Library, 0, len(libs)) // hold the result
2731 mark := make(map[*sym.Library]markKind, len(libs))
2732 for _, lib := range libs {
2733 dfs(lib, mark, &order)
2738 func dfs(lib *sym.Library, mark map[*sym.Library]markKind, order *[]*sym.Library) {
2739 if mark[lib] == visited {
2742 if mark[lib] == visiting {
2743 panic("found import cycle while visiting " + lib.Pkg)
2745 mark[lib] = visiting
2746 for _, i := range lib.Imports {
2750 *order = append(*order, lib)
2753 func ElfSymForReloc(ctxt *Link, s loader.Sym) int32 {
2754 // If putelfsym created a local version of this symbol, use that in all
2756 les := ctxt.loader.SymLocalElfSym(s)
2760 return ctxt.loader.SymElfSym(s)
2764 func AddGotSym(target *Target, ldr *loader.Loader, syms *ArchSyms, s loader.Sym, elfRelocTyp uint32) {
2765 if ldr.SymGot(s) >= 0 {
2769 Adddynsym(ldr, target, syms, s)
2770 got := ldr.MakeSymbolUpdater(syms.GOT)
2771 ldr.SetGot(s, int32(got.Size()))
2772 got.AddUint(target.Arch, 0)
2775 if target.Arch.PtrSize == 8 {
2776 rela := ldr.MakeSymbolUpdater(syms.Rela)
2777 rela.AddAddrPlus(target.Arch, got.Sym(), int64(ldr.SymGot(s)))
2778 rela.AddUint64(target.Arch, elf.R_INFO(uint32(ldr.SymDynid(s)), elfRelocTyp))
2779 rela.AddUint64(target.Arch, 0)
2781 rel := ldr.MakeSymbolUpdater(syms.Rel)
2782 rel.AddAddrPlus(target.Arch, got.Sym(), int64(ldr.SymGot(s)))
2783 rel.AddUint32(target.Arch, elf.R_INFO32(uint32(ldr.SymDynid(s)), elfRelocTyp))
2785 } else if target.IsDarwin() {
2786 leg := ldr.MakeSymbolUpdater(syms.LinkEditGOT)
2787 leg.AddUint32(target.Arch, uint32(ldr.SymDynid(s)))
2788 if target.IsPIE() && target.IsInternal() {
2789 // Mach-O relocations are a royal pain to lay out.
2790 // They use a compact stateful bytecode representation.
2791 // Here we record what are needed and encode them later.
2792 MachoAddBind(int64(ldr.SymGot(s)), s)
2795 ldr.Errorf(s, "addgotsym: unsupported binary format")
2799 var hostobjcounter int
2801 // captureHostObj writes out the content of a host object (pulled from
2802 // an archive or loaded from a *.o file directly) to a directory
2803 // specified via the linker's "-capturehostobjs" debugging flag. This
2804 // is intended to make it easier for a developer to inspect the actual
2805 // object feeding into "CGO internal" link step.
2806 func captureHostObj(h *Hostobj) {
2807 // Form paths for info file and obj file.
2808 ofile := fmt.Sprintf("captured-obj-%d.o", hostobjcounter)
2809 ifile := fmt.Sprintf("captured-obj-%d.txt", hostobjcounter)
2811 opath := filepath.Join(*flagCaptureHostObjs, ofile)
2812 ipath := filepath.Join(*flagCaptureHostObjs, ifile)
2814 // Write the info file.
2815 info := fmt.Sprintf("pkg: %s\npn: %s\nfile: %s\noff: %d\nlen: %d\n",
2816 h.pkg, h.pn, h.file, h.off, h.length)
2817 if err := os.WriteFile(ipath, []byte(info), 0666); err != nil {
2818 log.Fatalf("error writing captured host obj info %s: %v", ipath, err)
2821 readObjData := func() []byte {
2822 inf, err := os.Open(h.file)
2824 log.Fatalf("capturing host obj: open failed on %s: %v", h.pn, err)
2826 res := make([]byte, h.length)
2827 if n, err := inf.ReadAt(res, h.off); err != nil || n != int(h.length) {
2828 log.Fatalf("capturing host obj: readat failed on %s: %v", h.pn, err)
2833 // Write the object file.
2834 if err := os.WriteFile(opath, readObjData(), 0666); err != nil {
2835 log.Fatalf("error writing captured host object %s: %v", opath, err)
2838 fmt.Fprintf(os.Stderr, "link: info: captured host object %s to %s\n",