1 // Inferno utils/6l/span.c 2 // https://bitbucket.org/inferno-os/inferno-os/src/default/utils/6l/span.c 3 // 4 // Copyright 1994-1999 Lucent Technologies Inc. All rights reserved. 5 // Portions Copyright 1995-1997 C H Forsyth (forsyth (a] 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 (a] terzarima.net) 10 // Revisions Copyright 2000-2007 Lucent Technologies Inc. and others 11 // Portions Copyright 2009 The Go Authors. All rights reserved. 12 // 13 // Permission is hereby granted, free of charge, to any person obtaining a copy 14 // of this software and associated documentation files (the "Software"), to deal 15 // in the Software without restriction, including without limitation the rights 16 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 17 // copies of the Software, and to permit persons to whom the Software is 18 // furnished to do so, subject to the following conditions: 19 // 20 // The above copyright notice and this permission notice shall be included in 21 // all copies or substantial portions of the Software. 22 // 23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 24 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 25 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 26 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 27 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 28 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 29 // THE SOFTWARE. 30 31 package ld 32 33 import ( 34 "cmd/internal/objabi" 35 "cmd/internal/sys" 36 "cmd/link/internal/sym" 37 "fmt" 38 "path/filepath" 39 "strings" 40 ) 41 42 // Symbol table. 43 44 func putelfstr(s string) int { 45 if len(Elfstrdat) == 0 && s != "" { 46 // first entry must be empty string 47 putelfstr("") 48 } 49 50 off := len(Elfstrdat) 51 Elfstrdat = append(Elfstrdat, s...) 52 Elfstrdat = append(Elfstrdat, 0) 53 return off 54 } 55 56 func putelfsyment(out *OutBuf, off int, addr int64, size int64, info int, shndx int, other int) { 57 if elf64 { 58 out.Write32(uint32(off)) 59 out.Write8(uint8(info)) 60 out.Write8(uint8(other)) 61 out.Write16(uint16(shndx)) 62 out.Write64(uint64(addr)) 63 out.Write64(uint64(size)) 64 Symsize += ELF64SYMSIZE 65 } else { 66 out.Write32(uint32(off)) 67 out.Write32(uint32(addr)) 68 out.Write32(uint32(size)) 69 out.Write8(uint8(info)) 70 out.Write8(uint8(other)) 71 out.Write16(uint16(shndx)) 72 Symsize += ELF32SYMSIZE 73 } 74 } 75 76 var numelfsym = 1 // 0 is reserved 77 78 var elfbind int 79 80 func putelfsym(ctxt *Link, x *sym.Symbol, s string, t SymbolType, addr int64, go_ *sym.Symbol) { 81 var typ int 82 83 switch t { 84 default: 85 return 86 87 case TextSym: 88 typ = STT_FUNC 89 90 case DataSym, BSSSym: 91 typ = STT_OBJECT 92 93 case UndefinedSym: 94 // ElfType is only set for symbols read from Go shared libraries, but 95 // for other symbols it is left as STT_NOTYPE which is fine. 96 typ = int(x.ElfType) 97 98 case TLSSym: 99 typ = STT_TLS 100 } 101 102 size := x.Size 103 if t == UndefinedSym { 104 size = 0 105 } 106 107 xo := x 108 for xo.Outer != nil { 109 xo = xo.Outer 110 } 111 112 var elfshnum int 113 if xo.Type == sym.SDYNIMPORT || xo.Type == sym.SHOSTOBJ { 114 elfshnum = SHN_UNDEF 115 } else { 116 if xo.Sect == nil { 117 Errorf(x, "missing section in putelfsym") 118 return 119 } 120 if xo.Sect.Elfsect == nil { 121 Errorf(x, "missing ELF section in putelfsym") 122 return 123 } 124 elfshnum = xo.Sect.Elfsect.(*ElfShdr).shnum 125 } 126 127 // One pass for each binding: STB_LOCAL, STB_GLOBAL, 128 // maybe one day STB_WEAK. 129 bind := STB_GLOBAL 130 131 if x.Version != 0 || x.Attr.VisibilityHidden() || x.Attr.Local() { 132 bind = STB_LOCAL 133 } 134 135 // In external linking mode, we have to invoke gcc with -rdynamic 136 // to get the exported symbols put into the dynamic symbol table. 137 // To avoid filling the dynamic table with lots of unnecessary symbols, 138 // mark all Go symbols local (not global) in the final executable. 139 // But when we're dynamically linking, we need all those global symbols. 140 if !ctxt.DynlinkingGo() && ctxt.LinkMode == LinkExternal && !x.Attr.CgoExportStatic() && elfshnum != SHN_UNDEF { 141 bind = STB_LOCAL 142 } 143 144 if ctxt.LinkMode == LinkExternal && elfshnum != SHN_UNDEF { 145 addr -= int64(xo.Sect.Vaddr) 146 } 147 other := STV_DEFAULT 148 if x.Attr.VisibilityHidden() { 149 // TODO(mwhudson): We only set AttrVisibilityHidden in ldelf, i.e. when 150 // internally linking. But STV_HIDDEN visibility only matters in object 151 // files and shared libraries, and as we are a long way from implementing 152 // internal linking for shared libraries and only create object files when 153 // externally linking, I don't think this makes a lot of sense. 154 other = STV_HIDDEN 155 } 156 if ctxt.Arch.Family == sys.PPC64 && typ == STT_FUNC && x.Attr.Shared() && x.Name != "runtime.duffzero" && x.Name != "runtime.duffcopy" { 157 // On ppc64 the top three bits of the st_other field indicate how 158 // many instructions separate the global and local entry points. In 159 // our case it is two instructions, indicated by the value 3. 160 // The conditions here match those in preprocess in 161 // cmd/internal/obj/ppc64/obj9.go, which is where the 162 // instructions are inserted. 163 other |= 3 << 5 164 } 165 166 // When dynamically linking, we create Symbols by reading the names from 167 // the symbol tables of the shared libraries and so the names need to 168 // match exactly. Tools like DTrace will have to wait for now. 169 if !ctxt.DynlinkingGo() { 170 // Rewrite to . for ASCII-only tools like DTrace (sigh) 171 s = strings.Replace(s, "", ".", -1) 172 } 173 174 if ctxt.DynlinkingGo() && bind == STB_GLOBAL && elfbind == STB_LOCAL && x.Type == sym.STEXT { 175 // When dynamically linking, we want references to functions defined 176 // in this module to always be to the function object, not to the 177 // PLT. We force this by writing an additional local symbol for every 178 // global function symbol and making all relocations against the 179 // global symbol refer to this local symbol instead (see 180 // (*sym.Symbol).ElfsymForReloc). This is approximately equivalent to the 181 // ELF linker -Bsymbolic-functions option, but that is buggy on 182 // several platforms. 183 putelfsyment(ctxt.Out, putelfstr("local."+s), addr, size, STB_LOCAL<<4|typ&0xf, elfshnum, other) 184 x.LocalElfsym = int32(numelfsym) 185 numelfsym++ 186 return 187 } else if bind != elfbind { 188 return 189 } 190 191 putelfsyment(ctxt.Out, putelfstr(s), addr, size, bind<<4|typ&0xf, elfshnum, other) 192 x.Elfsym = int32(numelfsym) 193 numelfsym++ 194 } 195 196 func putelfsectionsym(out *OutBuf, s *sym.Symbol, shndx int) { 197 putelfsyment(out, 0, 0, 0, STB_LOCAL<<4|STT_SECTION, shndx, 0) 198 s.Elfsym = int32(numelfsym) 199 numelfsym++ 200 } 201 202 func Asmelfsym(ctxt *Link) { 203 // the first symbol entry is reserved 204 putelfsyment(ctxt.Out, 0, 0, 0, STB_LOCAL<<4|STT_NOTYPE, 0, 0) 205 206 dwarfaddelfsectionsyms(ctxt) 207 208 // Some linkers will add a FILE sym if one is not present. 209 // Avoid having the working directory inserted into the symbol table. 210 // It is added with a name to avoid problems with external linking 211 // encountered on some versions of Solaris. See issue #14957. 212 putelfsyment(ctxt.Out, putelfstr("go.go"), 0, 0, STB_LOCAL<<4|STT_FILE, SHN_ABS, 0) 213 numelfsym++ 214 215 elfbind = STB_LOCAL 216 genasmsym(ctxt, putelfsym) 217 218 elfbind = STB_GLOBAL 219 elfglobalsymndx = numelfsym 220 genasmsym(ctxt, putelfsym) 221 } 222 223 func putplan9sym(ctxt *Link, x *sym.Symbol, s string, typ SymbolType, addr int64, go_ *sym.Symbol) { 224 t := int(typ) 225 switch typ { 226 case TextSym, DataSym, BSSSym: 227 if x.Version != 0 { 228 t += 'a' - 'A' 229 } 230 fallthrough 231 232 case AutoSym, ParamSym, FrameSym: 233 l := 4 234 if ctxt.HeadType == objabi.Hplan9 && ctxt.Arch.Family == sys.AMD64 && !Flag8 { 235 ctxt.Out.Write32b(uint32(addr >> 32)) 236 l = 8 237 } 238 239 ctxt.Out.Write32b(uint32(addr)) 240 ctxt.Out.Write8(uint8(t + 0x80)) /* 0x80 is variable length */ 241 242 ctxt.Out.WriteString(s) 243 ctxt.Out.Write8(0) 244 245 Symsize += int32(l) + 1 + int32(len(s)) + 1 246 247 default: 248 return 249 } 250 } 251 252 func Asmplan9sym(ctxt *Link) { 253 genasmsym(ctxt, putplan9sym) 254 } 255 256 var symt *sym.Symbol 257 258 type byPkg []*sym.Library 259 260 func (libs byPkg) Len() int { 261 return len(libs) 262 } 263 264 func (libs byPkg) Less(a, b int) bool { 265 return libs[a].Pkg < libs[b].Pkg 266 } 267 268 func (libs byPkg) Swap(a, b int) { 269 libs[a], libs[b] = libs[b], libs[a] 270 } 271 272 // Create a table with information on the text sections. 273 274 func textsectionmap(ctxt *Link) uint32 { 275 276 t := ctxt.Syms.Lookup("runtime.textsectionmap", 0) 277 t.Type = sym.SRODATA 278 t.Attr |= sym.AttrReachable 279 nsections := int64(0) 280 281 for _, sect := range Segtext.Sections { 282 if sect.Name == ".text" { 283 nsections++ 284 } else { 285 break 286 } 287 } 288 t.Grow(3 * nsections * int64(ctxt.Arch.PtrSize)) 289 290 off := int64(0) 291 n := 0 292 293 // The vaddr for each text section is the difference between the section's 294 // Vaddr and the Vaddr for the first text section as determined at compile 295 // time. 296 297 // The symbol for the first text section is named runtime.text as before. 298 // Additional text sections are named runtime.text.n where n is the 299 // order of creation starting with 1. These symbols provide the section's 300 // address after relocation by the linker. 301 302 textbase := Segtext.Sections[0].Vaddr 303 for _, sect := range Segtext.Sections { 304 if sect.Name != ".text" { 305 break 306 } 307 off = t.SetUint(ctxt.Arch, off, sect.Vaddr-textbase) 308 off = t.SetUint(ctxt.Arch, off, sect.Length) 309 if n == 0 { 310 s := ctxt.Syms.ROLookup("runtime.text", 0) 311 if s == nil { 312 Errorf(nil, "Unable to find symbol runtime.text\n") 313 } 314 off = t.SetAddr(ctxt.Arch, off, s) 315 316 } else { 317 s := ctxt.Syms.Lookup(fmt.Sprintf("runtime.text.%d", n), 0) 318 if s == nil { 319 Errorf(nil, "Unable to find symbol runtime.text.%d\n", n) 320 } 321 off = t.SetAddr(ctxt.Arch, off, s) 322 } 323 n++ 324 } 325 return uint32(n) 326 } 327 328 func (ctxt *Link) symtab() { 329 dosymtype(ctxt) 330 331 // Define these so that they'll get put into the symbol table. 332 // data.c:/^address will provide the actual values. 333 ctxt.xdefine("runtime.text", sym.STEXT, 0) 334 335 ctxt.xdefine("runtime.etext", sym.STEXT, 0) 336 ctxt.xdefine("runtime.itablink", sym.SRODATA, 0) 337 ctxt.xdefine("runtime.eitablink", sym.SRODATA, 0) 338 ctxt.xdefine("runtime.rodata", sym.SRODATA, 0) 339 ctxt.xdefine("runtime.erodata", sym.SRODATA, 0) 340 ctxt.xdefine("runtime.types", sym.SRODATA, 0) 341 ctxt.xdefine("runtime.etypes", sym.SRODATA, 0) 342 ctxt.xdefine("runtime.noptrdata", sym.SNOPTRDATA, 0) 343 ctxt.xdefine("runtime.enoptrdata", sym.SNOPTRDATA, 0) 344 ctxt.xdefine("runtime.data", sym.SDATA, 0) 345 ctxt.xdefine("runtime.edata", sym.SDATA, 0) 346 ctxt.xdefine("runtime.bss", sym.SBSS, 0) 347 ctxt.xdefine("runtime.ebss", sym.SBSS, 0) 348 ctxt.xdefine("runtime.noptrbss", sym.SNOPTRBSS, 0) 349 ctxt.xdefine("runtime.enoptrbss", sym.SNOPTRBSS, 0) 350 ctxt.xdefine("runtime.end", sym.SBSS, 0) 351 ctxt.xdefine("runtime.epclntab", sym.SRODATA, 0) 352 ctxt.xdefine("runtime.esymtab", sym.SRODATA, 0) 353 354 // garbage collection symbols 355 s := ctxt.Syms.Lookup("runtime.gcdata", 0) 356 357 s.Type = sym.SRODATA 358 s.Size = 0 359 s.Attr |= sym.AttrReachable 360 ctxt.xdefine("runtime.egcdata", sym.SRODATA, 0) 361 362 s = ctxt.Syms.Lookup("runtime.gcbss", 0) 363 s.Type = sym.SRODATA 364 s.Size = 0 365 s.Attr |= sym.AttrReachable 366 ctxt.xdefine("runtime.egcbss", sym.SRODATA, 0) 367 368 // pseudo-symbols to mark locations of type, string, and go string data. 369 var symtype *sym.Symbol 370 var symtyperel *sym.Symbol 371 if ctxt.UseRelro() && (ctxt.BuildMode == BuildModeCArchive || ctxt.BuildMode == BuildModeCShared || ctxt.BuildMode == BuildModePIE) { 372 s = ctxt.Syms.Lookup("type.*", 0) 373 374 s.Type = sym.STYPE 375 s.Size = 0 376 s.Attr |= sym.AttrReachable 377 symtype = s 378 379 s = ctxt.Syms.Lookup("typerel.*", 0) 380 381 s.Type = sym.STYPERELRO 382 s.Size = 0 383 s.Attr |= sym.AttrReachable 384 symtyperel = s 385 } else if !ctxt.DynlinkingGo() { 386 s = ctxt.Syms.Lookup("type.*", 0) 387 388 s.Type = sym.STYPE 389 s.Size = 0 390 s.Attr |= sym.AttrReachable 391 symtype = s 392 symtyperel = s 393 } 394 395 groupSym := func(name string, t sym.SymKind) *sym.Symbol { 396 s := ctxt.Syms.Lookup(name, 0) 397 s.Type = t 398 s.Size = 0 399 s.Attr |= sym.AttrLocal | sym.AttrReachable 400 return s 401 } 402 var ( 403 symgostring = groupSym("go.string.*", sym.SGOSTRING) 404 symgofunc = groupSym("go.func.*", sym.SGOFUNC) 405 symgcbits = groupSym("runtime.gcbits.*", sym.SGCBITS) 406 ) 407 408 var symgofuncrel *sym.Symbol 409 if !ctxt.DynlinkingGo() { 410 if ctxt.UseRelro() { 411 symgofuncrel = groupSym("go.funcrel.*", sym.SGOFUNCRELRO) 412 } else { 413 symgofuncrel = symgofunc 414 } 415 } 416 417 symitablink := ctxt.Syms.Lookup("runtime.itablink", 0) 418 symitablink.Type = sym.SITABLINK 419 420 symt = ctxt.Syms.Lookup("runtime.symtab", 0) 421 symt.Attr |= sym.AttrLocal 422 symt.Type = sym.SSYMTAB 423 symt.Size = 0 424 symt.Attr |= sym.AttrReachable 425 426 nitablinks := 0 427 428 // assign specific types so that they sort together. 429 // within a type they sort by size, so the .* symbols 430 // just defined above will be first. 431 // hide the specific symbols. 432 for _, s := range ctxt.Syms.Allsym { 433 if !s.Attr.Reachable() || s.Attr.Special() || s.Type != sym.SRODATA { 434 continue 435 } 436 437 switch { 438 case strings.HasPrefix(s.Name, "type."): 439 if !ctxt.DynlinkingGo() { 440 s.Attr |= sym.AttrNotInSymbolTable 441 } 442 if ctxt.UseRelro() { 443 s.Type = sym.STYPERELRO 444 s.Outer = symtyperel 445 } else { 446 s.Type = sym.STYPE 447 s.Outer = symtype 448 } 449 450 case strings.HasPrefix(s.Name, "go.importpath.") && ctxt.UseRelro(): 451 // Keep go.importpath symbols in the same section as types and 452 // names, as they can be referred to by a section offset. 453 s.Type = sym.STYPERELRO 454 455 case strings.HasPrefix(s.Name, "go.itablink."): 456 nitablinks++ 457 s.Type = sym.SITABLINK 458 s.Attr |= sym.AttrNotInSymbolTable 459 s.Outer = symitablink 460 461 case strings.HasPrefix(s.Name, "go.string."): 462 s.Type = sym.SGOSTRING 463 s.Attr |= sym.AttrNotInSymbolTable 464 s.Outer = symgostring 465 466 case strings.HasPrefix(s.Name, "runtime.gcbits."): 467 s.Type = sym.SGCBITS 468 s.Attr |= sym.AttrNotInSymbolTable 469 s.Outer = symgcbits 470 471 case strings.HasSuffix(s.Name, "f"): 472 if !ctxt.DynlinkingGo() { 473 s.Attr |= sym.AttrNotInSymbolTable 474 } 475 if ctxt.UseRelro() { 476 s.Type = sym.SGOFUNCRELRO 477 s.Outer = symgofuncrel 478 } else { 479 s.Type = sym.SGOFUNC 480 s.Outer = symgofunc 481 } 482 483 case strings.HasPrefix(s.Name, "gcargs."), 484 strings.HasPrefix(s.Name, "gclocals."), 485 strings.HasPrefix(s.Name, "gclocals"), 486 strings.HasPrefix(s.Name, "inltree."): 487 s.Type = sym.SGOFUNC 488 s.Attr |= sym.AttrNotInSymbolTable 489 s.Outer = symgofunc 490 s.Align = 4 491 liveness += (s.Size + int64(s.Align) - 1) &^ (int64(s.Align) - 1) 492 } 493 } 494 495 if ctxt.BuildMode == BuildModeShared { 496 abihashgostr := ctxt.Syms.Lookup("go.link.abihash."+filepath.Base(*flagOutfile), 0) 497 abihashgostr.Attr |= sym.AttrReachable 498 abihashgostr.Type = sym.SRODATA 499 hashsym := ctxt.Syms.Lookup("go.link.abihashbytes", 0) 500 abihashgostr.AddAddr(ctxt.Arch, hashsym) 501 abihashgostr.AddUint(ctxt.Arch, uint64(hashsym.Size)) 502 } 503 if ctxt.BuildMode == BuildModePlugin || ctxt.Syms.ROLookup("plugin.Open", 0) != nil { 504 for _, l := range ctxt.Library { 505 s := ctxt.Syms.Lookup("go.link.pkghashbytes."+l.Pkg, 0) 506 s.Attr |= sym.AttrReachable 507 s.Type = sym.SRODATA 508 s.Size = int64(len(l.Hash)) 509 s.P = []byte(l.Hash) 510 str := ctxt.Syms.Lookup("go.link.pkghash."+l.Pkg, 0) 511 str.Attr |= sym.AttrReachable 512 str.Type = sym.SRODATA 513 str.AddAddr(ctxt.Arch, s) 514 str.AddUint(ctxt.Arch, uint64(len(l.Hash))) 515 } 516 } 517 518 nsections := textsectionmap(ctxt) 519 520 // Information about the layout of the executable image for the 521 // runtime to use. Any changes here must be matched by changes to 522 // the definition of moduledata in runtime/symtab.go. 523 // This code uses several global variables that are set by pcln.go:pclntab. 524 moduledata := ctxt.Moduledata 525 // The pclntab slice 526 moduledata.AddAddr(ctxt.Arch, ctxt.Syms.Lookup("runtime.pclntab", 0)) 527 moduledata.AddUint(ctxt.Arch, uint64(ctxt.Syms.Lookup("runtime.pclntab", 0).Size)) 528 moduledata.AddUint(ctxt.Arch, uint64(ctxt.Syms.Lookup("runtime.pclntab", 0).Size)) 529 // The ftab slice 530 moduledata.AddAddrPlus(ctxt.Arch, ctxt.Syms.Lookup("runtime.pclntab", 0), int64(pclntabPclntabOffset)) 531 moduledata.AddUint(ctxt.Arch, uint64(pclntabNfunc+1)) 532 moduledata.AddUint(ctxt.Arch, uint64(pclntabNfunc+1)) 533 // The filetab slice 534 moduledata.AddAddrPlus(ctxt.Arch, ctxt.Syms.Lookup("runtime.pclntab", 0), int64(pclntabFiletabOffset)) 535 moduledata.AddUint(ctxt.Arch, uint64(len(ctxt.Filesyms))+1) 536 moduledata.AddUint(ctxt.Arch, uint64(len(ctxt.Filesyms))+1) 537 // findfunctab 538 moduledata.AddAddr(ctxt.Arch, ctxt.Syms.Lookup("runtime.findfunctab", 0)) 539 // minpc, maxpc 540 moduledata.AddAddr(ctxt.Arch, pclntabFirstFunc) 541 moduledata.AddAddrPlus(ctxt.Arch, pclntabLastFunc, pclntabLastFunc.Size) 542 // pointers to specific parts of the module 543 moduledata.AddAddr(ctxt.Arch, ctxt.Syms.Lookup("runtime.text", 0)) 544 moduledata.AddAddr(ctxt.Arch, ctxt.Syms.Lookup("runtime.etext", 0)) 545 moduledata.AddAddr(ctxt.Arch, ctxt.Syms.Lookup("runtime.noptrdata", 0)) 546 moduledata.AddAddr(ctxt.Arch, ctxt.Syms.Lookup("runtime.enoptrdata", 0)) 547 moduledata.AddAddr(ctxt.Arch, ctxt.Syms.Lookup("runtime.data", 0)) 548 moduledata.AddAddr(ctxt.Arch, ctxt.Syms.Lookup("runtime.edata", 0)) 549 moduledata.AddAddr(ctxt.Arch, ctxt.Syms.Lookup("runtime.bss", 0)) 550 moduledata.AddAddr(ctxt.Arch, ctxt.Syms.Lookup("runtime.ebss", 0)) 551 moduledata.AddAddr(ctxt.Arch, ctxt.Syms.Lookup("runtime.noptrbss", 0)) 552 moduledata.AddAddr(ctxt.Arch, ctxt.Syms.Lookup("runtime.enoptrbss", 0)) 553 moduledata.AddAddr(ctxt.Arch, ctxt.Syms.Lookup("runtime.end", 0)) 554 moduledata.AddAddr(ctxt.Arch, ctxt.Syms.Lookup("runtime.gcdata", 0)) 555 moduledata.AddAddr(ctxt.Arch, ctxt.Syms.Lookup("runtime.gcbss", 0)) 556 moduledata.AddAddr(ctxt.Arch, ctxt.Syms.Lookup("runtime.types", 0)) 557 moduledata.AddAddr(ctxt.Arch, ctxt.Syms.Lookup("runtime.etypes", 0)) 558 559 // text section information 560 moduledata.AddAddr(ctxt.Arch, ctxt.Syms.Lookup("runtime.textsectionmap", 0)) 561 moduledata.AddUint(ctxt.Arch, uint64(nsections)) 562 moduledata.AddUint(ctxt.Arch, uint64(nsections)) 563 564 // The typelinks slice 565 typelinkSym := ctxt.Syms.Lookup("runtime.typelink", 0) 566 ntypelinks := uint64(typelinkSym.Size) / 4 567 moduledata.AddAddr(ctxt.Arch, typelinkSym) 568 moduledata.AddUint(ctxt.Arch, ntypelinks) 569 moduledata.AddUint(ctxt.Arch, ntypelinks) 570 // The itablinks slice 571 moduledata.AddAddr(ctxt.Arch, ctxt.Syms.Lookup("runtime.itablink", 0)) 572 moduledata.AddUint(ctxt.Arch, uint64(nitablinks)) 573 moduledata.AddUint(ctxt.Arch, uint64(nitablinks)) 574 // The ptab slice 575 if ptab := ctxt.Syms.ROLookup("go.plugin.tabs", 0); ptab != nil && ptab.Attr.Reachable() { 576 ptab.Attr |= sym.AttrLocal 577 ptab.Type = sym.SRODATA 578 579 nentries := uint64(len(ptab.P) / 8) // sizeof(nameOff) + sizeof(typeOff) 580 moduledata.AddAddr(ctxt.Arch, ptab) 581 moduledata.AddUint(ctxt.Arch, nentries) 582 moduledata.AddUint(ctxt.Arch, nentries) 583 } else { 584 moduledata.AddUint(ctxt.Arch, 0) 585 moduledata.AddUint(ctxt.Arch, 0) 586 moduledata.AddUint(ctxt.Arch, 0) 587 } 588 if ctxt.BuildMode == BuildModePlugin { 589 addgostring(ctxt, moduledata, "go.link.thispluginpath", objabi.PathToPrefix(*flagPluginPath)) 590 591 pkghashes := ctxt.Syms.Lookup("go.link.pkghashes", 0) 592 pkghashes.Attr |= sym.AttrReachable 593 pkghashes.Attr |= sym.AttrLocal 594 pkghashes.Type = sym.SRODATA 595 596 for i, l := range ctxt.Library { 597 // pkghashes[i].name 598 addgostring(ctxt, pkghashes, fmt.Sprintf("go.link.pkgname.%d", i), l.Pkg) 599 // pkghashes[i].linktimehash 600 addgostring(ctxt, pkghashes, fmt.Sprintf("go.link.pkglinkhash.%d", i), l.Hash) 601 // pkghashes[i].runtimehash 602 hash := ctxt.Syms.ROLookup("go.link.pkghash."+l.Pkg, 0) 603 pkghashes.AddAddr(ctxt.Arch, hash) 604 } 605 moduledata.AddAddr(ctxt.Arch, pkghashes) 606 moduledata.AddUint(ctxt.Arch, uint64(len(ctxt.Library))) 607 moduledata.AddUint(ctxt.Arch, uint64(len(ctxt.Library))) 608 } else { 609 moduledata.AddUint(ctxt.Arch, 0) // pluginpath 610 moduledata.AddUint(ctxt.Arch, 0) 611 moduledata.AddUint(ctxt.Arch, 0) // pkghashes slice 612 moduledata.AddUint(ctxt.Arch, 0) 613 moduledata.AddUint(ctxt.Arch, 0) 614 } 615 if len(ctxt.Shlibs) > 0 { 616 thismodulename := filepath.Base(*flagOutfile) 617 switch ctxt.BuildMode { 618 case BuildModeExe, BuildModePIE: 619 // When linking an executable, outfile is just "a.out". Make 620 // it something slightly more comprehensible. 621 thismodulename = "the executable" 622 } 623 addgostring(ctxt, moduledata, "go.link.thismodulename", thismodulename) 624 625 modulehashes := ctxt.Syms.Lookup("go.link.abihashes", 0) 626 modulehashes.Attr |= sym.AttrReachable 627 modulehashes.Attr |= sym.AttrLocal 628 modulehashes.Type = sym.SRODATA 629 630 for i, shlib := range ctxt.Shlibs { 631 // modulehashes[i].modulename 632 modulename := filepath.Base(shlib.Path) 633 addgostring(ctxt, modulehashes, fmt.Sprintf("go.link.libname.%d", i), modulename) 634 635 // modulehashes[i].linktimehash 636 addgostring(ctxt, modulehashes, fmt.Sprintf("go.link.linkhash.%d", i), string(shlib.Hash)) 637 638 // modulehashes[i].runtimehash 639 abihash := ctxt.Syms.Lookup("go.link.abihash."+modulename, 0) 640 abihash.Attr |= sym.AttrReachable 641 modulehashes.AddAddr(ctxt.Arch, abihash) 642 } 643 644 moduledata.AddAddr(ctxt.Arch, modulehashes) 645 moduledata.AddUint(ctxt.Arch, uint64(len(ctxt.Shlibs))) 646 moduledata.AddUint(ctxt.Arch, uint64(len(ctxt.Shlibs))) 647 } else { 648 moduledata.AddUint(ctxt.Arch, 0) // modulename 649 moduledata.AddUint(ctxt.Arch, 0) 650 moduledata.AddUint(ctxt.Arch, 0) // moduleshashes slice 651 moduledata.AddUint(ctxt.Arch, 0) 652 moduledata.AddUint(ctxt.Arch, 0) 653 } 654 655 hasmain := ctxt.BuildMode == BuildModeExe || ctxt.BuildMode == BuildModePIE 656 if hasmain { 657 moduledata.AddUint8(1) 658 } else { 659 moduledata.AddUint8(0) 660 } 661 662 // The rest of moduledata is zero initialized. 663 // When linking an object that does not contain the runtime we are 664 // creating the moduledata from scratch and it does not have a 665 // compiler-provided size, so read it from the type data. 666 moduledatatype := ctxt.Syms.ROLookup("type.runtime.moduledata", 0) 667 moduledata.Size = decodetypeSize(ctxt.Arch, moduledatatype) 668 moduledata.Grow(moduledata.Size) 669 670 lastmoduledatap := ctxt.Syms.Lookup("runtime.lastmoduledatap", 0) 671 if lastmoduledatap.Type != sym.SDYNIMPORT { 672 lastmoduledatap.Type = sym.SNOPTRDATA 673 lastmoduledatap.Size = 0 // overwrite existing value 674 lastmoduledatap.AddAddr(ctxt.Arch, moduledata) 675 } 676 } 677
