1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31 package ld
32
33 import (
34 "bytes"
35 "debug/elf"
36 "debug/macho"
37 "debug/pe"
38 "encoding/base64"
39 "encoding/binary"
40 "fmt"
41 "internal/buildcfg"
42 "internal/platform"
43 "io"
44 "log"
45 "os"
46 "os/exec"
47 "path/filepath"
48 "runtime"
49 "slices"
50 "sort"
51 "strings"
52 "sync"
53 "time"
54
55 "cmd/internal/bio"
56 "cmd/internal/goobj"
57 "cmd/internal/hash"
58 "cmd/internal/objabi"
59 "cmd/internal/sys"
60 "cmd/link/internal/loadelf"
61 "cmd/link/internal/loader"
62 "cmd/link/internal/loadmacho"
63 "cmd/link/internal/loadpe"
64 "cmd/link/internal/loadxcoff"
65 "cmd/link/internal/sym"
66 )
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103 type ArchSyms struct {
104 Rel loader.Sym
105 Rela loader.Sym
106 RelPLT loader.Sym
107 RelaPLT loader.Sym
108
109 LinkEditGOT loader.Sym
110 LinkEditPLT loader.Sym
111
112 TOC loader.Sym
113 DotTOC []loader.Sym
114
115 GOT loader.Sym
116 PLT loader.Sym
117 GOTPLT loader.Sym
118
119 Tlsg loader.Sym
120 Tlsoffset int
121
122 Dynamic loader.Sym
123 DynSym loader.Sym
124 DynStr loader.Sym
125
126 unreachableMethod loader.Sym
127
128
129
130 mainInittasks loader.Sym
131 }
132
133
134 func (ctxt *Link) mkArchSym(name string, ver int, ls *loader.Sym) {
135 *ls = ctxt.loader.LookupOrCreateSym(name, ver)
136 ctxt.loader.SetAttrReachable(*ls, true)
137 }
138
139
140
141 func (ctxt *Link) mkArchSymVec(name string, ver int, ls []loader.Sym) {
142 ls[ver] = ctxt.loader.LookupOrCreateSym(name, ver)
143 ctxt.loader.SetAttrReachable(ls[ver], true)
144 }
145
146
147
148 func (ctxt *Link) setArchSyms() {
149 ctxt.mkArchSym(".got", 0, &ctxt.GOT)
150 ctxt.mkArchSym(".plt", 0, &ctxt.PLT)
151 ctxt.mkArchSym(".got.plt", 0, &ctxt.GOTPLT)
152 ctxt.mkArchSym(".dynamic", 0, &ctxt.Dynamic)
153 ctxt.mkArchSym(".dynsym", 0, &ctxt.DynSym)
154 ctxt.mkArchSym(".dynstr", 0, &ctxt.DynStr)
155 ctxt.mkArchSym("runtime.unreachableMethod", abiInternalVer, &ctxt.unreachableMethod)
156
157 if ctxt.IsPPC64() {
158 ctxt.mkArchSym("TOC", 0, &ctxt.TOC)
159
160 ctxt.DotTOC = make([]loader.Sym, ctxt.MaxVersion()+1)
161 for i := 0; i <= ctxt.MaxVersion(); i++ {
162 if i >= sym.SymVerABICount && i < sym.SymVerStatic {
163 continue
164 }
165 ctxt.mkArchSymVec(".TOC.", i, ctxt.DotTOC)
166 }
167 }
168 if ctxt.IsElf() {
169 ctxt.mkArchSym(".rel", 0, &ctxt.Rel)
170 ctxt.mkArchSym(".rela", 0, &ctxt.Rela)
171 ctxt.mkArchSym(".rel.plt", 0, &ctxt.RelPLT)
172 ctxt.mkArchSym(".rela.plt", 0, &ctxt.RelaPLT)
173 }
174 if ctxt.IsDarwin() {
175 ctxt.mkArchSym(".linkedit.got", 0, &ctxt.LinkEditGOT)
176 ctxt.mkArchSym(".linkedit.plt", 0, &ctxt.LinkEditPLT)
177 }
178 }
179
180 type Arch struct {
181 Funcalign int
182 Maxalign int
183 Minalign int
184 Dwarfregsp int
185 Dwarfreglr int
186
187
188
189
190
191 TrampLimit uint64
192
193
194
195
196
197 CodePad []byte
198
199
200 Plan9Magic uint32
201 Plan9_64Bit bool
202
203 Adddynrel func(*Target, *loader.Loader, *ArchSyms, loader.Sym, loader.Reloc, int) bool
204 Archinit func(*Link)
205
206
207
208
209
210
211
212
213
214
215 Archreloc func(*Target, *loader.Loader, *ArchSyms, loader.Reloc, loader.Sym,
216 int64) (relocatedOffset int64, nExtReloc int, ok bool)
217
218
219
220
221
222
223
224
225 Archrelocvariant func(target *Target, ldr *loader.Loader, rel loader.Reloc,
226 rv sym.RelocVariant, sym loader.Sym, offset int64, data []byte) (relocatedOffset int64)
227
228
229
230 Trampoline func(ctxt *Link, ldr *loader.Loader, ri int, rs, s loader.Sym)
231
232
233
234
235
236
237
238
239 Asmb func(*Link, *loader.Loader)
240 Asmb2 func(*Link, *loader.Loader)
241
242
243
244
245 Extreloc func(*Target, *loader.Loader, loader.Reloc, loader.Sym) (loader.ExtReloc, bool)
246
247 Gentext func(*Link, *loader.Loader)
248 Machoreloc1 func(*sys.Arch, *OutBuf, *loader.Loader, loader.Sym, loader.ExtReloc, int64) bool
249 MachorelocSize uint32
250 PEreloc1 func(*sys.Arch, *OutBuf, *loader.Loader, loader.Sym, loader.ExtReloc, int64) bool
251 Xcoffreloc1 func(*sys.Arch, *OutBuf, *loader.Loader, loader.Sym, loader.ExtReloc, int64) bool
252
253
254
255 GenSymsLate func(*Link, *loader.Loader)
256
257
258
259
260
261
262
263 TLSIEtoLE func(P []byte, off, size int)
264
265
266 AssignAddress func(ldr *loader.Loader, sect *sym.Section, n int, s loader.Sym, va uint64, isTramp bool) (*sym.Section, int, uint64)
267
268
269 ELF ELFArch
270 }
271
272 var (
273 thearch Arch
274 lcSize int32
275 rpath Rpath
276 spSize int32
277 symSize int32
278 )
279
280
281
282 var abiInternalVer = sym.SymVerABIInternal
283
284
285
286 func (ctxt *Link) DynlinkingGo() bool {
287 if !ctxt.Loaded {
288 panic("DynlinkingGo called before all symbols loaded")
289 }
290 return ctxt.BuildMode == BuildModeShared || ctxt.linkShared || ctxt.BuildMode == BuildModePlugin || ctxt.canUsePlugins
291 }
292
293
294 func (ctxt *Link) CanUsePlugins() bool {
295 if !ctxt.Loaded {
296 panic("CanUsePlugins called before all symbols loaded")
297 }
298 return ctxt.canUsePlugins
299 }
300
301
302 func (ctxt *Link) NeedCodeSign() bool {
303 return ctxt.IsDarwin() && ctxt.IsARM64()
304 }
305
306 var (
307 dynlib []string
308 ldflag []string
309 havedynamic int
310 Funcalign int
311 iscgo bool
312 elfglobalsymndx int
313 interpreter string
314
315 debug_s bool
316 HEADR int32
317
318 nerrors int
319 liveness int64
320
321
322 checkStrictDups int
323 strictDupMsgCount int
324 )
325
326 var (
327 Segtext sym.Segment
328 Segrodata sym.Segment
329 Segrelrodata sym.Segment
330 Segdata sym.Segment
331 Segdwarf sym.Segment
332 Segpdata sym.Segment
333 Segxdata sym.Segment
334
335 Segments = []*sym.Segment{&Segtext, &Segrodata, &Segrelrodata, &Segdata, &Segdwarf, &Segpdata, &Segxdata}
336 )
337
338 const pkgdef = "__.PKGDEF"
339
340 var (
341
342
343
344 externalobj = false
345
346
347
348
349 dynimportfail []string
350
351
352
353
354
355 preferlinkext []string
356
357
358
359 unknownObjFormat = false
360
361 theline string
362 )
363
364 func Lflag(ctxt *Link, arg string) {
365 ctxt.Libdir = append(ctxt.Libdir, arg)
366 }
367
368
374 func mayberemoveoutfile() {
375 if fi, err := os.Lstat(*flagOutfile); err == nil && !fi.Mode().IsRegular() {
376 return
377 }
378 os.Remove(*flagOutfile)
379 if *flagOutfile != "" {
380 os.RemoveAll(*flagOutfile + ".dSYM")
381 }
382 }
383
384 func libinit(ctxt *Link) {
385 if *FlagFuncAlign != 0 {
386 Funcalign = *FlagFuncAlign
387 } else {
388 Funcalign = thearch.Funcalign
389 }
390
391
392 suffix := ""
393
394 suffixsep := ""
395 if *flagInstallSuffix != "" {
396 suffixsep = "_"
397 suffix = *flagInstallSuffix
398 } else if *flagRace {
399 suffixsep = "_"
400 suffix = "race"
401 } else if *flagMsan {
402 suffixsep = "_"
403 suffix = "msan"
404 } else if *flagAsan {
405 suffixsep = "_"
406 suffix = "asan"
407 }
408
409 if buildcfg.GOROOT != "" {
410 Lflag(ctxt, filepath.Join(buildcfg.GOROOT, "pkg", fmt.Sprintf("%s_%s%s%s", buildcfg.GOOS, buildcfg.GOARCH, suffixsep, suffix)))
411 }
412
413 mayberemoveoutfile()
414
415 if err := ctxt.Out.Open(*flagOutfile); err != nil {
416 Exitf("cannot create %s: %v", *flagOutfile, err)
417 }
418
419 if *flagEntrySymbol == "" {
420 switch ctxt.BuildMode {
421 case BuildModeCShared, BuildModeCArchive:
422 *flagEntrySymbol = fmt.Sprintf("_rt0_%s_%s_lib", buildcfg.GOARCH, buildcfg.GOOS)
423 case BuildModeExe, BuildModePIE:
424 *flagEntrySymbol = fmt.Sprintf("_rt0_%s_%s", buildcfg.GOARCH, buildcfg.GOOS)
425 case BuildModeShared, BuildModePlugin:
426
427 default:
428 Errorf("unknown *flagEntrySymbol for buildmode %v", ctxt.BuildMode)
429 }
430 }
431 }
432
433 func exitIfErrors() {
434 if nerrors != 0 || checkStrictDups > 1 && strictDupMsgCount > 0 {
435 mayberemoveoutfile()
436 Exit(2)
437 }
438
439 }
440
441 func errorexit() {
442 exitIfErrors()
443 Exit(0)
444 }
445
446 func loadinternal(ctxt *Link, name string) *sym.Library {
447 zerofp := goobj.FingerprintType{}
448 if ctxt.linkShared && ctxt.PackageShlib != nil {
449 if shlib := ctxt.PackageShlib[name]; shlib != "" {
450 return addlibpath(ctxt, "internal", "internal", "", name, shlib, zerofp)
451 }
452 }
453 if ctxt.PackageFile != nil {
454 if pname := ctxt.PackageFile[name]; pname != "" {
455 return addlibpath(ctxt, "internal", "internal", pname, name, "", zerofp)
456 }
457 ctxt.Logf("loadinternal: cannot find %s\n", name)
458 return nil
459 }
460
461 for _, libdir := range ctxt.Libdir {
462 if ctxt.linkShared {
463 shlibname := filepath.Join(libdir, name+".shlibname")
464 if ctxt.Debugvlog != 0 {
465 ctxt.Logf("searching for %s.a in %s\n", name, shlibname)
466 }
467 if _, err := os.Stat(shlibname); err == nil {
468 return addlibpath(ctxt, "internal", "internal", "", name, shlibname, zerofp)
469 }
470 }
471 pname := filepath.Join(libdir, name+".a")
472 if ctxt.Debugvlog != 0 {
473 ctxt.Logf("searching for %s.a in %s\n", name, pname)
474 }
475 if _, err := os.Stat(pname); err == nil {
476 return addlibpath(ctxt, "internal", "internal", pname, name, "", zerofp)
477 }
478 }
479
480 if name == "runtime" {
481 Exitf("error: unable to find runtime.a")
482 }
483 ctxt.Logf("warning: unable to find %s.a\n", name)
484 return nil
485 }
486
487
488 func (ctxt *Link) extld() []string {
489 if len(flagExtld) == 0 {
490
491
492
493 switch buildcfg.GOOS {
494 case "darwin", "freebsd", "openbsd":
495 flagExtld = []string{"clang"}
496 default:
497 flagExtld = []string{"gcc"}
498 }
499 }
500 return flagExtld
501 }
502
503
504
505 func (ctxt *Link) findLibPathCmd(cmd, libname string) string {
506 extld := ctxt.extld()
507 name, args := extld[0], extld[1:]
508 args = append(args, hostlinkArchArgs(ctxt.Arch)...)
509 args = append(args, cmd)
510 if ctxt.Debugvlog != 0 {
511 ctxt.Logf("%s %v\n", extld, args)
512 }
513 out, err := exec.Command(name, args...).Output()
514 if err != nil {
515 if ctxt.Debugvlog != 0 {
516 ctxt.Logf("not using a %s file because compiler failed\n%v\n%s\n", libname, err, out)
517 }
518 return "none"
519 }
520 return strings.TrimSpace(string(out))
521 }
522
523
524
525 func (ctxt *Link) findLibPath(libname string) string {
526 return ctxt.findLibPathCmd("--print-file-name="+libname, libname)
527 }
528
529 func (ctxt *Link) loadlib() {
530 var flags uint32
531 if *flagCheckLinkname {
532 flags |= loader.FlagCheckLinkname
533 }
534 switch *FlagStrictDups {
535 case 0:
536
537 case 1, 2:
538 flags |= loader.FlagStrictDups
539 default:
540 log.Fatalf("invalid -strictdups flag value %d", *FlagStrictDups)
541 }
542 ctxt.loader = loader.NewLoader(flags, &ctxt.ErrorReporter.ErrorReporter)
543 ctxt.ErrorReporter.SymName = func(s loader.Sym) string {
544 return ctxt.loader.SymName(s)
545 }
546
547
548 i := 0
549 for ; i < len(ctxt.Library); i++ {
550 lib := ctxt.Library[i]
551 if lib.Shlib == "" {
552 if ctxt.Debugvlog > 1 {
553 ctxt.Logf("autolib: %s (from %s)\n", lib.File, lib.Objref)
554 }
555 loadobjfile(ctxt, lib)
556 }
557 }
558
559
560 if *flagRace {
561 loadinternal(ctxt, "runtime/race")
562 }
563 if *flagMsan {
564 loadinternal(ctxt, "runtime/msan")
565 }
566 if *flagAsan {
567 loadinternal(ctxt, "runtime/asan")
568 }
569 loadinternal(ctxt, "runtime")
570 for ; i < len(ctxt.Library); i++ {
571 lib := ctxt.Library[i]
572 if lib.Shlib == "" {
573 loadobjfile(ctxt, lib)
574 }
575 }
576
577
578
579
580 iscgo = ctxt.LibraryByPkg["runtime/cgo"] != nil
581
582
583
584 ctxt.canUsePlugins = ctxt.LibraryByPkg["plugin"] != nil && iscgo &&
585 platform.BuildModeSupported("gc", "plugin", buildcfg.GOOS, buildcfg.GOARCH)
586
587
588 determineLinkMode(ctxt)
589
590 if ctxt.LinkMode == LinkExternal && !iscgo && !(buildcfg.GOOS == "darwin" && ctxt.BuildMode != BuildModePlugin && ctxt.Arch.Family == sys.AMD64) {
591
592
593
594
595 if lib := loadinternal(ctxt, "runtime/cgo"); lib != nil && lib.Shlib == "" {
596 if ctxt.BuildMode == BuildModeShared || ctxt.linkShared {
597 Exitf("cannot implicitly include runtime/cgo in a shared library")
598 }
599 for ; i < len(ctxt.Library); i++ {
600 lib := ctxt.Library[i]
601 if lib.Shlib == "" {
602 loadobjfile(ctxt, lib)
603 }
604 }
605 }
606 }
607
608
609 ctxt.loader.LoadSyms(ctxt.Arch)
610
611
612 for _, lib := range ctxt.Library {
613 if lib.Shlib != "" {
614 if ctxt.Debugvlog > 1 {
615 ctxt.Logf("autolib: %s (from %s)\n", lib.Shlib, lib.Objref)
616 }
617 ldshlibsyms(ctxt, lib.Shlib)
618 }
619 }
620
621
622 ctxt.loadcgodirectives()
623
624
625 hostobjs(ctxt)
626 hostlinksetup(ctxt)
627
628 if ctxt.LinkMode == LinkInternal && len(hostobj) != 0 {
629
630
631 any := false
632 undefs, froms := ctxt.loader.UndefinedRelocTargets(1)
633 if len(undefs) > 0 {
634 any = true
635 if ctxt.Debugvlog > 1 {
636 ctxt.Logf("loadlib: first unresolved is %s [%d] from %s [%d]\n",
637 ctxt.loader.SymName(undefs[0]), undefs[0],
638 ctxt.loader.SymName(froms[0]), froms[0])
639 }
640 }
641 if any {
642 if *flagLibGCC == "" {
643 *flagLibGCC = ctxt.findLibPathCmd("--print-libgcc-file-name", "libgcc")
644 }
645 if runtime.GOOS == "freebsd" && strings.HasPrefix(filepath.Base(*flagLibGCC), "libclang_rt.builtins") {
646
647
648
649
650 *flagLibGCC = ctxt.findLibPathCmd("--print-file-name=libcompiler_rt.a", "libcompiler_rt")
651 }
652 if runtime.GOOS == "openbsd" && *flagLibGCC == "libgcc.a" {
653
654
655
656 *flagLibGCC = ctxt.findLibPathCmd("--print-file-name=libcompiler_rt.a", "libcompiler_rt")
657 }
658 if ctxt.HeadType == objabi.Hwindows {
659 loadWindowsHostArchives(ctxt)
660 }
661 if *flagLibGCC != "none" {
662 hostArchive(ctxt, *flagLibGCC)
663 }
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680 isunresolved := symbolsAreUnresolved(ctxt, []string{"__stack_chk_fail_local"})
681 if isunresolved[0] {
682 if p := ctxt.findLibPath("libc_nonshared.a"); p != "none" {
683 hostArchive(ctxt, p)
684 }
685 if p := ctxt.findLibPath("libssp_nonshared.a"); p != "none" {
686 hostArchive(ctxt, p)
687 }
688 }
689 }
690 }
691
692 loadfips(ctxt)
693
694
695 ctxt.Loaded = true
696
697 strictDupMsgCount = ctxt.loader.NStrictDupMsgs()
698 }
699
700
701
702
703
704
705
706
707 func loadWindowsHostArchives(ctxt *Link) {
708 any := true
709 for i := 0; any && i < 2; i++ {
710
711
712 isunresolved := symbolsAreUnresolved(ctxt, []string{"atexit"})
713 if isunresolved[0] {
714 if p := ctxt.findLibPath("crt2.o"); p != "none" {
715 hostObject(ctxt, "crt2", p)
716 }
717 }
718 if *flagRace {
719 if p := ctxt.findLibPath("libsynchronization.a"); p != "none" {
720 hostArchive(ctxt, p)
721 }
722 }
723 if p := ctxt.findLibPath("libmingwex.a"); p != "none" {
724 hostArchive(ctxt, p)
725 }
726 if p := ctxt.findLibPath("libmingw32.a"); p != "none" {
727 hostArchive(ctxt, p)
728 }
729
730
731 if p := ctxt.findLibPath("libmsvcrt.a"); p != "none" {
732 hostArchive(ctxt, p)
733 }
734 any = false
735 undefs, froms := ctxt.loader.UndefinedRelocTargets(1)
736 if len(undefs) > 0 {
737 any = true
738 if ctxt.Debugvlog > 1 {
739 ctxt.Logf("loadWindowsHostArchives: remaining unresolved is %s [%d] from %s [%d]\n",
740 ctxt.loader.SymName(undefs[0]), undefs[0],
741 ctxt.loader.SymName(froms[0]), froms[0])
742 }
743 }
744 }
745
746
747
748
749 want := []string{"__CTOR_LIST__", "__DTOR_LIST__"}
750 isunresolved := symbolsAreUnresolved(ctxt, want)
751 for k, w := range want {
752 if isunresolved[k] {
753 sb := ctxt.loader.CreateSymForUpdate(w, 0)
754 sb.SetType(sym.SDATA)
755 sb.AddUint64(ctxt.Arch, 0)
756 sb.SetReachable(true)
757 ctxt.loader.SetAttrSpecial(sb.Sym(), true)
758 }
759 }
760
761
762
763 if err := loadpe.PostProcessImports(); err != nil {
764 Errorf("%v", err)
765 }
766
767
768
769
770
776 }
777
778
779
780 func (ctxt *Link) loadcgodirectives() {
781 l := ctxt.loader
782 hostObjSyms := make(map[loader.Sym]struct{})
783 for _, d := range ctxt.cgodata {
784 setCgoAttr(ctxt, d.file, d.pkg, d.directives, hostObjSyms)
785 }
786 ctxt.cgodata = nil
787
788 if ctxt.LinkMode == LinkInternal {
789
790
791 for symIdx := range hostObjSyms {
792 if l.SymType(symIdx) == sym.SHOSTOBJ {
793
794
795
796
797 su := l.MakeSymbolUpdater(symIdx)
798 if l.SymExtname(symIdx) != "" && l.SymDynimplib(symIdx) != "" && !(l.AttrCgoExportStatic(symIdx) || l.AttrCgoExportDynamic(symIdx)) {
799 su.SetType(sym.SDYNIMPORT)
800 } else {
801 su.SetType(0)
802 }
803 }
804 }
805 }
806 }
807
808
809
810 func (ctxt *Link) linksetup() {
811 switch ctxt.BuildMode {
812 case BuildModeCShared, BuildModePlugin:
813 symIdx := ctxt.loader.LookupOrCreateSym("runtime.islibrary", 0)
814 sb := ctxt.loader.MakeSymbolUpdater(symIdx)
815 sb.SetType(sym.SNOPTRDATA)
816 sb.AddUint8(1)
817 case BuildModeCArchive:
818 symIdx := ctxt.loader.LookupOrCreateSym("runtime.isarchive", 0)
819 sb := ctxt.loader.MakeSymbolUpdater(symIdx)
820 sb.SetType(sym.SNOPTRDATA)
821 sb.AddUint8(1)
822 }
823
824
825 if ctxt.HeadType == objabi.Hwindows {
826 Peinit(ctxt)
827 }
828
829 if ctxt.LinkMode == LinkExternal {
830
831
832 *FlagTextAddr = 0
833 }
834
835
836
837
838
839
840
841
842
843
844
845 if ctxt.BuildMode == BuildModeExe {
846 if havedynamic == 0 && ctxt.HeadType != objabi.Hdarwin && ctxt.HeadType != objabi.Hsolaris {
847 *FlagD = true
848 }
849 }
850
851 if ctxt.LinkMode == LinkExternal && ctxt.Arch.Family == sys.PPC64 && buildcfg.GOOS != "aix" {
852 toc := ctxt.loader.LookupOrCreateSym(".TOC.", 0)
853 sb := ctxt.loader.MakeSymbolUpdater(toc)
854 sb.SetType(sym.SDYNIMPORT)
855 }
856
857
858
859
860 if buildcfg.GOOS != "android" {
861 tlsg := ctxt.loader.LookupOrCreateSym("runtime.tlsg", 0)
862 sb := ctxt.loader.MakeSymbolUpdater(tlsg)
863
864
865
866 if sb.Type() == 0 {
867 sb.SetType(sym.STLSBSS)
868 sb.SetSize(int64(ctxt.Arch.PtrSize))
869 } else if sb.Type() != sym.SDYNIMPORT {
870 Errorf("runtime declared tlsg variable %v", sb.Type())
871 }
872 ctxt.loader.SetAttrReachable(tlsg, true)
873 ctxt.Tlsg = tlsg
874
875 if ctxt.IsWindows() && ctxt.IsExternal() {
876 ctxt.loader.SetAttrNotInSymbolTable(tlsg, false)
877 tlsOffset := ctxt.loader.Lookup("runtime.tls_g", 0)
878 if tlsOffset == 0 {
879 Errorf("missing runtime.tls_g")
880 } else {
881 rel, _ := ctxt.loader.MakeSymbolUpdater(tlsOffset).AddRel(objabi.R_ADDROFF)
882 rel.SetOff(0)
883 rel.SetSiz(4)
884 rel.SetSym(tlsg)
885 }
886 }
887 }
888
889 var moduledata loader.Sym
890 var mdsb *loader.SymbolBuilder
891 if ctxt.BuildMode == BuildModePlugin {
892 moduledata = ctxt.loader.LookupOrCreateSym("local.pluginmoduledata", 0)
893 mdsb = ctxt.loader.MakeSymbolUpdater(moduledata)
894 ctxt.loader.SetAttrLocal(moduledata, true)
895 } else {
896 moduledata = ctxt.loader.LookupOrCreateSym("runtime.firstmoduledata", 0)
897 mdsb = ctxt.loader.MakeSymbolUpdater(moduledata)
898 }
899 if mdsb.Type() != 0 && mdsb.Type() != sym.SDYNIMPORT {
900
901
902
903
904
905 mdsb.SetSize(0)
906
907
908
909 if ctxt.Arch.Family == sys.ARM {
910 goarm := ctxt.loader.LookupOrCreateSym("runtime.goarm", 0)
911 sb := ctxt.loader.MakeSymbolUpdater(goarm)
912 sb.SetType(sym.SNOPTRDATA)
913 sb.SetSize(0)
914 sb.AddUint8(uint8(buildcfg.GOARM.Version))
915
916 goarmsoftfp := ctxt.loader.LookupOrCreateSym("runtime.goarmsoftfp", 0)
917 sb2 := ctxt.loader.MakeSymbolUpdater(goarmsoftfp)
918 sb2.SetType(sym.SNOPTRDATA)
919 sb2.SetSize(0)
920 if buildcfg.GOARM.SoftFloat {
921 sb2.AddUint8(1)
922 } else {
923 sb2.AddUint8(0)
924 }
925 }
926
927
928
929
930 memProfile := ctxt.loader.Lookup("runtime.memProfileInternal", abiInternalVer)
931 if memProfile != 0 && !ctxt.loader.AttrReachable(memProfile) && !ctxt.DynlinkingGo() {
932 memProfSym := ctxt.loader.LookupOrCreateSym("runtime.disableMemoryProfiling", 0)
933 sb := ctxt.loader.MakeSymbolUpdater(memProfSym)
934 sb.SetType(sym.SNOPTRDATA)
935 sb.SetSize(0)
936 sb.AddUint8(1)
937 }
938 } else {
939
940
941 moduledata = ctxt.loader.LookupOrCreateSym("local.moduledata", 0)
942 mdsb = ctxt.loader.MakeSymbolUpdater(moduledata)
943 ctxt.loader.SetAttrLocal(moduledata, true)
944 }
945 mdsb.SetType(sym.SMODULEDATA)
946 ctxt.loader.SetAttrReachable(moduledata, true)
947 ctxt.Moduledata = moduledata
948
949 if ctxt.Arch == sys.Arch386 && ctxt.HeadType != objabi.Hwindows {
950 if (ctxt.BuildMode == BuildModeCArchive && ctxt.IsELF) || ctxt.BuildMode == BuildModeCShared || ctxt.BuildMode == BuildModePIE || ctxt.DynlinkingGo() {
951 got := ctxt.loader.LookupOrCreateSym("_GLOBAL_OFFSET_TABLE_", 0)
952 sb := ctxt.loader.MakeSymbolUpdater(got)
953 sb.SetType(sym.SDYNIMPORT)
954 ctxt.loader.SetAttrReachable(got, true)
955 }
956 }
957
958
959
960
961
962
963
964 ctxt.Library = postorder(ctxt.Library)
965 intlibs := []bool{}
966 for _, lib := range ctxt.Library {
967 intlibs = append(intlibs, isRuntimeDepPkg(lib.Pkg))
968 }
969 ctxt.Textp = ctxt.loader.AssignTextSymbolOrder(ctxt.Library, intlibs, ctxt.Textp)
970 }
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985 func (ctxt *Link) mangleTypeSym() {
986 if ctxt.BuildMode != BuildModeShared && !ctxt.linkShared && ctxt.BuildMode != BuildModePlugin && !ctxt.CanUsePlugins() {
987 return
988 }
989
990 ldr := ctxt.loader
991 for s := loader.Sym(1); s < loader.Sym(ldr.NSym()); s++ {
992 if !ldr.AttrReachable(s) && !ctxt.linkShared {
993
994
995
996
997
998 continue
999 }
1000 name := ldr.SymName(s)
1001 newName := typeSymbolMangle(name)
1002 if newName != name {
1003 ldr.SetSymExtname(s, newName)
1004
1005
1006
1007
1008
1009
1010 dup := ldr.Lookup(newName, ldr.SymVersion(s))
1011 if dup != 0 {
1012 st := ldr.SymType(s)
1013 dt := ldr.SymType(dup)
1014 if st == sym.Sxxx && dt != sym.Sxxx {
1015 ldr.CopySym(dup, s)
1016 }
1017 }
1018 }
1019 }
1020 }
1021
1022
1023
1024
1025
1026
1027
1028 func typeSymbolMangle(name string) string {
1029 isType := strings.HasPrefix(name, "type:")
1030 if !isType && !strings.Contains(name, "@") {
1031
1032 return name
1033 }
1034 if strings.HasPrefix(name, "type:runtime.") {
1035 return name
1036 }
1037 if strings.HasPrefix(name, "go:string.") {
1038
1039
1040 return name
1041 }
1042 if len(name) <= 14 && !strings.Contains(name, "@") {
1043 return name
1044 }
1045 if isType {
1046 hb := hash.Sum32([]byte(name[5:]))
1047 prefix := "type:"
1048 if name[5] == '.' {
1049 prefix = "type:."
1050 }
1051 return prefix + base64.StdEncoding.EncodeToString(hb[:6])
1052 }
1053
1054 i := strings.IndexByte(name, '[')
1055 j := strings.LastIndexByte(name, ']')
1056 if j == -1 || j <= i {
1057 j = len(name)
1058 }
1059 hb := hash.Sum32([]byte(name[i+1 : j]))
1060 return name[:i+1] + base64.StdEncoding.EncodeToString(hb[:6]) + name[j:]
1061 }
1062
1063
1067 func nextar(bp *bio.Reader, off int64, a *ArHdr) int64 {
1068 if off&1 != 0 {
1069 off++
1070 }
1071 bp.MustSeek(off, 0)
1072 var buf [SAR_HDR]byte
1073 if n, err := io.ReadFull(bp, buf[:]); err != nil {
1074 if n == 0 && err != io.EOF {
1075 return -1
1076 }
1077 return 0
1078 }
1079
1080 a.name = artrim(buf[0:16])
1081 a.date = artrim(buf[16:28])
1082 a.uid = artrim(buf[28:34])
1083 a.gid = artrim(buf[34:40])
1084 a.mode = artrim(buf[40:48])
1085 a.size = artrim(buf[48:58])
1086 a.fmag = artrim(buf[58:60])
1087
1088 arsize := atolwhex(a.size)
1089 if arsize&1 != 0 {
1090 arsize++
1091 }
1092 return arsize + SAR_HDR
1093 }
1094
1095 func loadobjfile(ctxt *Link, lib *sym.Library) {
1096 pkg := objabi.PathToPrefix(lib.Pkg)
1097
1098 if ctxt.Debugvlog > 1 {
1099 ctxt.Logf("ldobj: %s (%s)\n", lib.File, pkg)
1100 }
1101 f, err := bio.Open(lib.File)
1102 if err != nil {
1103 Exitf("cannot open file %s: %v", lib.File, err)
1104 }
1105 defer f.Close()
1106 defer func() {
1107 if pkg == "main" && !lib.Main {
1108 Exitf("%s: not package main", lib.File)
1109 }
1110 }()
1111
1112 for i := 0; i < len(ARMAG); i++ {
1113 if c, err := f.ReadByte(); err == nil && c == ARMAG[i] {
1114 continue
1115 }
1116
1117
1118 l := f.MustSeek(0, 2)
1119 f.MustSeek(0, 0)
1120 ldobj(ctxt, f, lib, l, lib.File, lib.File)
1121 return
1122 }
1123
1124
1136 var arhdr ArHdr
1137 off := f.Offset()
1138 for {
1139 l := nextar(f, off, &arhdr)
1140 if l == 0 {
1141 break
1142 }
1143 if l < 0 {
1144 Exitf("%s: malformed archive", lib.File)
1145 }
1146 off += l
1147
1148
1149
1150
1151
1152 if arhdr.name == pkgdef {
1153 continue
1154 }
1155
1156 if arhdr.name == "dynimportfail" {
1157 dynimportfail = append(dynimportfail, lib.Pkg)
1158 }
1159 if arhdr.name == "preferlinkext" {
1160
1161
1162 if ctxt.LinkMode == LinkAuto {
1163 preferlinkext = append(preferlinkext, lib.Pkg)
1164 }
1165 }
1166
1167
1168
1169
1170 if len(arhdr.name) < 16 {
1171 if ext := filepath.Ext(arhdr.name); ext != ".o" && ext != ".syso" {
1172 continue
1173 }
1174 }
1175
1176 pname := fmt.Sprintf("%s(%s)", lib.File, arhdr.name)
1177 l = atolwhex(arhdr.size)
1178 ldobj(ctxt, f, lib, l, pname, lib.File)
1179 }
1180 }
1181
1182 type Hostobj struct {
1183 ld func(*Link, *bio.Reader, string, int64, string)
1184 pkg string
1185 pn string
1186 file string
1187 off int64
1188 length int64
1189 }
1190
1191 var hostobj []Hostobj
1192
1193
1194
1195 var internalpkg = []string{
1196 "crypto/internal/boring",
1197 "crypto/internal/boring/syso",
1198 "crypto/x509",
1199 "net",
1200 "os/user",
1201 "runtime/cgo",
1202 "runtime/race",
1203 "runtime/race/internal/amd64v1",
1204 "runtime/race/internal/amd64v3",
1205 "runtime/msan",
1206 "runtime/asan",
1207 }
1208
1209 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 {
1210 isinternal := false
1211 for _, intpkg := range internalpkg {
1212 if pkg == intpkg {
1213 isinternal = true
1214 break
1215 }
1216 }
1217
1218
1219
1220
1221
1222
1223
1224 if headType == objabi.Hdragonfly {
1225 if pkg == "net" || pkg == "os/user" {
1226 isinternal = false
1227 }
1228 }
1229
1230 if !isinternal {
1231 externalobj = true
1232 }
1233
1234 hostobj = append(hostobj, Hostobj{})
1235 h := &hostobj[len(hostobj)-1]
1236 h.ld = ld
1237 h.pkg = pkg
1238 h.pn = pn
1239 h.file = file
1240 h.off = f.Offset()
1241 h.length = length
1242 return h
1243 }
1244
1245 func hostobjs(ctxt *Link) {
1246 if ctxt.LinkMode != LinkInternal {
1247 return
1248 }
1249 var h *Hostobj
1250
1251 for i := 0; i < len(hostobj); i++ {
1252 h = &hostobj[i]
1253 f, err := bio.Open(h.file)
1254 if err != nil {
1255 Exitf("cannot reopen %s: %v", h.pn, err)
1256 }
1257 f.MustSeek(h.off, 0)
1258 if h.ld == nil {
1259 Errorf("%s: unrecognized object file format", h.pn)
1260 f.Close()
1261 continue
1262 }
1263 h.ld(ctxt, f, h.pkg, h.length, h.pn)
1264 if *flagCaptureHostObjs != "" {
1265 captureHostObj(h)
1266 }
1267 f.Close()
1268 }
1269 }
1270
1271 func hostlinksetup(ctxt *Link) {
1272 if ctxt.LinkMode != LinkExternal {
1273 return
1274 }
1275
1276
1277
1278
1279 debug_s = *FlagS
1280 *FlagS = false
1281
1282
1283 if *flagTmpdir == "" {
1284 dir, err := os.MkdirTemp("", "go-link-")
1285 if err != nil {
1286 log.Fatal(err)
1287 }
1288 *flagTmpdir = dir
1289 ownTmpDir = true
1290 AtExit(func() {
1291 os.RemoveAll(*flagTmpdir)
1292 })
1293 }
1294
1295
1296 if err := ctxt.Out.Close(); err != nil {
1297 Exitf("error closing output file")
1298 }
1299 mayberemoveoutfile()
1300
1301 p := filepath.Join(*flagTmpdir, "go.o")
1302 if err := ctxt.Out.Open(p); err != nil {
1303 Exitf("cannot create %s: %v", p, err)
1304 }
1305 }
1306
1307
1308
1309
1310
1311
1312
1313
1314 func cleanTimeStamps(files []string) {
1315 epocht := time.Unix(0, 0)
1316 for _, f := range files {
1317 if err := os.Chtimes(f, epocht, epocht); err != nil {
1318 Exitf("cannot chtimes %s: %v", f, err)
1319 }
1320 }
1321 }
1322
1323
1324
1325 func (ctxt *Link) hostobjCopy() (paths []string) {
1326 var wg sync.WaitGroup
1327 sema := make(chan struct{}, runtime.NumCPU())
1328 for i, h := range hostobj {
1329 h := h
1330 dst := filepath.Join(*flagTmpdir, fmt.Sprintf("%06d.o", i))
1331 paths = append(paths, dst)
1332 if ctxt.Debugvlog != 0 {
1333 ctxt.Logf("host obj copy: %s from pkg %s -> %s\n", h.pn, h.pkg, dst)
1334 }
1335
1336 wg.Add(1)
1337 go func() {
1338 sema <- struct{}{}
1339 defer func() {
1340 <-sema
1341 wg.Done()
1342 }()
1343 f, err := os.Open(h.file)
1344 if err != nil {
1345 Exitf("cannot reopen %s: %v", h.pn, err)
1346 }
1347 defer f.Close()
1348 if _, err := f.Seek(h.off, 0); err != nil {
1349 Exitf("cannot seek %s: %v", h.pn, err)
1350 }
1351
1352 w, err := os.Create(dst)
1353 if err != nil {
1354 Exitf("cannot create %s: %v", dst, err)
1355 }
1356 if _, err := io.CopyN(w, f, h.length); err != nil {
1357 Exitf("cannot write %s: %v", dst, err)
1358 }
1359 if err := w.Close(); err != nil {
1360 Exitf("cannot close %s: %v", dst, err)
1361 }
1362 }()
1363 }
1364 wg.Wait()
1365 return paths
1366 }
1367
1368
1369
1370
1371
1372 func writeGDBLinkerScript() string {
1373 name := "fix_debug_gdb_scripts.ld"
1374 path := filepath.Join(*flagTmpdir, name)
1375 src := `SECTIONS
1376 {
1377 .debug_gdb_scripts BLOCK(__section_alignment__) (NOLOAD) :
1378 {
1379 *(.debug_gdb_scripts)
1380 }
1381 }
1382 INSERT AFTER .debug_types;
1383 `
1384 err := os.WriteFile(path, []byte(src), 0666)
1385 if err != nil {
1386 Errorf("WriteFile %s failed: %v", name, err)
1387 }
1388 return path
1389 }
1390
1391 type machoUpdateFunc func(ctxt *Link, exef *os.File, exem *macho.File, outexe string) error
1392
1393
1394 func (ctxt *Link) archive() {
1395 if ctxt.BuildMode != BuildModeCArchive {
1396 return
1397 }
1398
1399 exitIfErrors()
1400
1401 if *flagExtar == "" {
1402 const printProgName = "--print-prog-name=ar"
1403 cc := ctxt.extld()
1404 *flagExtar = "ar"
1405 if linkerFlagSupported(ctxt.Arch, cc, "", printProgName) {
1406 *flagExtar = ctxt.findExtLinkTool("ar")
1407 }
1408 }
1409
1410 mayberemoveoutfile()
1411
1412
1413
1414 if err := ctxt.Out.Close(); err != nil {
1415 Exitf("error closing %v", *flagOutfile)
1416 }
1417
1418 argv := []string{*flagExtar, "-q", "-c", "-s"}
1419 if ctxt.HeadType == objabi.Haix {
1420 argv = append(argv, "-X64")
1421 }
1422 godotopath := filepath.Join(*flagTmpdir, "go.o")
1423 cleanTimeStamps([]string{godotopath})
1424 hostObjCopyPaths := ctxt.hostobjCopy()
1425 cleanTimeStamps(hostObjCopyPaths)
1426
1427 argv = append(argv, *flagOutfile)
1428 argv = append(argv, godotopath)
1429 argv = append(argv, hostObjCopyPaths...)
1430
1431 if ctxt.Debugvlog != 0 {
1432 ctxt.Logf("archive: %s\n", strings.Join(argv, " "))
1433 }
1434
1435
1436
1437
1438
1439
1440 if syscallExecSupported && !ownTmpDir {
1441 runAtExitFuncs()
1442 ctxt.execArchive(argv)
1443 panic("should not get here")
1444 }
1445
1446
1447 if out, err := exec.Command(argv[0], argv[1:]...).CombinedOutput(); err != nil {
1448 Exitf("running %s failed: %v\n%s", argv[0], err, out)
1449 }
1450 }
1451
1452 func (ctxt *Link) hostlink() {
1453 if ctxt.LinkMode != LinkExternal || nerrors > 0 {
1454 return
1455 }
1456 if ctxt.BuildMode == BuildModeCArchive {
1457 return
1458 }
1459
1460 var argv []string
1461 argv = append(argv, ctxt.extld()...)
1462 argv = append(argv, hostlinkArchArgs(ctxt.Arch)...)
1463
1464 if *FlagS || debug_s {
1465 if ctxt.HeadType == objabi.Hdarwin {
1466
1467
1468
1469 } else {
1470 argv = append(argv, "-s")
1471 }
1472 } else if *FlagW {
1473 if !ctxt.IsAIX() && !ctxt.IsSolaris() {
1474 argv = append(argv, "-Wl,-S")
1475 }
1476 }
1477
1478
1479
1480
1481 machoDwarf := ctxt.IsDarwin() && !*FlagW && (*FlagSplitDWARF || machoPlatform == PLATFORM_MACOS)
1482 combineDwarf := machoDwarf && !*FlagSplitDWARF
1483
1484 var isMSVC, isLLD bool
1485 wlPrefix := "-Wl,--"
1486
1487 switch ctxt.HeadType {
1488 case objabi.Hdarwin:
1489 if combineDwarf {
1490
1491
1492 argv = append(argv, "-Wl,-headerpad,1144")
1493 }
1494 if ctxt.DynlinkingGo() && buildcfg.GOOS != "ios" {
1495
1496
1497
1498
1499
1500 argv = append(argv, "-Wl,-flat_namespace", "-Wl,-bind_at_load")
1501 if combineDwarf && linkerFlagSupported(ctxt.Arch, ctxt.extld(), "", "-Wl,-no_fixup_chains") {
1502
1503
1504
1505
1506
1507 argv = append(argv, "-Wl,-no_fixup_chains")
1508 }
1509 }
1510 if !machoDwarf {
1511 argv = append(argv, "-Wl,-S")
1512 if debug_s {
1513
1514
1515
1516 argv = append(argv, "-Wl,-x")
1517 }
1518 }
1519 if *flagRace {
1520
1521
1522
1523 argv = append(argv, "-Wl,-U,__dyld_get_dyld_header")
1524 }
1525 if *flagHostBuildid == "none" {
1526 argv = append(argv, "-Wl,-no_uuid")
1527 }
1528 case objabi.Hopenbsd:
1529 argv = append(argv, "-pthread")
1530 if linkerFlagSupported(ctxt.Arch, ctxt.extld(), "", "-Wl,-z,nobtcfi") {
1531
1532
1533 argv = append(argv, "-Wl,-z,nobtcfi")
1534 }
1535 if ctxt.Arch.InFamily(sys.ARM64) {
1536
1537
1538
1539 argv = append(argv, "-Wl,--no-execute-only")
1540 }
1541 case objabi.Hwindows:
1542 isMSVC = ctxt.isMSVC()
1543 isLLD = ctxt.isLLD()
1544 if isMSVC {
1545
1546
1547
1548
1549 wlPrefix = "-Wl,-"
1550 }
1551
1552 if windowsgui {
1553 argv = append(argv, "-mwindows")
1554 } else {
1555 argv = append(argv, "-mconsole")
1556 }
1557
1558
1559
1560 argv = append(argv, wlPrefix+"tsaware")
1561
1562
1563 argv = append(argv, wlPrefix+"nxcompat")
1564
1565 if !isMSVC {
1566 peMajorVersion := PeMinimumTargetMajorVersion
1567 peMinorVersion := PeMinimumTargetMinorVersion
1568 if peMajorVersion >= 10 && !isLLD &&
1569 !peHasLoadConfigDirectorySupport(ctxt.Arch, ctxt.extld()) {
1570
1571
1572
1573
1574
1575 peMajorVersion = 6
1576 peMinorVersion = 1
1577 }
1578 argv = append(argv, fmt.Sprintf("-Wl,--major-os-version=%d", peMajorVersion))
1579 argv = append(argv, fmt.Sprintf("-Wl,--minor-os-version=%d", peMinorVersion))
1580 argv = append(argv, fmt.Sprintf("-Wl,--major-subsystem-version=%d", peMajorVersion))
1581 argv = append(argv, fmt.Sprintf("-Wl,--minor-subsystem-version=%d", peMinorVersion))
1582 }
1583 case objabi.Haix:
1584 argv = append(argv, "-pthread")
1585
1586
1587 argv = append(argv, "-Wl,-bnoobjreorder")
1588
1589
1590 argv = append(argv, "-mcmodel=large")
1591 argv = append(argv, "-Wl,-bbigtoc")
1592 }
1593
1594
1595
1596
1597 if ctxt.IsPPC64() && ctxt.IsElf() && buildcfg.GOPPC64 >= 10 {
1598 if !linkerFlagSupported(ctxt.Arch, ctxt.extld(), "", "-mcpu=power10") {
1599 Exitf("The external toolchain does not support -mcpu=power10. " +
1600 " This is required to externally link GOPPC64 >= power10")
1601 }
1602 }
1603
1604
1605 addASLRargs := func(argv []string, val bool) []string {
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621 var dbopt string
1622 var heopt string
1623 dbon := wlPrefix + "dynamicbase"
1624 heon := wlPrefix + "high-entropy-va"
1625 dboff := wlPrefix + "disable-dynamicbase"
1626 heoff := wlPrefix + "disable-high-entropy-va"
1627 if isMSVC {
1628 heon = wlPrefix + "highentropyva"
1629 heoff = wlPrefix + "highentropyva:no"
1630 dboff = wlPrefix + "dynamicbase:no"
1631 }
1632 if val {
1633 dbopt = dbon
1634 heopt = heon
1635 } else {
1636
1637 newer := linkerFlagSupported(ctxt.Arch, ctxt.extld(), "", dboff)
1638 if newer {
1639
1640 dbopt = dboff
1641 heopt = heoff
1642 } else {
1643
1644
1645 dbopt = ""
1646 heopt = ""
1647 }
1648 }
1649 if dbopt != "" {
1650 argv = append(argv, dbopt)
1651 }
1652
1653 if ctxt.Arch.PtrSize >= 8 && heopt != "" {
1654 argv = append(argv, heopt)
1655 }
1656 return argv
1657 }
1658
1659 switch ctxt.BuildMode {
1660 case BuildModeExe:
1661 if ctxt.HeadType == objabi.Hdarwin {
1662 if machoPlatform == PLATFORM_MACOS && ctxt.IsAMD64() {
1663 argv = append(argv, "-Wl,-no_pie")
1664 }
1665 }
1666 if *flagRace && ctxt.HeadType == objabi.Hwindows {
1667
1668
1669
1670
1671 argv = addASLRargs(argv, false)
1672 }
1673 case BuildModePIE:
1674 switch ctxt.HeadType {
1675 case objabi.Hdarwin, objabi.Haix:
1676 case objabi.Hwindows:
1677 if *flagAslr && *flagRace {
1678
1679
1680
1681 *flagAslr = false
1682 }
1683 argv = addASLRargs(argv, *flagAslr)
1684 default:
1685
1686 if ctxt.UseRelro() {
1687 argv = append(argv, "-Wl,-z,relro")
1688 }
1689 argv = append(argv, "-pie")
1690 }
1691 case BuildModeCShared:
1692 if ctxt.HeadType == objabi.Hdarwin {
1693 argv = append(argv, "-dynamiclib")
1694 } else {
1695 if ctxt.UseRelro() {
1696 argv = append(argv, "-Wl,-z,relro")
1697 }
1698 argv = append(argv, "-shared")
1699 if ctxt.HeadType == objabi.Hwindows {
1700 argv = addASLRargs(argv, *flagAslr)
1701 } else {
1702
1703
1704 argv = append(argv, "-Wl,-z,nodelete")
1705
1706 argv = append(argv, "-Wl,-Bsymbolic")
1707 }
1708 }
1709 case BuildModeShared:
1710 if ctxt.UseRelro() {
1711 argv = append(argv, "-Wl,-z,relro")
1712 }
1713 argv = append(argv, "-shared")
1714 case BuildModePlugin:
1715 if ctxt.HeadType == objabi.Hdarwin {
1716 argv = append(argv, "-dynamiclib")
1717 } else {
1718 if ctxt.UseRelro() {
1719 argv = append(argv, "-Wl,-z,relro")
1720 }
1721 argv = append(argv, "-shared")
1722 }
1723 }
1724
1725 var altLinker string
1726 if ctxt.IsELF && (ctxt.DynlinkingGo() || *flagBindNow) {
1727
1728
1729
1730
1731
1732 argv = append(argv, "-Wl,-z,now")
1733 }
1734
1735 if ctxt.IsELF && ctxt.DynlinkingGo() {
1736
1737
1738
1739 argv = append(argv, "-Wl,-z,nocopyreloc")
1740
1741 if buildcfg.GOOS == "android" {
1742
1743 altLinker = "lld"
1744 }
1745
1746 if ctxt.Arch.InFamily(sys.ARM64) && buildcfg.GOOS == "linux" {
1747
1748
1749
1750
1751
1752
1753
1754 useGold := false
1755 name, args := flagExtld[0], flagExtld[1:]
1756 args = append(args, "-Wl,--version")
1757 cmd := exec.Command(name, args...)
1758 if out, err := cmd.CombinedOutput(); err == nil {
1759
1760 for line := range strings.Lines(string(out)) {
1761 if !strings.HasPrefix(line, "GNU ld ") {
1762 continue
1763 }
1764 fields := strings.Fields(line[len("GNU ld "):])
1765 var major, minor int
1766 if ret, err := fmt.Sscanf(fields[len(fields)-1], "%d.%d", &major, &minor); ret == 2 && err == nil {
1767 if major == 2 && minor <= 35 {
1768 useGold = true
1769 }
1770 break
1771 }
1772 }
1773 }
1774
1775 if useGold {
1776
1777 altLinker = "gold"
1778
1779
1780
1781
1782 args = flagExtld[1:]
1783 args = append(args, "-fuse-ld=gold", "-Wl,--version")
1784 cmd = exec.Command(name, args...)
1785 if out, err := cmd.CombinedOutput(); err == nil {
1786 if !bytes.Contains(out, []byte("GNU gold")) {
1787 log.Fatalf("ARM64 external linker must be ld>=2.36 or gold (issue #15696, 22040), but is not: %s", out)
1788 }
1789 }
1790 }
1791 }
1792 }
1793 if ctxt.Arch.Family == sys.ARM64 && buildcfg.GOOS == "freebsd" {
1794
1795 altLinker = "bfd"
1796
1797
1798 name, args := flagExtld[0], flagExtld[1:]
1799 args = append(args, "-fuse-ld=bfd", "-Wl,--version")
1800 cmd := exec.Command(name, args...)
1801 if out, err := cmd.CombinedOutput(); err == nil {
1802 if !bytes.Contains(out, []byte("GNU ld")) {
1803 log.Fatalf("ARM64 external linker must be ld.bfd (issue #35197), please install devel/binutils")
1804 }
1805 }
1806 }
1807 if altLinker != "" {
1808 argv = append(argv, "-fuse-ld="+altLinker)
1809 }
1810
1811 if ctxt.IsELF && linkerFlagSupported(ctxt.Arch, ctxt.extld(), "", "-Wl,--build-id=0x1234567890abcdef") {
1812 if len(buildinfo) > 0 {
1813 argv = append(argv, fmt.Sprintf("-Wl,--build-id=0x%x", buildinfo))
1814 } else if *flagHostBuildid == "none" {
1815 argv = append(argv, "-Wl,--build-id=none")
1816 }
1817 }
1818
1819
1820
1821
1822
1823
1824
1825 outopt := *flagOutfile
1826 if buildcfg.GOOS == "windows" && runtime.GOOS == "windows" && filepath.Ext(outopt) == "" {
1827 outopt += "."
1828 }
1829 argv = append(argv, "-o")
1830 argv = append(argv, outopt)
1831
1832 if rpath.val != "" {
1833 argv = append(argv, fmt.Sprintf("-Wl,-rpath,%s", rpath.val))
1834 }
1835
1836 if *flagInterpreter != "" {
1837 if strings.Contains(*flagInterpreter, ",") {
1838 Exitf("invalid dynamic linker path %q", *flagInterpreter)
1839 }
1840
1841
1842
1843
1844 argv = append(argv, fmt.Sprintf("-Wl,--dynamic-linker=%s", *flagInterpreter))
1845 }
1846
1847
1848 switch {
1849 case ctxt.IsELF:
1850 if ctxt.DynlinkingGo() || ctxt.BuildMode == BuildModeCShared || !linkerFlagSupported(ctxt.Arch, ctxt.extld(), altLinker, "-Wl,--export-dynamic-symbol=main") {
1851 argv = append(argv, "-rdynamic")
1852 } else {
1853 var exports []string
1854 ctxt.loader.ForAllCgoExportDynamic(func(s loader.Sym) {
1855 extname := ctxt.loader.SymExtname(s)
1856 if strings.Contains(extname, ",") {
1857 Exitf("invalid exported symbol name %q", extname)
1858 }
1859 exports = append(exports, "-Wl,--export-dynamic-symbol="+extname)
1860 })
1861 sort.Strings(exports)
1862 argv = append(argv, exports...)
1863 }
1864 case ctxt.IsAIX():
1865 fileName := xcoffCreateExportFile(ctxt)
1866 argv = append(argv, "-Wl,-bE:"+fileName)
1867 case ctxt.IsWindows() && !slices.Contains(flagExtldflags, wlPrefix+"export-all-symbols"):
1868 fileName := peCreateExportFile(ctxt, filepath.Base(outopt))
1869 prefix := ""
1870 if isMSVC {
1871 prefix = "-Wl,-def:"
1872 }
1873 argv = append(argv, prefix+fileName)
1874 }
1875
1876 const unusedArguments = "-Qunused-arguments"
1877 if linkerFlagSupported(ctxt.Arch, ctxt.extld(), altLinker, unusedArguments) {
1878 argv = append(argv, unusedArguments)
1879 }
1880
1881 if ctxt.IsWindows() {
1882
1883
1884
1885
1886 const noTimeStamp = "-Wl,--no-insert-timestamp"
1887 if linkerFlagSupported(ctxt.Arch, ctxt.extld(), altLinker, noTimeStamp) {
1888 argv = append(argv, noTimeStamp)
1889 }
1890 }
1891
1892 const compressDWARF = "-Wl,--compress-debug-sections=zlib"
1893 if ctxt.compressDWARF && linkerFlagSupported(ctxt.Arch, ctxt.extld(), altLinker, compressDWARF) {
1894 argv = append(argv, compressDWARF)
1895 }
1896
1897 hostObjCopyPaths := ctxt.hostobjCopy()
1898 cleanTimeStamps(hostObjCopyPaths)
1899 godotopath := filepath.Join(*flagTmpdir, "go.o")
1900 cleanTimeStamps([]string{godotopath})
1901
1902 argv = append(argv, godotopath)
1903 argv = append(argv, hostObjCopyPaths...)
1904 if ctxt.HeadType == objabi.Haix {
1905
1906
1907 argv = append(argv, "-nostartfiles")
1908
1909 extld := ctxt.extld()
1910 name, args := extld[0], extld[1:]
1911
1912 getPathFile := func(file string) string {
1913 args := append(args, "-maix64", "--print-file-name="+file)
1914 out, err := exec.Command(name, args...).CombinedOutput()
1915 if err != nil {
1916 log.Fatalf("running %s failed: %v\n%s", extld, err, out)
1917 }
1918 return strings.Trim(string(out), "\n")
1919 }
1920 argv = append(argv, getPathFile("crt0_64.o"))
1921
1922
1923
1924 crtcxa := getPathFile("crtcxa_64.o")
1925 if !filepath.IsAbs(crtcxa) {
1926 crtcxa = getPathFile("crtcxa.o")
1927 }
1928 crtdbase := getPathFile("crtdbase_64.o")
1929 if !filepath.IsAbs(crtdbase) {
1930 crtdbase = getPathFile("crtdbase.o")
1931 }
1932 argv = append(argv, crtcxa)
1933 argv = append(argv, crtdbase)
1934 }
1935
1936 if ctxt.linkShared {
1937 seenDirs := make(map[string]bool)
1938 seenLibs := make(map[string]bool)
1939 addshlib := func(path string) {
1940 dir, base := filepath.Split(path)
1941 if !seenDirs[dir] {
1942 argv = append(argv, "-L"+dir)
1943 if !rpath.set {
1944 argv = append(argv, "-Wl,-rpath="+dir)
1945 }
1946 seenDirs[dir] = true
1947 }
1948 base = strings.TrimSuffix(base, ".so")
1949 base = strings.TrimPrefix(base, "lib")
1950 if !seenLibs[base] {
1951 argv = append(argv, "-l"+base)
1952 seenLibs[base] = true
1953 }
1954 }
1955 for _, shlib := range ctxt.Shlibs {
1956 addshlib(shlib.Path)
1957 for _, dep := range shlib.Deps {
1958 if dep == "" {
1959 continue
1960 }
1961 libpath := findshlib(ctxt, dep)
1962 if libpath != "" {
1963 addshlib(libpath)
1964 }
1965 }
1966 }
1967 }
1968
1969
1970
1971
1972
1973
1974
1975
1976 checkStatic := func(arg string) {
1977 if ctxt.IsELF && arg == "-static" {
1978 for i := range argv {
1979 if argv[i] == "-rdynamic" || strings.HasPrefix(argv[i], "-Wl,--dynamic-linker=") {
1980 argv[i] = "-static"
1981 }
1982 }
1983 }
1984 }
1985
1986 for _, p := range ldflag {
1987 argv = append(argv, p)
1988 checkStatic(p)
1989 }
1990
1991
1992
1993
1994
1995
1996
1997
1998 if ctxt.BuildMode == BuildModeExe && !ctxt.linkShared && !(ctxt.IsDarwin() && ctxt.IsARM64()) {
1999
2000 for _, nopie := range []string{"-no-pie", "-nopie"} {
2001 if linkerFlagSupported(ctxt.Arch, ctxt.extld(), altLinker, nopie) {
2002 argv = append(argv, nopie)
2003 break
2004 }
2005 }
2006 }
2007
2008 for _, p := range flagExtldflags {
2009 argv = append(argv, p)
2010 checkStatic(p)
2011 }
2012 if ctxt.HeadType == objabi.Hwindows {
2013
2014
2015 if !isLLD {
2016 p := writeGDBLinkerScript()
2017 argv = append(argv, "-Wl,-T,"+p)
2018 }
2019 if *flagRace {
2020
2021
2022
2023
2024 if isMSVC || ctxt.findLibPath("libsynchronization.a") != "libsynchronization.a" {
2025 argv = append(argv, "-lsynchronization")
2026 }
2027 }
2028 if !isMSVC {
2029
2030
2031 argv = append(argv, "-Wl,--start-group", "-lmingwex", "-lmingw32", "-Wl,--end-group")
2032 }
2033 argv = append(argv, peimporteddlls()...)
2034 }
2035
2036 argv = ctxt.passLongArgsInResponseFile(argv, altLinker)
2037
2038 if ctxt.Debugvlog != 0 {
2039 ctxt.Logf("host link:")
2040 for _, v := range argv {
2041 ctxt.Logf(" %q", v)
2042 }
2043 ctxt.Logf("\n")
2044 }
2045
2046 cmd := exec.Command(argv[0], argv[1:]...)
2047 out, err := cmd.CombinedOutput()
2048 if err != nil {
2049 Exitf("running %s failed: %v\n%s\n%s", argv[0], err, cmd, out)
2050 }
2051
2052
2053
2054 var save [][]byte
2055 var skipLines int
2056 for _, line := range bytes.SplitAfter(out, []byte("\n")) {
2057
2058 if bytes.Contains(line, []byte("ld: warning: text-based stub file")) {
2059 continue
2060 }
2061
2062 if skipLines > 0 {
2063 skipLines--
2064 continue
2065 }
2066
2067
2068 if bytes.Contains(line, []byte("ld: 0711-783")) {
2069 skipLines = 2
2070 continue
2071 }
2072
2073 save = append(save, line)
2074 }
2075 out = bytes.Join(save, nil)
2076
2077 if len(out) > 0 {
2078
2079
2080 if ctxt.IsDarwin() && ctxt.IsAMD64() {
2081 const noPieWarning = "ld: warning: -no_pie is deprecated when targeting new OS versions\n"
2082 if i := bytes.Index(out, []byte(noPieWarning)); i >= 0 {
2083
2084 out = append(out[:i], out[i+len(noPieWarning):]...)
2085 }
2086 }
2087 if ctxt.IsDarwin() {
2088 const bindAtLoadWarning = "ld: warning: -bind_at_load is deprecated on macOS\n"
2089 if i := bytes.Index(out, []byte(bindAtLoadWarning)); i >= 0 {
2090
2091
2092
2093
2094 out = append(out[:i], out[i+len(bindAtLoadWarning):]...)
2095 }
2096 }
2097 ctxt.Logf("%s", out)
2098 }
2099
2100
2101
2102 updateMachoOutFile := func(op string, updateFunc machoUpdateFunc) {
2103
2104 rewrittenOutput := *flagOutfile + "~"
2105 exef, err := os.Open(*flagOutfile)
2106 if err != nil {
2107 Exitf("%s: %s failed: %v", os.Args[0], op, err)
2108 }
2109 defer exef.Close()
2110 exem, err := macho.NewFile(exef)
2111 if err != nil {
2112 Exitf("%s: parsing Mach-O header failed: %v", os.Args[0], err)
2113 }
2114 if err := updateFunc(ctxt, exef, exem, rewrittenOutput); err != nil {
2115 Exitf("%s: %s failed: %v", os.Args[0], op, err)
2116 }
2117 os.Remove(*flagOutfile)
2118 if err := os.Rename(rewrittenOutput, *flagOutfile); err != nil {
2119 Exitf("%s: %v", os.Args[0], err)
2120 }
2121 }
2122
2123 if ctxt.IsDarwin() && !combineDwarf && len(buildinfo) > 0 {
2124
2125
2126 updateMachoOutFile("rewriting uuid",
2127 func(ctxt *Link, exef *os.File, exem *macho.File, outexe string) error {
2128 return machoRewriteUuid(ctxt, exef, exem, outexe)
2129 })
2130 }
2131 if machoDwarf {
2132
2133 dsymutilCmd := ctxt.findExtLinkTool("dsymutil")
2134 stripCmd := ctxt.findExtLinkTool("strip")
2135
2136 dsym := filepath.Join(*flagTmpdir, "go.dwarf")
2137 if *FlagSplitDWARF {
2138 dsym = filepath.Join(*flagOutfile+".dSYM", "Contents", "Resources", "DWARF", filepath.Base(*flagOutfile))
2139 if err := os.MkdirAll(filepath.Dir(dsym), 0777); err != nil {
2140 Exitf("fail to create dSYM dir: %v", err)
2141 }
2142 }
2143 cmd := exec.Command(dsymutilCmd, "-f", *flagOutfile, "-o", dsym)
2144
2145
2146
2147
2148
2149 dsymDir := filepath.Join(*flagTmpdir, "dsymutil")
2150 err := os.MkdirAll(dsymDir, 0777)
2151 if err != nil {
2152 Exitf("fail to create temp dir: %v", err)
2153 }
2154 cmd.Env = append(os.Environ(), "DSYMUTIL_REPRODUCER_PATH="+dsymDir)
2155 if ctxt.Debugvlog != 0 {
2156 ctxt.Logf("host link dsymutil:")
2157 for _, v := range cmd.Args {
2158 ctxt.Logf(" %q", v)
2159 }
2160 ctxt.Logf("\n")
2161 }
2162 if out, err := cmd.CombinedOutput(); err != nil {
2163 Exitf("%s: running dsymutil failed: %v\n%s\n%s", os.Args[0], err, cmd, out)
2164 }
2165
2166
2167 var stripArgs = []string{"-S"}
2168 if debug_s {
2169
2170
2171
2172 stripArgs = append(stripArgs, "-x")
2173 }
2174 stripArgs = append(stripArgs, *flagOutfile)
2175 if ctxt.Debugvlog != 0 {
2176 ctxt.Logf("host link strip: %q", stripCmd)
2177 for _, v := range stripArgs {
2178 ctxt.Logf(" %q", v)
2179 }
2180 ctxt.Logf("\n")
2181 }
2182 cmd = exec.Command(stripCmd, stripArgs...)
2183 if out, err := cmd.CombinedOutput(); err != nil {
2184 Exitf("%s: running strip failed: %v\n%s\n%s", os.Args[0], err, cmd, out)
2185 }
2186 if combineDwarf {
2187
2188 if _, err := os.Stat(dsym); err == nil {
2189 updateMachoOutFile("combining dwarf",
2190 func(ctxt *Link, exef *os.File, exem *macho.File, outexe string) error {
2191 return machoCombineDwarf(ctxt, exef, exem, dsym, outexe)
2192 })
2193 } else if len(buildinfo) > 0 {
2194 updateMachoOutFile("rewriting uuid",
2195 func(ctxt *Link, exef *os.File, exem *macho.File, outexe string) error {
2196 return machoRewriteUuid(ctxt, exef, exem, outexe)
2197 })
2198 }
2199 } else {
2200
2201 if _, err := os.Stat(dsym); err != nil {
2202 os.RemoveAll(*flagOutfile + ".dSYM")
2203 }
2204 }
2205 }
2206 hostlinkfips(ctxt, *flagOutfile, *flagFipso)
2207 if ctxt.NeedCodeSign() {
2208 err := machoCodeSign(ctxt, *flagOutfile)
2209 if err != nil {
2210 Exitf("%s: code signing failed: %v", os.Args[0], err)
2211 }
2212 }
2213 }
2214
2215
2216
2217 func (ctxt *Link) passLongArgsInResponseFile(argv []string, altLinker string) []string {
2218 c := 0
2219 for _, arg := range argv {
2220 c += len(arg)
2221 }
2222
2223 if c < sys.ExecArgLengthLimit {
2224 return argv
2225 }
2226
2227
2228 response := filepath.Join(*flagTmpdir, "response")
2229 if err := os.WriteFile(response, nil, 0644); err != nil {
2230 log.Fatalf("failed while testing response file: %v", err)
2231 }
2232 if !linkerFlagSupported(ctxt.Arch, ctxt.extld(), altLinker, "@"+response) {
2233 if ctxt.Debugvlog != 0 {
2234 ctxt.Logf("not using response file because linker does not support one")
2235 }
2236 return argv
2237 }
2238
2239
2240
2241
2242
2243 nextld := len(ctxt.extld())
2244
2245 var buf bytes.Buffer
2246 for _, arg := range argv[nextld:] {
2247
2248 fmt.Fprintf(&buf, "%q\n", arg)
2249 }
2250 if err := os.WriteFile(response, buf.Bytes(), 0644); err != nil {
2251 log.Fatalf("failed while writing response file: %v", err)
2252 }
2253 if ctxt.Debugvlog != 0 {
2254 ctxt.Logf("response file %s contents:\n%s", response, buf.Bytes())
2255 }
2256 return append(slices.Clone(argv[:nextld]), "@"+response)
2257 }
2258
2259 var createTrivialCOnce sync.Once
2260
2261
2262
2263 func linkerFlagSupported(arch *sys.Arch, linker []string, altLinker, flag string) bool {
2264 createTrivialCOnce.Do(func() {
2265 src := filepath.Join(*flagTmpdir, "trivial.c")
2266 if err := os.WriteFile(src, []byte("int main() { return 0; }"), 0666); err != nil {
2267 Errorf("WriteFile trivial.c failed: %v", err)
2268 }
2269 })
2270
2271
2272
2273
2274 flags := slices.Concat(linker[1:], hostlinkArchArgs(arch))
2275
2276 moreFlags := trimLinkerArgv(append(ldflag, flagExtldflags...))
2277 flags = append(flags, moreFlags...)
2278
2279 if altLinker != "" {
2280 flags = append(flags, "-fuse-ld="+altLinker)
2281 }
2282 trivialPath := filepath.Join(*flagTmpdir, "trivial.c")
2283 outPath := filepath.Join(*flagTmpdir, "a.out")
2284 flags = append(flags, "-o", outPath, flag, trivialPath)
2285
2286 cmd := exec.Command(linker[0], flags...)
2287 cmd.Env = append([]string{"LC_ALL=C"}, os.Environ()...)
2288 out, err := cmd.CombinedOutput()
2289
2290
2291 return err == nil && !bytes.Contains(out, []byte("unrecognized")) && !bytes.Contains(out, []byte("unknown"))
2292 }
2293
2294
2295
2296
2297
2298
2299
2300 func peHasLoadConfigDirectorySupport(arch *sys.Arch, linker []string) bool {
2301 src := filepath.Join(*flagTmpdir, "loadcfg_test.c")
2302 if err := os.WriteFile(src, []byte(`
2303 #ifdef _WIN64
2304 typedef unsigned long long uintptr;
2305 #else
2306 typedef unsigned long uintptr;
2307 #endif
2308 const uintptr _load_config_used[2] = { sizeof(_load_config_used), 0 };
2309 int main() { return 0; }
2310 `), 0666); err != nil {
2311 return false
2312 }
2313
2314 outPath := filepath.Join(*flagTmpdir, "loadcfg_test.exe")
2315 flags := slices.Concat(linker[1:], hostlinkArchArgs(arch))
2316 flags = append(flags, "-o", outPath, src)
2317 cmd := exec.Command(linker[0], flags...)
2318 cmd.Env = append([]string{"LC_ALL=C"}, os.Environ()...)
2319 if err := cmd.Run(); err != nil {
2320 return false
2321 }
2322
2323 f, err := pe.Open(outPath)
2324 if err != nil {
2325 return false
2326 }
2327 defer f.Close()
2328
2329 switch oh := f.OptionalHeader.(type) {
2330 case *pe.OptionalHeader64:
2331 if int(pe.IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG) < len(oh.DataDirectory) {
2332 return oh.DataDirectory[pe.IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG].VirtualAddress != 0
2333 }
2334 case *pe.OptionalHeader32:
2335 if int(pe.IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG) < len(oh.DataDirectory) {
2336 return oh.DataDirectory[pe.IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG].VirtualAddress != 0
2337 }
2338 }
2339 return false
2340 }
2341
2342
2343
2344 func trimLinkerArgv(argv []string) []string {
2345 flagsWithNextArgSkip := []string{
2346 "-F",
2347 "-l",
2348 "-framework",
2349 "-Wl,-framework",
2350 "-Wl,-rpath",
2351 "-Wl,-undefined",
2352 }
2353 flagsWithNextArgKeep := []string{
2354 "-B",
2355 "-L",
2356 "-arch",
2357 "-isysroot",
2358 "--sysroot",
2359 "-target",
2360 "--target",
2361 "-resource-dir",
2362 "-rtlib",
2363 "--rtlib",
2364 "-stdlib",
2365 "--stdlib",
2366 "-unwindlib",
2367 "--unwindlib",
2368 }
2369 prefixesToKeep := []string{
2370 "-B",
2371 "-L",
2372 "-f",
2373 "-m",
2374 "-p",
2375 "-Wl,",
2376 "-arch",
2377 "-isysroot",
2378 "--sysroot",
2379 "-target",
2380 "--target",
2381 "-resource-dir",
2382 "-rtlib",
2383 "--rtlib",
2384 "-stdlib",
2385 "--stdlib",
2386 "-unwindlib",
2387 "--unwindlib",
2388 "-nostdlib++",
2389 "-nostdlib",
2390 "-nodefaultlibs",
2391 "-nostartfiles",
2392 "-nostdinc++",
2393 "-nostdinc",
2394 "-nobuiltininc",
2395 }
2396
2397 var flags []string
2398 keep := false
2399 skip := false
2400 for _, f := range argv {
2401 if keep {
2402 flags = append(flags, f)
2403 keep = false
2404 } else if skip {
2405 skip = false
2406 } else if f == "" || f[0] != '-' {
2407 } else if slices.Contains(flagsWithNextArgSkip, f) {
2408 skip = true
2409 } else if slices.Contains(flagsWithNextArgKeep, f) {
2410 flags = append(flags, f)
2411 keep = true
2412 } else {
2413 for _, p := range prefixesToKeep {
2414 if strings.HasPrefix(f, p) {
2415 flags = append(flags, f)
2416 break
2417 }
2418 }
2419 }
2420 }
2421 return flags
2422 }
2423
2424
2425
2426 func hostlinkArchArgs(arch *sys.Arch) []string {
2427 switch arch.Family {
2428 case sys.I386:
2429 return []string{"-m32"}
2430 case sys.AMD64:
2431 if buildcfg.GOOS == "darwin" {
2432 return []string{"-arch", "x86_64", "-m64"}
2433 }
2434 return []string{"-m64"}
2435 case sys.S390X:
2436 return []string{"-m64"}
2437 case sys.ARM:
2438 return []string{"-marm"}
2439 case sys.ARM64:
2440 if buildcfg.GOOS == "darwin" {
2441 return []string{"-arch", "arm64"}
2442 }
2443 case sys.Loong64:
2444 return []string{"-mabi=lp64d"}
2445 case sys.MIPS64:
2446 return []string{"-mabi=64"}
2447 case sys.MIPS:
2448 return []string{"-mabi=32"}
2449 case sys.PPC64:
2450 if buildcfg.GOOS == "aix" {
2451 return []string{"-maix64"}
2452 } else {
2453 return []string{"-m64"}
2454 }
2455
2456 }
2457 return nil
2458 }
2459
2460 var wantHdr = objabi.HeaderString()
2461
2462
2463
2464
2465 func ldobj(ctxt *Link, f *bio.Reader, lib *sym.Library, length int64, pn string, file string) *Hostobj {
2466 pkg := objabi.PathToPrefix(lib.Pkg)
2467
2468 eof := f.Offset() + length
2469 start := f.Offset()
2470 c1 := bgetc(f)
2471 c2 := bgetc(f)
2472 c3 := bgetc(f)
2473 c4 := bgetc(f)
2474 f.MustSeek(start, 0)
2475
2476 unit := &sym.CompilationUnit{Lib: lib}
2477 lib.Units = append(lib.Units, unit)
2478
2479 magic := uint32(c1)<<24 | uint32(c2)<<16 | uint32(c3)<<8 | uint32(c4)
2480 if magic == 0x7f454c46 {
2481 ldelf := func(ctxt *Link, f *bio.Reader, pkg string, length int64, pn string) {
2482 textp, flags, err := loadelf.Load(ctxt.loader, ctxt.Arch, ctxt.IncVersion(), f, pkg, length, pn, ehdr.Flags)
2483 if err != nil {
2484 Errorf("%v", err)
2485 return
2486 }
2487 ehdr.Flags = flags
2488 ctxt.Textp = append(ctxt.Textp, textp...)
2489 }
2490 return ldhostobj(ldelf, ctxt.HeadType, f, pkg, length, pn, file)
2491 }
2492
2493 if magic&^1 == 0xfeedface || magic&^0x01000000 == 0xcefaedfe {
2494 ldmacho := func(ctxt *Link, f *bio.Reader, pkg string, length int64, pn string) {
2495 textp, err := loadmacho.Load(ctxt.loader, ctxt.Arch, ctxt.IncVersion(), f, pkg, length, pn)
2496 if err != nil {
2497 Errorf("%v", err)
2498 return
2499 }
2500 ctxt.Textp = append(ctxt.Textp, textp...)
2501 }
2502 return ldhostobj(ldmacho, ctxt.HeadType, f, pkg, length, pn, file)
2503 }
2504
2505 switch c1<<8 | c2 {
2506 case 0x4c01,
2507 0x6486,
2508 0xc401,
2509 0x64aa:
2510 ldpe := func(ctxt *Link, f *bio.Reader, pkg string, length int64, pn string) {
2511 ls, err := loadpe.Load(ctxt.loader, ctxt.Arch, ctxt.IncVersion(), f, pkg, length, pn)
2512 if err != nil {
2513 Errorf("%v", err)
2514 return
2515 }
2516 if len(ls.Resources) != 0 {
2517 setpersrc(ctxt, ls.Resources)
2518 }
2519 sehp.pdata = append(sehp.pdata, ls.PData...)
2520 if ls.XData != 0 {
2521 sehp.xdata = append(sehp.xdata, ls.XData)
2522 }
2523 ctxt.Textp = append(ctxt.Textp, ls.Textp...)
2524 }
2525 return ldhostobj(ldpe, ctxt.HeadType, f, pkg, length, pn, file)
2526 }
2527
2528 if c1 == 0x01 && (c2 == 0xD7 || c2 == 0xF7) {
2529 ldxcoff := func(ctxt *Link, f *bio.Reader, pkg string, length int64, pn string) {
2530 textp, err := loadxcoff.Load(ctxt.loader, ctxt.Arch, ctxt.IncVersion(), f, pkg, length, pn)
2531 if err != nil {
2532 Errorf("%v", err)
2533 return
2534 }
2535 ctxt.Textp = append(ctxt.Textp, textp...)
2536 }
2537 return ldhostobj(ldxcoff, ctxt.HeadType, f, pkg, length, pn, file)
2538 }
2539
2540
2541
2542
2543
2544
2545 if strings.HasSuffix(file, ".syso") || strings.HasSuffix(pn, ".syso") || strings.HasSuffix(pn, ".syso)") {
2546 Errorf("%s: unsupported object format in .syso file", pn)
2547 return nil
2548 }
2549
2550 if c1 != 'g' || c2 != 'o' || c3 != ' ' || c4 != 'o' {
2551
2552
2553
2554 unknownObjFormat = true
2555 return ldhostobj(nil, ctxt.HeadType, f, pkg, length, pn, file)
2556 }
2557
2558
2559 line, err := f.ReadString('\n')
2560 if err != nil {
2561 Errorf("truncated object file: %s: %v", pn, err)
2562 return nil
2563 }
2564
2565 if !strings.HasPrefix(line, "go object ") {
2566 if strings.HasSuffix(pn, ".go") {
2567 Exitf("%s: uncompiled .go source file", pn)
2568 return nil
2569 }
2570
2571 if line == ctxt.Arch.Name {
2572
2573 Errorf("%s: stale object file", pn)
2574 return nil
2575 }
2576
2577 Errorf("%s: not an object file: @%d %q", pn, start, line)
2578 return nil
2579 }
2580
2581
2582 if line != wantHdr && !*flagF {
2583 Errorf("%s: linked object header mismatch:\nhave %q\nwant %q\n", pn, line, wantHdr)
2584 }
2585
2586
2587
2588
2589
2590
2591
2592
2593 import0 := f.Offset()
2594
2595 c1 = '\n'
2596 c2 = bgetc(f)
2597 c3 = bgetc(f)
2598 markers := 0
2599 for {
2600 if c1 == '\n' {
2601 if markers%2 == 0 && c2 == '!' && c3 == '\n' {
2602 break
2603 }
2604 if c2 == '$' && c3 == '$' {
2605 markers++
2606 }
2607 }
2608
2609 c1 = c2
2610 c2 = c3
2611 c3 = bgetc(f)
2612 if c3 == -1 {
2613 Errorf("truncated object file: %s", pn)
2614 return nil
2615 }
2616 }
2617
2618 import1 := f.Offset()
2619
2620 f.MustSeek(import0, 0)
2621 ldpkg(ctxt, f, lib, import1-import0-2, pn)
2622 f.MustSeek(import1, 0)
2623
2624 fingerprint := ctxt.loader.Preload(ctxt.IncVersion(), f, lib, unit, eof-f.Offset())
2625 if !fingerprint.IsZero() {
2626
2627
2628
2629
2630
2631 if lib.Fingerprint.IsZero() {
2632 lib.Fingerprint = fingerprint
2633 }
2634 checkFingerprint(lib, fingerprint, lib.Srcref, lib.Fingerprint)
2635 }
2636
2637 addImports(ctxt, lib, pn)
2638 return nil
2639 }
2640
2641
2642
2643
2644
2645 func symbolsAreUnresolved(ctxt *Link, want []string) []bool {
2646 returnAllUndefs := -1
2647 undefs, _ := ctxt.loader.UndefinedRelocTargets(returnAllUndefs)
2648 seen := make(map[loader.Sym]struct{})
2649 rval := make([]bool, len(want))
2650 wantm := make(map[string]int)
2651 for k, w := range want {
2652 wantm[w] = k
2653 }
2654 count := 0
2655 for _, s := range undefs {
2656 if _, ok := seen[s]; ok {
2657 continue
2658 }
2659 seen[s] = struct{}{}
2660 if k, ok := wantm[ctxt.loader.SymName(s)]; ok {
2661 rval[k] = true
2662 count++
2663 if count == len(want) {
2664 return rval
2665 }
2666 }
2667 }
2668 return rval
2669 }
2670
2671
2672
2673
2674 func hostObject(ctxt *Link, objname string, path string) {
2675 if ctxt.Debugvlog > 1 {
2676 ctxt.Logf("hostObject(%s)\n", path)
2677 }
2678 objlib := sym.Library{
2679 Pkg: objname,
2680 }
2681 f, err := bio.Open(path)
2682 if err != nil {
2683 Exitf("cannot open host object %q file %s: %v", objname, path, err)
2684 }
2685 defer f.Close()
2686 h := ldobj(ctxt, f, &objlib, 0, path, path)
2687 if h.ld == nil {
2688 Exitf("unrecognized object file format in %s", path)
2689 }
2690 h.file = path
2691 h.length = f.MustSeek(0, 2)
2692 f.MustSeek(h.off, 0)
2693 h.ld(ctxt, f, h.pkg, h.length, h.pn)
2694 if *flagCaptureHostObjs != "" {
2695 captureHostObj(h)
2696 }
2697 }
2698
2699 func checkFingerprint(lib *sym.Library, libfp goobj.FingerprintType, src string, srcfp goobj.FingerprintType) {
2700 if libfp != srcfp {
2701 Exitf("fingerprint mismatch: %s has %x, import from %s expecting %x", lib, libfp, src, srcfp)
2702 }
2703 }
2704
2705 func readelfsymboldata(ctxt *Link, f *elf.File, sym *elf.Symbol) []byte {
2706 data := make([]byte, sym.Size)
2707 sect := f.Sections[sym.Section]
2708 if sect.Type != elf.SHT_PROGBITS && sect.Type != elf.SHT_NOTE {
2709 Errorf("reading %s from non-data section", sym.Name)
2710 }
2711 n, err := sect.ReadAt(data, int64(sym.Value-sect.Addr))
2712 if uint64(n) != sym.Size {
2713 Errorf("reading contents of %s: %v", sym.Name, err)
2714 }
2715 return data
2716 }
2717
2718 func readwithpad(r io.Reader, sz int32) ([]byte, error) {
2719 data := make([]byte, Rnd(int64(sz), 4))
2720 _, err := io.ReadFull(r, data)
2721 if err != nil {
2722 return nil, err
2723 }
2724 data = data[:sz]
2725 return data, nil
2726 }
2727
2728 func readnote(f *elf.File, name []byte, typ int32) ([]byte, error) {
2729 for _, sect := range f.Sections {
2730 if sect.Type != elf.SHT_NOTE {
2731 continue
2732 }
2733 r := sect.Open()
2734 for {
2735 var namesize, descsize, noteType int32
2736 err := binary.Read(r, f.ByteOrder, &namesize)
2737 if err != nil {
2738 if err == io.EOF {
2739 break
2740 }
2741 return nil, fmt.Errorf("read namesize failed: %v", err)
2742 }
2743 err = binary.Read(r, f.ByteOrder, &descsize)
2744 if err != nil {
2745 return nil, fmt.Errorf("read descsize failed: %v", err)
2746 }
2747 err = binary.Read(r, f.ByteOrder, ¬eType)
2748 if err != nil {
2749 return nil, fmt.Errorf("read type failed: %v", err)
2750 }
2751 noteName, err := readwithpad(r, namesize)
2752 if err != nil {
2753 return nil, fmt.Errorf("read name failed: %v", err)
2754 }
2755 desc, err := readwithpad(r, descsize)
2756 if err != nil {
2757 return nil, fmt.Errorf("read desc failed: %v", err)
2758 }
2759 if string(name) == string(noteName) && typ == noteType {
2760 return desc, nil
2761 }
2762 }
2763 }
2764 return nil, nil
2765 }
2766
2767 func findshlib(ctxt *Link, shlib string) string {
2768 if filepath.IsAbs(shlib) {
2769 return shlib
2770 }
2771 for _, libdir := range ctxt.Libdir {
2772 libpath := filepath.Join(libdir, shlib)
2773 if _, err := os.Stat(libpath); err == nil {
2774 return libpath
2775 }
2776 }
2777 Errorf("cannot find shared library: %s", shlib)
2778 return ""
2779 }
2780
2781 func ldshlibsyms(ctxt *Link, shlib string) {
2782 var libpath string
2783 if filepath.IsAbs(shlib) {
2784 libpath = shlib
2785 shlib = filepath.Base(shlib)
2786 } else {
2787 libpath = findshlib(ctxt, shlib)
2788 if libpath == "" {
2789 return
2790 }
2791 }
2792 for _, processedlib := range ctxt.Shlibs {
2793 if processedlib.Path == libpath {
2794 return
2795 }
2796 }
2797 if ctxt.Debugvlog > 1 {
2798 ctxt.Logf("ldshlibsyms: found library with name %s at %s\n", shlib, libpath)
2799 }
2800
2801 f, err := elf.Open(libpath)
2802 if err != nil {
2803 Errorf("cannot open shared library: %s", libpath)
2804 return
2805 }
2806
2807
2808
2809
2810 hash, err := readnote(f, ELF_NOTE_GO_NAME, ELF_NOTE_GOABIHASH_TAG)
2811 if err != nil {
2812 Errorf("cannot read ABI hash from shared library %s: %v", libpath, err)
2813 return
2814 }
2815
2816 depsbytes, err := readnote(f, ELF_NOTE_GO_NAME, ELF_NOTE_GODEPS_TAG)
2817 if err != nil {
2818 Errorf("cannot read dep list from shared library %s: %v", libpath, err)
2819 return
2820 }
2821 var deps []string
2822 for _, dep := range strings.Split(string(depsbytes), "\n") {
2823 if dep == "" {
2824 continue
2825 }
2826 if !filepath.IsAbs(dep) {
2827
2828
2829
2830 abs := filepath.Join(filepath.Dir(libpath), dep)
2831 if _, err := os.Stat(abs); err == nil {
2832 dep = abs
2833 }
2834 }
2835 deps = append(deps, dep)
2836 }
2837
2838 syms, err := f.DynamicSymbols()
2839 if err != nil {
2840 Errorf("cannot read symbols from shared library: %s", libpath)
2841 return
2842 }
2843
2844 symAddr := map[string]uint64{}
2845 for _, elfsym := range syms {
2846 if elf.ST_TYPE(elfsym.Info) == elf.STT_NOTYPE || elf.ST_TYPE(elfsym.Info) == elf.STT_SECTION {
2847 continue
2848 }
2849
2850
2851
2852 ver := 0
2853 symname := elfsym.Name
2854 if elf.ST_TYPE(elfsym.Info) == elf.STT_FUNC && strings.HasPrefix(elfsym.Name, "type:") {
2855 ver = abiInternalVer
2856 } else if buildcfg.Experiment.RegabiWrappers && elf.ST_TYPE(elfsym.Info) == elf.STT_FUNC {
2857
2858 if strings.HasSuffix(elfsym.Name, ".abiinternal") {
2859 ver = sym.SymVerABIInternal
2860 symname = strings.TrimSuffix(elfsym.Name, ".abiinternal")
2861 } else if strings.HasSuffix(elfsym.Name, ".abi0") {
2862 ver = 0
2863 symname = strings.TrimSuffix(elfsym.Name, ".abi0")
2864 }
2865 }
2866
2867 l := ctxt.loader
2868 s := l.LookupOrCreateSym(symname, ver)
2869
2870
2871
2872
2873
2874 if l.SymType(s) != 0 && l.SymType(s) != sym.SDYNIMPORT {
2875 continue
2876 }
2877 su := l.MakeSymbolUpdater(s)
2878 su.SetType(sym.SDYNIMPORT)
2879 l.SetSymElfType(s, elf.ST_TYPE(elfsym.Info))
2880 su.SetSize(int64(elfsym.Size))
2881 if elfsym.Section != elf.SHN_UNDEF {
2882
2883 l.SetSymPkg(s, libpath)
2884
2885
2886
2887 sname := l.SymName(s)
2888 if strings.HasPrefix(sname, "type:") && !strings.HasPrefix(sname, "type:.") {
2889 su.SetData(readelfsymboldata(ctxt, f, &elfsym))
2890 }
2891 }
2892
2893 if symname != elfsym.Name {
2894 l.SetSymExtname(s, elfsym.Name)
2895 }
2896 symAddr[elfsym.Name] = elfsym.Value
2897 }
2898
2899
2900
2901
2902 relocTarget := map[uint64]string{}
2903 addends := false
2904 sect := f.SectionByType(elf.SHT_REL)
2905 if sect == nil {
2906 sect = f.SectionByType(elf.SHT_RELA)
2907 if sect == nil {
2908 log.Fatalf("can't find SHT_REL or SHT_RELA section of %s", shlib)
2909 }
2910 addends = true
2911 }
2912
2913 data, err := sect.Data()
2914 if err != nil {
2915 log.Fatalf("can't read relocation section of %s: %v", shlib, err)
2916 }
2917 bo := f.ByteOrder
2918 for len(data) > 0 {
2919 var off, idx uint64
2920 var addend int64
2921 switch f.Class {
2922 case elf.ELFCLASS64:
2923 off = bo.Uint64(data)
2924 info := bo.Uint64(data[8:])
2925 data = data[16:]
2926 if addends {
2927 addend = int64(bo.Uint64(data))
2928 data = data[8:]
2929 }
2930
2931 idx = info >> 32
2932 typ := info & 0xffff
2933
2934
2935 switch typ {
2936 case uint64(elf.R_X86_64_64):
2937 case uint64(elf.R_AARCH64_ABS64):
2938 case uint64(elf.R_LARCH_64):
2939 case uint64(elf.R_390_64):
2940 case uint64(elf.R_PPC64_ADDR64):
2941 default:
2942 continue
2943 }
2944 case elf.ELFCLASS32:
2945 off = uint64(bo.Uint32(data))
2946 info := bo.Uint32(data[4:])
2947 data = data[8:]
2948 if addends {
2949 addend = int64(int32(bo.Uint32(data)))
2950 data = data[4:]
2951 }
2952
2953 idx = uint64(info >> 8)
2954 typ := info & 0xff
2955
2956 switch typ {
2957 case uint32(elf.R_386_32):
2958 case uint32(elf.R_ARM_ABS32):
2959 default:
2960 continue
2961 }
2962 default:
2963 log.Fatalf("unknown bit size %s", f.Class)
2964 }
2965 if addend != 0 {
2966 continue
2967 }
2968 relocTarget[off] = syms[idx-1].Name
2969 }
2970
2971 ctxt.Shlibs = append(ctxt.Shlibs, Shlib{Path: libpath, Hash: hash, Deps: deps, File: f, symAddr: symAddr, relocTarget: relocTarget})
2972 }
2973
2974 func addsection(ldr *loader.Loader, arch *sys.Arch, seg *sym.Segment, name string, rwx int) *sym.Section {
2975 sect := ldr.NewSection()
2976 sect.Rwx = uint8(rwx)
2977 sect.Name = name
2978 sect.Seg = seg
2979 sect.Align = int32(arch.PtrSize)
2980 seg.Sections = append(seg.Sections, sect)
2981 return sect
2982 }
2983
2984 func usage() {
2985 fmt.Fprintf(os.Stderr, "usage: link [options] main.o\n")
2986 objabi.Flagprint(os.Stderr)
2987 Exit(2)
2988 }
2989
2990 type SymbolType int8
2991
2992 const (
2993
2994 TextSym SymbolType = 'T'
2995 DataSym SymbolType = 'D'
2996 BSSSym SymbolType = 'B'
2997 UndefinedSym SymbolType = 'U'
2998 TLSSym SymbolType = 't'
2999 FrameSym SymbolType = 'm'
3000 ParamSym SymbolType = 'p'
3001 AutoSym SymbolType = 'a'
3002
3003
3004 DeletedAutoSym = 'x'
3005 )
3006
3007
3008 func (ctxt *Link) defineInternal(p string, t sym.SymKind) loader.Sym {
3009 s := ctxt.loader.CreateSymForUpdate(p, 0)
3010 s.SetType(t)
3011 s.SetSpecial(true)
3012 s.SetLocal(true)
3013 return s.Sym()
3014 }
3015
3016 func (ctxt *Link) xdefine(p string, t sym.SymKind, v int64) loader.Sym {
3017 s := ctxt.defineInternal(p, t)
3018 ctxt.loader.SetSymValue(s, v)
3019 return s
3020 }
3021
3022 func datoff(ldr *loader.Loader, s loader.Sym, addr int64) int64 {
3023 if uint64(addr) >= Segdata.Vaddr {
3024 return int64(uint64(addr) - Segdata.Vaddr + Segdata.Fileoff)
3025 }
3026 if uint64(addr) >= Segtext.Vaddr {
3027 return int64(uint64(addr) - Segtext.Vaddr + Segtext.Fileoff)
3028 }
3029 ldr.Errorf(s, "invalid datoff %#x", addr)
3030 return 0
3031 }
3032
3033 func Entryvalue(ctxt *Link) int64 {
3034 a := *flagEntrySymbol
3035 if a[0] >= '0' && a[0] <= '9' {
3036 return atolwhex(a)
3037 }
3038 ldr := ctxt.loader
3039 s := ldr.Lookup(a, 0)
3040 if s == 0 {
3041 Errorf("missing entry symbol %q", a)
3042 return 0
3043 }
3044 st := ldr.SymType(s)
3045 if st == 0 {
3046 return *FlagTextAddr
3047 }
3048 if !ctxt.IsAIX() && !st.IsText() {
3049 ldr.Errorf(s, "entry not text")
3050 }
3051 return ldr.SymValue(s)
3052 }
3053
3054 func (ctxt *Link) callgraph() {
3055 if !*FlagC {
3056 return
3057 }
3058
3059 ldr := ctxt.loader
3060 for _, s := range ctxt.Textp {
3061 relocs := ldr.Relocs(s)
3062 for i := 0; i < relocs.Count(); i++ {
3063 r := relocs.At(i)
3064 rs := r.Sym()
3065 if rs == 0 {
3066 continue
3067 }
3068 if r.Type().IsDirectCall() && ldr.SymType(rs).IsText() {
3069 ctxt.Logf("%s calls %s\n", ldr.SymName(s), ldr.SymName(rs))
3070 }
3071 }
3072 }
3073 }
3074
3075 func Rnd(v int64, r int64) int64 {
3076 if r <= 0 {
3077 return v
3078 }
3079 v += r - 1
3080 c := v % r
3081 if c < 0 {
3082 c += r
3083 }
3084 v -= c
3085 return v
3086 }
3087
3088 func bgetc(r *bio.Reader) int {
3089 c, err := r.ReadByte()
3090 if err != nil {
3091 if err != io.EOF {
3092 log.Fatalf("reading input: %v", err)
3093 }
3094 return -1
3095 }
3096 return int(c)
3097 }
3098
3099 type markKind uint8
3100 const (
3101 _ markKind = iota
3102 visiting
3103 visited
3104 )
3105
3106 func postorder(libs []*sym.Library) []*sym.Library {
3107 order := make([]*sym.Library, 0, len(libs))
3108 mark := make(map[*sym.Library]markKind, len(libs))
3109 for _, lib := range libs {
3110 dfs(lib, mark, &order)
3111 }
3112 return order
3113 }
3114
3115 func dfs(lib *sym.Library, mark map[*sym.Library]markKind, order *[]*sym.Library) {
3116 if mark[lib] == visited {
3117 return
3118 }
3119 if mark[lib] == visiting {
3120 panic("found import cycle while visiting " + lib.Pkg)
3121 }
3122 mark[lib] = visiting
3123 for _, i := range lib.Imports {
3124 dfs(i, mark, order)
3125 }
3126 mark[lib] = visited
3127 *order = append(*order, lib)
3128 }
3129
3130 func ElfSymForReloc(ctxt *Link, s loader.Sym) int32 {
3131
3132
3133 les := ctxt.loader.SymLocalElfSym(s)
3134 if les != 0 {
3135 return les
3136 } else {
3137 return ctxt.loader.SymElfSym(s)
3138 }
3139 }
3140
3141 func AddGotSym(target *Target, ldr *loader.Loader, syms *ArchSyms, s loader.Sym, elfRelocTyp uint32) {
3142 if ldr.SymGot(s) >= 0 {
3143 return
3144 }
3145
3146 Adddynsym(ldr, target, syms, s)
3147 got := ldr.MakeSymbolUpdater(syms.GOT)
3148 ldr.SetGot(s, int32(got.Size()))
3149 got.AddUint(target.Arch, 0)
3150
3151 if target.IsElf() {
3152 if target.Arch.PtrSize == 8 {
3153 rela := ldr.MakeSymbolUpdater(syms.Rela)
3154 rela.AddAddrPlus(target.Arch, got.Sym(), int64(ldr.SymGot(s)))
3155 rela.AddUint64(target.Arch, elf.R_INFO(uint32(ldr.SymDynid(s)), elfRelocTyp))
3156 rela.AddUint64(target.Arch, 0)
3157 } else {
3158 rel := ldr.MakeSymbolUpdater(syms.Rel)
3159 rel.AddAddrPlus(target.Arch, got.Sym(), int64(ldr.SymGot(s)))
3160 rel.AddUint32(target.Arch, elf.R_INFO32(uint32(ldr.SymDynid(s)), elfRelocTyp))
3161 }
3162 } else if target.IsDarwin() {
3163 leg := ldr.MakeSymbolUpdater(syms.LinkEditGOT)
3164 leg.AddUint32(target.Arch, uint32(ldr.SymDynid(s)))
3165 if target.IsPIE() && target.IsInternal() {
3166
3167
3168
3169 MachoAddBind(syms.GOT, int64(ldr.SymGot(s)), s)
3170 }
3171 } else {
3172 ldr.Errorf(s, "addgotsym: unsupported binary format")
3173 }
3174 }
3175
3176 var hostobjcounter int
3177
3178
3179
3180
3181
3182
3183 func captureHostObj(h *Hostobj) {
3184
3185 ofile := fmt.Sprintf("captured-obj-%d.o", hostobjcounter)
3186 ifile := fmt.Sprintf("captured-obj-%d.txt", hostobjcounter)
3187 hostobjcounter++
3188 opath := filepath.Join(*flagCaptureHostObjs, ofile)
3189 ipath := filepath.Join(*flagCaptureHostObjs, ifile)
3190
3191
3192 info := fmt.Sprintf("pkg: %s\npn: %s\nfile: %s\noff: %d\nlen: %d\n",
3193 h.pkg, h.pn, h.file, h.off, h.length)
3194 if err := os.WriteFile(ipath, []byte(info), 0666); err != nil {
3195 log.Fatalf("error writing captured host obj info %s: %v", ipath, err)
3196 }
3197
3198 readObjData := func() []byte {
3199 inf, err := os.Open(h.file)
3200 if err != nil {
3201 log.Fatalf("capturing host obj: open failed on %s: %v", h.pn, err)
3202 }
3203 defer inf.Close()
3204 res := make([]byte, h.length)
3205 if n, err := inf.ReadAt(res, h.off); err != nil || n != int(h.length) {
3206 log.Fatalf("capturing host obj: readat failed on %s: %v", h.pn, err)
3207 }
3208 return res
3209 }
3210
3211
3212 if err := os.WriteFile(opath, readObjData(), 0666); err != nil {
3213 log.Fatalf("error writing captured host object %s: %v", opath, err)
3214 }
3215
3216 fmt.Fprintf(os.Stderr, "link: info: captured host object %s to %s\n",
3217 h.file, opath)
3218 }
3219
3220
3221
3222
3223 func (ctxt *Link) findExtLinkTool(toolname string) string {
3224 var cc []string
3225 cc = append(cc, ctxt.extld()...)
3226 cc = append(cc, hostlinkArchArgs(ctxt.Arch)...)
3227 cc = append(cc, "--print-prog-name", toolname)
3228 out, err := exec.Command(cc[0], cc[1:]...).CombinedOutput()
3229 if err != nil {
3230 Exitf("%s: finding %s failed: %v\n%s", os.Args[0], toolname, err, out)
3231 }
3232 cmdpath := strings.TrimRight(string(out), "\r\n")
3233 return cmdpath
3234 }
3235
3236
3237
3238 func (ctxt *Link) isMSVC() bool {
3239 extld := ctxt.extld()
3240 name, args := extld[0], extld[1:]
3241 args = append(args, trimLinkerArgv(flagExtldflags)...)
3242 args = append(args, "--version")
3243 cmd := exec.Command(name, args...)
3244 if out, err := cmd.CombinedOutput(); err == nil {
3245 if bytes.Contains(out, []byte("-msvc\n")) || bytes.Contains(out, []byte("-msvc\r")) {
3246 return true
3247 }
3248 }
3249 return false
3250 }
3251
3252
3253 func (ctxt *Link) isLLD() bool {
3254 extld := ctxt.extld()
3255 name, args := extld[0], extld[1:]
3256 args = append(args, trimLinkerArgv(flagExtldflags)...)
3257 args = append(args, "-Wl,--version")
3258 cmd := exec.Command(name, args...)
3259 if out, err := cmd.CombinedOutput(); err == nil {
3260 if bytes.Contains(out, []byte("LLD ")) {
3261 return true
3262 }
3263 }
3264 return false
3265 }
3266
View as plain text