if !ctxt.DynlinkingGo() {
return
}
- addmoduledata := ld.Linklookup(ctxt, "runtime.addmoduledata", 0)
+ addmoduledata := ctxt.Syms.Lookup("runtime.addmoduledata", 0)
if addmoduledata.Type == obj.STEXT && ld.Buildmode != ld.BuildmodePlugin {
// we're linking a module containing the runtime -> no need for
// an init function
return
}
addmoduledata.Attr |= ld.AttrReachable
- initfunc := ld.Linklookup(ctxt, "go.link.addmoduledata", 0)
+ initfunc := ctxt.Syms.Lookup("go.link.addmoduledata", 0)
initfunc.Type = obj.STEXT
initfunc.Attr |= ld.AttrLocal
initfunc.Attr |= ld.AttrReachable
if ld.Buildmode == ld.BuildmodePlugin {
ctxt.Textp = append(ctxt.Textp, addmoduledata)
}
- initarray_entry := ld.Linklookup(ctxt, "go.link.addmoduledatainit", 0)
+ initarray_entry := ctxt.Syms.Lookup("go.link.addmoduledatainit", 0)
initarray_entry.Attr |= ld.AttrReachable
initarray_entry.Attr |= ld.AttrLocal
initarray_entry.Type = obj.SINITARR
r.Add += 4
if targ.Type == obj.SDYNIMPORT {
addpltsym(ctxt, targ)
- r.Sym = ld.Linklookup(ctxt, ".plt", 0)
+ r.Sym = ctxt.Syms.Lookup(".plt", 0)
r.Add += int64(targ.Plt)
}
addgotsym(ctxt, targ)
r.Type = obj.R_PCREL
- r.Sym = ld.Linklookup(ctxt, ".got", 0)
+ r.Sym = ctxt.Syms.Lookup(".got", 0)
r.Add += 4
r.Add += int64(targ.Got)
return true
case 512 + ld.MACHO_X86_64_RELOC_BRANCH*2 + 1:
if targ.Type == obj.SDYNIMPORT {
addpltsym(ctxt, targ)
- r.Sym = ld.Linklookup(ctxt, ".plt", 0)
+ r.Sym = ctxt.Syms.Lookup(".plt", 0)
r.Add = int64(targ.Plt)
r.Type = obj.R_PCREL
return true
}
addgotsym(ctxt, targ)
r.Type = obj.R_PCREL
- r.Sym = ld.Linklookup(ctxt, ".got", 0)
+ r.Sym = ctxt.Syms.Lookup(".got", 0)
r.Add += int64(targ.Got)
return true
}
} else {
// for both ELF and Mach-O
addpltsym(ctxt, targ)
- r.Sym = ld.Linklookup(ctxt, ".plt", 0)
+ r.Sym = ctxt.Syms.Lookup(".plt", 0)
r.Add = int64(targ.Plt)
return true
}
if s.Type == obj.STEXT && ld.Iself {
if ld.Headtype == obj.Hsolaris {
addpltsym(ctxt, targ)
- r.Sym = ld.Linklookup(ctxt, ".plt", 0)
+ r.Sym = ctxt.Syms.Lookup(".plt", 0)
r.Add += int64(targ.Plt)
return true
}
// correspondent GOT symbol.
addgotsym(ctxt, targ)
- r.Sym = ld.Linklookup(ctxt, ".got", 0)
+ r.Sym = ctxt.Syms.Lookup(".got", 0)
r.Add += int64(targ.Got)
return true
}
// though it would be more efficient (for the dynamic linker) if we
// generated R_X86_RELATIVE instead.
ld.Adddynsym(ctxt, targ)
- rela := ld.Linklookup(ctxt, ".rela", 0)
+ rela := ctxt.Syms.Lookup(".rela", 0)
ld.Addaddrplus(ctxt, rela, s, int64(r.Off))
if r.Siz == 8 {
ld.Adduint64(ctxt, rela, ld.ELF64_R_INFO(uint32(targ.Dynid), ld.R_X86_64_64))
// but we only need to support cgo and that's all it needs.
ld.Adddynsym(ctxt, targ)
- got := ld.Linklookup(ctxt, ".got", 0)
+ got := ctxt.Syms.Lookup(".got", 0)
s.Type = got.Type | obj.SSUB
s.Outer = got
s.Sub = got.Sub
got.Sub = s
s.Value = got.Size
ld.Adduint64(ctxt, got, 0)
- ld.Adduint32(ctxt, ld.Linklookup(ctxt, ".linkedit.got", 0), uint32(targ.Dynid))
+ ld.Adduint32(ctxt, ctxt.Syms.Lookup(".linkedit.got", 0), uint32(targ.Dynid))
r.Type = 256 // ignore during relocsym
return true
}
}
func elfsetupplt(ctxt *ld.Link) {
- plt := ld.Linklookup(ctxt, ".plt", 0)
- got := ld.Linklookup(ctxt, ".got.plt", 0)
+ plt := ctxt.Syms.Lookup(".plt", 0)
+ got := ctxt.Syms.Lookup(".got.plt", 0)
if plt.Size == 0 {
// pushq got+8(IP)
ld.Adduint8(ctxt, plt, 0xff)
ld.Adduint32(ctxt, plt, 0x00401f0f)
// assume got->size == 0 too
- ld.Addaddrplus(ctxt, got, ld.Linklookup(ctxt, ".dynamic", 0), 0)
+ ld.Addaddrplus(ctxt, got, ctxt.Syms.Lookup(".dynamic", 0), 0)
ld.Adduint64(ctxt, got, 0)
ld.Adduint64(ctxt, got, 0)
ld.Adddynsym(ctxt, s)
if ld.Iself {
- plt := ld.Linklookup(ctxt, ".plt", 0)
- got := ld.Linklookup(ctxt, ".got.plt", 0)
- rela := ld.Linklookup(ctxt, ".rela.plt", 0)
+ plt := ctxt.Syms.Lookup(".plt", 0)
+ got := ctxt.Syms.Lookup(".got.plt", 0)
+ rela := ctxt.Syms.Lookup(".rela.plt", 0)
if plt.Size == 0 {
elfsetupplt(ctxt)
}
// has details about what we're avoiding.
addgotsym(ctxt, s)
- plt := ld.Linklookup(ctxt, ".plt", 0)
+ plt := ctxt.Syms.Lookup(".plt", 0)
- ld.Adduint32(ctxt, ld.Linklookup(ctxt, ".linkedit.plt", 0), uint32(s.Dynid))
+ ld.Adduint32(ctxt, ctxt.Syms.Lookup(".linkedit.plt", 0), uint32(s.Dynid))
// jmpq *got+size(IP)
s.Plt = int32(plt.Size)
ld.Adduint8(ctxt, plt, 0xff)
ld.Adduint8(ctxt, plt, 0x25)
- ld.Addpcrelplus(ctxt, plt, ld.Linklookup(ctxt, ".got", 0), int64(s.Got))
+ ld.Addpcrelplus(ctxt, plt, ctxt.Syms.Lookup(".got", 0), int64(s.Got))
} else {
ld.Errorf(s, "addpltsym: unsupported binary format")
}
}
ld.Adddynsym(ctxt, s)
- got := ld.Linklookup(ctxt, ".got", 0)
+ got := ctxt.Syms.Lookup(".got", 0)
s.Got = int32(got.Size)
ld.Adduint64(ctxt, got, 0)
if ld.Iself {
- rela := ld.Linklookup(ctxt, ".rela", 0)
+ rela := ctxt.Syms.Lookup(".rela", 0)
ld.Addaddrplus(ctxt, rela, got, int64(s.Got))
ld.Adduint64(ctxt, rela, ld.ELF64_R_INFO(uint32(s.Dynid), ld.R_X86_64_GLOB_DAT))
ld.Adduint64(ctxt, rela, 0)
} else if ld.Headtype == obj.Hdarwin {
- ld.Adduint32(ctxt, ld.Linklookup(ctxt, ".linkedit.got", 0), uint32(s.Dynid))
+ ld.Adduint32(ctxt, ctxt.Syms.Lookup(".linkedit.got", 0), uint32(s.Dynid))
} else {
ld.Errorf(s, "addgotsym: unsupported binary format")
}
ld.Asmplan9sym(ctxt)
ld.Cflush()
- sym := ld.Linklookup(ctxt, "pclntab", 0)
+ sym := ctxt.Syms.Lookup("pclntab", 0)
if sym != nil {
ld.Lcsize = int32(len(sym.P))
for i := 0; int32(i) < ld.Lcsize; i++ {
if !ctxt.DynlinkingGo() {
return
}
- addmoduledata := ld.Linklookup(ctxt, "runtime.addmoduledata", 0)
+ addmoduledata := ctxt.Syms.Lookup("runtime.addmoduledata", 0)
if addmoduledata.Type == obj.STEXT && ld.Buildmode != ld.BuildmodePlugin {
// we're linking a module containing the runtime -> no need for
// an init function
return
}
addmoduledata.Attr |= ld.AttrReachable
- initfunc := ld.Linklookup(ctxt, "go.link.addmoduledata", 0)
+ initfunc := ctxt.Syms.Lookup("go.link.addmoduledata", 0)
initfunc.Type = obj.STEXT
initfunc.Attr |= ld.AttrLocal
initfunc.Attr |= ld.AttrReachable
rel := ld.Addrel(initfunc)
rel.Off = 8
rel.Siz = 4
- rel.Sym = ld.Linklookup(ctxt, "runtime.addmoduledata", 0)
+ rel.Sym = ctxt.Syms.Lookup("runtime.addmoduledata", 0)
rel.Type = obj.R_CALLARM
rel.Add = 0xeafffffe // vomit
if ld.Buildmode == ld.BuildmodePlugin {
ctxt.Textp = append(ctxt.Textp, addmoduledata)
}
- initarray_entry := ld.Linklookup(ctxt, "go.link.addmoduledatainit", 0)
+ initarray_entry := ctxt.Syms.Lookup("go.link.addmoduledatainit", 0)
initarray_entry.Attr |= ld.AttrReachable
initarray_entry.Attr |= ld.AttrLocal
initarray_entry.Type = obj.SINITARR
if targ.Type == obj.SDYNIMPORT {
addpltsym(ctxt, targ)
- r.Sym = ld.Linklookup(ctxt, ".plt", 0)
+ r.Sym = ctxt.Syms.Lookup(".plt", 0)
r.Add = int64(braddoff(int32(r.Add), targ.Plt/4))
}
}
r.Type = obj.R_PCREL
- r.Sym = ld.Linklookup(ctxt, ".got", 0)
+ r.Sym = ctxt.Syms.Lookup(".got", 0)
r.Add += int64(targ.Got) + 4
return true
case 256 + ld.R_ARM_GOTPC: // R_ARM_BASE_PREL
r.Type = obj.R_PCREL
- r.Sym = ld.Linklookup(ctxt, ".got", 0)
+ r.Sym = ctxt.Syms.Lookup(".got", 0)
r.Add += 4
return true
r.Type = obj.R_CALLARM
if targ.Type == obj.SDYNIMPORT {
addpltsym(ctxt, targ)
- r.Sym = ld.Linklookup(ctxt, ".plt", 0)
+ r.Sym = ctxt.Syms.Lookup(".plt", 0)
r.Add = int64(braddoff(int32(r.Add), targ.Plt/4))
}
r.Type = obj.R_CALLARM
if targ.Type == obj.SDYNIMPORT {
addpltsym(ctxt, targ)
- r.Sym = ld.Linklookup(ctxt, ".plt", 0)
+ r.Sym = ctxt.Syms.Lookup(".plt", 0)
r.Add = int64(braddoff(int32(r.Add), targ.Plt/4))
}
switch r.Type {
case obj.R_CALLARM:
addpltsym(ctxt, targ)
- r.Sym = ld.Linklookup(ctxt, ".plt", 0)
+ r.Sym = ctxt.Syms.Lookup(".plt", 0)
r.Add = int64(targ.Plt)
return true
}
if ld.Iself {
ld.Adddynsym(ctxt, targ)
- rel := ld.Linklookup(ctxt, ".rel", 0)
+ rel := ctxt.Syms.Lookup(".rel", 0)
ld.Addaddrplus(ctxt, rel, s, int64(r.Off))
ld.Adduint32(ctxt, rel, ld.ELF32_R_INFO(uint32(targ.Dynid), ld.R_ARM_GLOB_DAT)) // we need a nil + A dynamic reloc
r.Type = obj.R_CONST // write r->add during relocsym
}
func elfsetupplt(ctxt *ld.Link) {
- plt := ld.Linklookup(ctxt, ".plt", 0)
- got := ld.Linklookup(ctxt, ".got.plt", 0)
+ plt := ctxt.Syms.Lookup(".plt", 0)
+ got := ctxt.Syms.Lookup(".got.plt", 0)
if plt.Size == 0 {
// str lr, [sp, #-4]!
ld.Adduint32(ctxt, plt, 0xe52de004)
return 0
case obj.R_GOTOFF:
- *val = ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(ld.Linklookup(ctxt, ".got", 0))
+ *val = ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(ctxt.Syms.Lookup(".got", 0))
return 0
// The following three arch specific relocations are only for generation of
// Linux/ARM ELF's PLT entry (3 assembler instruction)
case obj.R_PLT0: // add ip, pc, #0xXX00000
- if ld.Symaddr(ld.Linklookup(ctxt, ".got.plt", 0)) < ld.Symaddr(ld.Linklookup(ctxt, ".plt", 0)) {
+ if ld.Symaddr(ctxt.Syms.Lookup(".got.plt", 0)) < ld.Symaddr(ctxt.Syms.Lookup(".plt", 0)) {
ld.Errorf(s, ".got.plt should be placed after .plt section.")
}
- *val = 0xe28fc600 + (0xff & (int64(uint32(ld.Symaddr(r.Sym)-(ld.Symaddr(ld.Linklookup(ctxt, ".plt", 0))+int64(r.Off))+r.Add)) >> 20))
+ *val = 0xe28fc600 + (0xff & (int64(uint32(ld.Symaddr(r.Sym)-(ld.Symaddr(ctxt.Syms.Lookup(".plt", 0))+int64(r.Off))+r.Add)) >> 20))
return 0
case obj.R_PLT1: // add ip, ip, #0xYY000
- *val = 0xe28cca00 + (0xff & (int64(uint32(ld.Symaddr(r.Sym)-(ld.Symaddr(ld.Linklookup(ctxt, ".plt", 0))+int64(r.Off))+r.Add+4)) >> 12))
+ *val = 0xe28cca00 + (0xff & (int64(uint32(ld.Symaddr(r.Sym)-(ld.Symaddr(ctxt.Syms.Lookup(".plt", 0))+int64(r.Off))+r.Add+4)) >> 12))
return 0
case obj.R_PLT2: // ldr pc, [ip, #0xZZZ]!
- *val = 0xe5bcf000 + (0xfff & int64(uint32(ld.Symaddr(r.Sym)-(ld.Symaddr(ld.Linklookup(ctxt, ".plt", 0))+int64(r.Off))+r.Add+8)))
+ *val = 0xe5bcf000 + (0xfff & int64(uint32(ld.Symaddr(r.Sym)-(ld.Symaddr(ctxt.Syms.Lookup(".plt", 0))+int64(r.Off))+r.Add+8)))
return 0
ld.Adddynsym(ctxt, s)
if ld.Iself {
- plt := ld.Linklookup(ctxt, ".plt", 0)
- got := ld.Linklookup(ctxt, ".got.plt", 0)
- rel := ld.Linklookup(ctxt, ".rel.plt", 0)
+ plt := ctxt.Syms.Lookup(".plt", 0)
+ got := ctxt.Syms.Lookup(".got.plt", 0)
+ rel := ctxt.Syms.Lookup(".rel.plt", 0)
if plt.Size == 0 {
elfsetupplt(ctxt)
}
return
}
- got := ld.Linklookup(ctxt, ".got", 0)
+ got := ctxt.Syms.Lookup(".got", 0)
s.Got = int32(got.Size)
ld.Addaddrplus(ctxt, got, s, 0)
}
ld.Adddynsym(ctxt, s)
- got := ld.Linklookup(ctxt, ".got", 0)
+ got := ctxt.Syms.Lookup(".got", 0)
s.Got = int32(got.Size)
ld.Adduint32(ctxt, got, 0)
if ld.Iself {
- rel := ld.Linklookup(ctxt, ".rel", 0)
+ rel := ctxt.Syms.Lookup(".rel", 0)
ld.Addaddrplus(ctxt, rel, got, int64(s.Got))
ld.Adduint32(ctxt, rel, ld.ELF32_R_INFO(uint32(s.Dynid), ld.R_ARM_GLOB_DAT))
} else {
ld.Asmplan9sym(ctxt)
ld.Cflush()
- sym := ld.Linklookup(ctxt, "pclntab", 0)
+ sym := ctxt.Syms.Lookup("pclntab", 0)
if sym != nil {
ld.Lcsize = int32(len(sym.P))
for i := 0; int32(i) < ld.Lcsize; i++ {
if !ctxt.DynlinkingGo() {
return
}
- addmoduledata := ld.Linklookup(ctxt, "runtime.addmoduledata", 0)
+ addmoduledata := ctxt.Syms.Lookup("runtime.addmoduledata", 0)
if addmoduledata.Type == obj.STEXT {
// we're linking a module containing the runtime -> no need for
// an init function
return
}
addmoduledata.Attr |= ld.AttrReachable
- initfunc := ld.Linklookup(ctxt, "go.link.addmoduledata", 0)
+ initfunc := ctxt.Syms.Lookup("go.link.addmoduledata", 0)
initfunc.Type = obj.STEXT
initfunc.Attr |= ld.AttrLocal
initfunc.Attr |= ld.AttrReachable
rel = ld.Addrel(initfunc)
rel.Off = 8
rel.Siz = 4
- rel.Sym = ld.Linklookup(ctxt, "runtime.addmoduledata", 0)
+ rel.Sym = ctxt.Syms.Lookup("runtime.addmoduledata", 0)
rel.Type = obj.R_CALLARM64 // Really should be R_AARCH64_JUMP26 but doesn't seem to make any difference
ctxt.Textp = append(ctxt.Textp, initfunc)
- initarray_entry := ld.Linklookup(ctxt, "go.link.addmoduledatainit", 0)
+ initarray_entry := ctxt.Syms.Lookup("go.link.addmoduledatainit", 0)
initarray_entry.Attr |= ld.AttrReachable
initarray_entry.Attr |= ld.AttrLocal
initarray_entry.Type = obj.SINITARR
return 0
case obj.R_GOTOFF:
- *val = ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(ld.Linklookup(ctxt, ".got", 0))
+ *val = ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(ctxt.Syms.Lookup(".got", 0))
return 0
case obj.R_ADDRARM64:
ld.Asmplan9sym(ctxt)
ld.Cflush()
- sym := ld.Linklookup(ctxt, "pclntab", 0)
+ sym := ctxt.Syms.Lookup("pclntab", 0)
if sym != nil {
ld.Lcsize = int32(len(sym.P))
for i := 0; int32(i) < ld.Lcsize; i++ {
r.Done = 0
r.Type = obj.R_ADDR
- r.Xsym = Linkrlookup(ctxt, r.Sym.Sect.Name, 0)
+ r.Xsym = ctxt.Syms.ROLookup(r.Sym.Sect.Name, 0)
r.Xadd = r.Add + Symaddr(r.Sym) - int64(r.Sym.Sect.Vaddr)
o = r.Xadd
rs = r.Xsym
func dynrelocsym(ctxt *Link, s *Symbol) {
if (Headtype == obj.Hwindows || Headtype == obj.Hwindowsgui) && Linkmode != LinkExternal {
- rel := Linklookup(ctxt, ".rel", 0)
+ rel := ctxt.Syms.Lookup(".rel", 0)
if s == rel {
return
}
func addstrdata(ctxt *Link, name string, value string) {
p := fmt.Sprintf("%s.str", name)
- sp := Linklookup(ctxt, p, 0)
+ sp := ctxt.Syms.Lookup(p, 0)
Addstring(ctxt, sp, value)
sp.Type = obj.SRODATA
- s := Linklookup(ctxt, name, 0)
+ s := ctxt.Syms.Lookup(name, 0)
s.Size = 0
s.Attr |= AttrDuplicateOK
reachable := s.Attr.Reachable()
// addgostring adds str, as a Go string value, to s. symname is the name of the
// symbol used to define the string data and must be unique per linked object.
func addgostring(ctxt *Link, s *Symbol, symname, str string) {
- sym := Linklookup(ctxt, symname, 0)
+ sym := ctxt.Syms.Lookup(symname, 0)
if sym.Type != obj.Sxxx {
Errorf(s, "duplicate symname in addgostring: %s", symname)
}
func addinitarrdata(ctxt *Link, s *Symbol) {
p := s.Name + ".ptr"
- sp := Linklookup(ctxt, p, 0)
+ sp := ctxt.Syms.Lookup(p, 0)
sp.Type = obj.SINITARR
sp.Size = 0
sp.Attr |= AttrDuplicateOK
func (p *GCProg) Init(ctxt *Link, name string) {
p.ctxt = ctxt
- p.sym = Linklookup(ctxt, name, 0)
+ p.sym = ctxt.Syms.Lookup(name, 0)
p.w.Init(p.writeByte(ctxt))
if debugGCProg {
fmt.Fprintf(os.Stderr, "ld: start GCProg %s\n", name)
s.Value = int64(uint64(datsize) - sect.Vaddr)
// Resolve .TOC. symbol for this object file (ppc64)
- toc = Linkrlookup(ctxt, ".TOC.", int(s.Version))
+ toc = ctxt.Syms.ROLookup(".TOC.", int(s.Version))
if toc != nil {
toc.Sect = sect
toc.Outer = s
sect.Align = dataMaxAlign[obj.SNOPTRDATA]
datsize = Rnd(datsize, int64(sect.Align))
sect.Vaddr = uint64(datsize)
- Linklookup(ctxt, "runtime.noptrdata", 0).Sect = sect
- Linklookup(ctxt, "runtime.enoptrdata", 0).Sect = sect
+ ctxt.Syms.Lookup("runtime.noptrdata", 0).Sect = sect
+ ctxt.Syms.Lookup("runtime.enoptrdata", 0).Sect = sect
for _, s := range data[obj.SNOPTRDATA] {
datsize = aligndatsize(datsize, s)
s.Sect = sect
sect.Align = dataMaxAlign[obj.SDATA]
datsize = Rnd(datsize, int64(sect.Align))
sect.Vaddr = uint64(datsize)
- Linklookup(ctxt, "runtime.data", 0).Sect = sect
- Linklookup(ctxt, "runtime.edata", 0).Sect = sect
+ ctxt.Syms.Lookup("runtime.data", 0).Sect = sect
+ ctxt.Syms.Lookup("runtime.edata", 0).Sect = sect
var gc GCProg
gc.Init(ctxt, "runtime.gcdata")
for _, s := range data[obj.SDATA] {
sect.Align = dataMaxAlign[obj.SBSS]
datsize = Rnd(datsize, int64(sect.Align))
sect.Vaddr = uint64(datsize)
- Linklookup(ctxt, "runtime.bss", 0).Sect = sect
- Linklookup(ctxt, "runtime.ebss", 0).Sect = sect
+ ctxt.Syms.Lookup("runtime.bss", 0).Sect = sect
+ ctxt.Syms.Lookup("runtime.ebss", 0).Sect = sect
gc = GCProg{}
gc.Init(ctxt, "runtime.gcbss")
for _, s := range data[obj.SBSS] {
sect.Align = dataMaxAlign[obj.SNOPTRBSS]
datsize = Rnd(datsize, int64(sect.Align))
sect.Vaddr = uint64(datsize)
- Linklookup(ctxt, "runtime.noptrbss", 0).Sect = sect
- Linklookup(ctxt, "runtime.enoptrbss", 0).Sect = sect
+ ctxt.Syms.Lookup("runtime.noptrbss", 0).Sect = sect
+ ctxt.Syms.Lookup("runtime.enoptrbss", 0).Sect = sect
for _, s := range data[obj.SNOPTRBSS] {
datsize = aligndatsize(datsize, s)
s.Sect = sect
}
sect.Length = uint64(datsize) - sect.Vaddr
- Linklookup(ctxt, "runtime.end", 0).Sect = sect
+ ctxt.Syms.Lookup("runtime.end", 0).Sect = sect
checkdatsize(ctxt, datsize, obj.SNOPTRBSS)
if len(data[obj.STLSBSS]) > 0 {
sect = addsection(segro, ".rodata", 04)
sect.Vaddr = 0
- Linklookup(ctxt, "runtime.rodata", 0).Sect = sect
- Linklookup(ctxt, "runtime.erodata", 0).Sect = sect
+ ctxt.Syms.Lookup("runtime.rodata", 0).Sect = sect
+ ctxt.Syms.Lookup("runtime.erodata", 0).Sect = sect
if !UseRelro() {
- Linklookup(ctxt, "runtime.types", 0).Sect = sect
- Linklookup(ctxt, "runtime.etypes", 0).Sect = sect
+ ctxt.Syms.Lookup("runtime.types", 0).Sect = sect
+ ctxt.Syms.Lookup("runtime.etypes", 0).Sect = sect
}
for _, symn := range obj.ReadOnly {
align := dataMaxAlign[symn]
sect = addrelrosection("")
sect.Vaddr = 0
- Linklookup(ctxt, "runtime.types", 0).Sect = sect
- Linklookup(ctxt, "runtime.etypes", 0).Sect = sect
+ ctxt.Syms.Lookup("runtime.types", 0).Sect = sect
+ ctxt.Syms.Lookup("runtime.etypes", 0).Sect = sect
for _, symnro := range obj.ReadOnly {
symn := obj.RelROMap[symnro]
align := dataMaxAlign[symn]
sect.Align = dataMaxAlign[obj.STYPELINK]
datsize = Rnd(datsize, int64(sect.Align))
sect.Vaddr = uint64(datsize)
- Linklookup(ctxt, "runtime.typelink", 0).Sect = sect
- Linklookup(ctxt, "runtime.etypelink", 0).Sect = sect
+ ctxt.Syms.Lookup("runtime.typelink", 0).Sect = sect
+ ctxt.Syms.Lookup("runtime.etypelink", 0).Sect = sect
for _, s := range data[obj.STYPELINK] {
datsize = aligndatsize(datsize, s)
s.Sect = sect
sect.Align = dataMaxAlign[obj.SITABLINK]
datsize = Rnd(datsize, int64(sect.Align))
sect.Vaddr = uint64(datsize)
- Linklookup(ctxt, "runtime.itablink", 0).Sect = sect
- Linklookup(ctxt, "runtime.eitablink", 0).Sect = sect
+ ctxt.Syms.Lookup("runtime.itablink", 0).Sect = sect
+ ctxt.Syms.Lookup("runtime.eitablink", 0).Sect = sect
for _, s := range data[obj.SITABLINK] {
datsize = aligndatsize(datsize, s)
s.Sect = sect
sect.Align = dataMaxAlign[obj.SSYMTAB]
datsize = Rnd(datsize, int64(sect.Align))
sect.Vaddr = uint64(datsize)
- Linklookup(ctxt, "runtime.symtab", 0).Sect = sect
- Linklookup(ctxt, "runtime.esymtab", 0).Sect = sect
+ ctxt.Syms.Lookup("runtime.symtab", 0).Sect = sect
+ ctxt.Syms.Lookup("runtime.esymtab", 0).Sect = sect
for _, s := range data[obj.SSYMTAB] {
datsize = aligndatsize(datsize, s)
s.Sect = sect
sect.Align = dataMaxAlign[obj.SPCLNTAB]
datsize = Rnd(datsize, int64(sect.Align))
sect.Vaddr = uint64(datsize)
- Linklookup(ctxt, "runtime.pclntab", 0).Sect = sect
- Linklookup(ctxt, "runtime.epclntab", 0).Sect = sect
+ ctxt.Syms.Lookup("runtime.pclntab", 0).Sect = sect
+ ctxt.Syms.Lookup("runtime.epclntab", 0).Sect = sect
for _, s := range data[obj.SPCLNTAB] {
datsize = aligndatsize(datsize, s)
s.Sect = sect
return
}
- sym := Linklookup(ctxt, "go.buildid", 0)
+ sym := ctxt.Syms.Lookup("go.buildid", 0)
sym.Attr |= AttrReachable
// The \xff is invalid UTF-8, meant to make it less likely
// to find one of these accidentally.
sect := Segtext.Sect
sect.Align = int32(Funcalign)
- Linklookup(ctxt, "runtime.text", 0).Sect = sect
- Linklookup(ctxt, "runtime.etext", 0).Sect = sect
+ ctxt.Syms.Lookup("runtime.text", 0).Sect = sect
+ ctxt.Syms.Lookup("runtime.etext", 0).Sect = sect
if Headtype == obj.Hwindows || Headtype == obj.Hwindowsgui {
- Linklookup(ctxt, ".text", 0).Sect = sect
+ ctxt.Syms.Lookup(".text", 0).Sect = sect
}
va := uint64(*FlagTextAddr)
sect.Vaddr = va
var (
text = Segtext.Sect
- rodata = Linklookup(ctxt, "runtime.rodata", 0).Sect
- typelink = Linklookup(ctxt, "runtime.typelink", 0).Sect
- itablink = Linklookup(ctxt, "runtime.itablink", 0).Sect
- symtab = Linklookup(ctxt, "runtime.symtab", 0).Sect
- pclntab = Linklookup(ctxt, "runtime.pclntab", 0).Sect
- types = Linklookup(ctxt, "runtime.types", 0).Sect
+ rodata = ctxt.Syms.Lookup("runtime.rodata", 0).Sect
+ typelink = ctxt.Syms.Lookup("runtime.typelink", 0).Sect
+ itablink = ctxt.Syms.Lookup("runtime.itablink", 0).Sect
+ symtab = ctxt.Syms.Lookup("runtime.symtab", 0).Sect
+ pclntab = ctxt.Syms.Lookup("runtime.pclntab", 0).Sect
+ types = ctxt.Syms.Lookup("runtime.types", 0).Sect
)
for _, s := range datap {
}
if Buildmode == BuildmodeShared {
- s := Linklookup(ctxt, "go.link.abihashbytes", 0)
- sectSym := Linklookup(ctxt, ".note.go.abihash", 0)
+ s := ctxt.Syms.Lookup("go.link.abihashbytes", 0)
+ sectSym := ctxt.Syms.Lookup(".note.go.abihash", 0)
s.Sect = sectSym.Sect
s.Value = int64(sectSym.Sect.Vaddr + 16)
}
ctxt.xdefine("runtime.itablink", obj.SRODATA, int64(itablink.Vaddr))
ctxt.xdefine("runtime.eitablink", obj.SRODATA, int64(itablink.Vaddr+itablink.Length))
- sym := Linklookup(ctxt, "runtime.gcdata", 0)
+ sym := ctxt.Syms.Lookup("runtime.gcdata", 0)
sym.Attr |= AttrLocal
ctxt.xdefine("runtime.egcdata", obj.SRODATA, Symaddr(sym)+sym.Size)
- Linklookup(ctxt, "runtime.egcdata", 0).Sect = sym.Sect
+ ctxt.Syms.Lookup("runtime.egcdata", 0).Sect = sym.Sect
- sym = Linklookup(ctxt, "runtime.gcbss", 0)
+ sym = ctxt.Syms.Lookup("runtime.gcbss", 0)
sym.Attr |= AttrLocal
ctxt.xdefine("runtime.egcbss", obj.SRODATA, Symaddr(sym)+sym.Size)
- Linklookup(ctxt, "runtime.egcbss", 0).Sect = sym.Sect
+ ctxt.Syms.Lookup("runtime.egcbss", 0).Sect = sym.Sect
ctxt.xdefine("runtime.symtab", obj.SRODATA, int64(symtab.Vaddr))
ctxt.xdefine("runtime.esymtab", obj.SRODATA, int64(symtab.Vaddr+symtab.Length))
d.init()
d.flood()
- callSym := Linkrlookup(ctxt, "reflect.Value.Call", 0)
- methSym := Linkrlookup(ctxt, "reflect.Value.Method", 0)
+ callSym := ctxt.Syms.ROLookup("reflect.Value.Call", 0)
+ methSym := ctxt.Syms.ROLookup("reflect.Value.Method", 0)
reflectSeen := false
if ctxt.DynlinkingGo() {
// We don't keep the go.plugin.exports symbol,
// but we do keep the symbols it refers to.
- exports := Linkrlookup(d.ctxt, "go.plugin.exports", 0)
+ exports := d.ctxt.Syms.ROLookup("go.plugin.exports", 0)
for _, r := range exports.R {
d.mark(r.Sym, nil)
}
}
for _, name := range names {
- d.mark(Linkrlookup(d.ctxt, name, 0), nil)
+ d.mark(d.ctxt.Syms.ROLookup(name, 0), nil)
}
}
var dwarfp []*Symbol
func writeabbrev(ctxt *Link, syms []*Symbol) []*Symbol {
- s := Linklookup(ctxt, ".debug_abbrev", 0)
+ s := ctxt.Syms.Lookup(".debug_abbrev", 0)
s.Type = obj.SDWARFSECT
abbrevsym = s
Addbytes(ctxt, s, dwarf.GetAbbrev())
if name != "" && (abbrev <= dwarf.DW_ABRV_VARIABLE || abbrev >= dwarf.DW_ABRV_NULLTYPE) {
if abbrev != dwarf.DW_ABRV_VARIABLE || version == 0 {
- sym := Linklookup(ctxt, dwarf.InfoPrefix+name, version)
+ sym := ctxt.Syms.Lookup(dwarf.InfoPrefix+name, version)
sym.Attr |= AttrHidden
sym.Type = obj.SDWARFINFO
die.Sym = sym
}
func walksymtypedef(ctxt *Link, s *Symbol) *Symbol {
- if t := Linkrlookup(ctxt, s.Name+"..def", int(s.Version)); t != nil {
+ if t := ctxt.Syms.ROLookup(s.Name+"..def", int(s.Version)); t != nil {
return t
}
return s
func find(ctxt *Link, name string) *Symbol {
n := append(prefixBuf, name...)
// The string allocation below is optimized away because it is only used in a map lookup.
- s := Linkrlookup(ctxt, string(n), 0)
+ s := ctxt.Syms.ROLookup(string(n), 0)
prefixBuf = n[:len(dwarf.InfoPrefix)]
if s != nil && s.Type == obj.SDWARFINFO {
return s
// Lookup predefined types
func lookupOrDiag(ctxt *Link, n string) *Symbol {
- s := Linkrlookup(ctxt, n, 0)
+ s := ctxt.Syms.ROLookup(n, 0)
if s == nil || s.Size == 0 {
Exitf("dwarf: missing type: %s", n)
}
Errorf(nil, "dwarf: bad def in dotypedef")
}
- sym := Linklookup(ctxt, dtolsym(def.Sym).Name+"..def", 0)
+ sym := ctxt.Syms.Lookup(dtolsym(def.Sym).Name+"..def", 0)
sym.Attr |= AttrHidden
sym.Type = obj.SDWARFINFO
def.Sym = sym
func mkinternaltype(ctxt *Link, abbrev int, typename, keyname, valname string, f func(*dwarf.DWDie)) *Symbol {
name := mkinternaltypename(typename, keyname, valname)
symname := dwarf.InfoPrefix + name
- s := Linkrlookup(ctxt, symname, 0)
+ s := ctxt.Syms.ROLookup(symname, 0)
if s != nil && s.Type == obj.SDWARFINFO {
return s
}
func writelines(ctxt *Link, syms []*Symbol) ([]*Symbol, []*Symbol) {
var dwarfctxt dwarf.Context = dwctxt{ctxt}
if linesec == nil {
- linesec = Linklookup(ctxt, ".debug_line", 0)
+ linesec = ctxt.Syms.Lookup(".debug_line", 0)
}
linesec.Type = obj.SDWARFSECT
linesec.R = linesec.R[:0]
epc = s.Value + s.Size
epcs = s
- dsym := Linklookup(ctxt, dwarf.InfoPrefix+s.Name, int(s.Version))
+ dsym := ctxt.Syms.Lookup(dwarf.InfoPrefix+s.Name, int(s.Version))
dsym.Attr |= AttrHidden
dsym.Type = obj.SDWARFINFO
for _, r := range dsym.R {
continue
}
n := nameFromDIESym(r.Sym)
- defgotype(ctxt, Linklookup(ctxt, "type."+n, 0))
+ defgotype(ctxt, ctxt.Syms.Lookup("type."+n, 0))
}
}
funcs = append(funcs, dsym)
func writeframes(ctxt *Link, syms []*Symbol) []*Symbol {
var dwarfctxt dwarf.Context = dwctxt{ctxt}
if framesec == nil {
- framesec = Linklookup(ctxt, ".debug_frame", 0)
+ framesec = ctxt.Syms.Lookup(".debug_frame", 0)
}
framesec.Type = obj.SDWARFSECT
framesec.R = framesec.R[:0]
func writeinfo(ctxt *Link, syms []*Symbol, funcs []*Symbol) []*Symbol {
if infosec == nil {
- infosec = Linklookup(ctxt, ".debug_info", 0)
+ infosec = ctxt.Syms.Lookup(".debug_info", 0)
}
infosec.R = infosec.R[:0]
infosec.Type = obj.SDWARFINFO
syms = append(syms, infosec)
if arangessec == nil {
- arangessec = Linklookup(ctxt, ".dwarfaranges", 0)
+ arangessec = ctxt.Syms.Lookup(".dwarfaranges", 0)
}
arangessec.R = arangessec.R[:0]
}
func writepub(ctxt *Link, sname string, ispub func(*dwarf.DWDie) bool, syms []*Symbol) []*Symbol {
- s := Linklookup(ctxt, sname, 0)
+ s := ctxt.Syms.Lookup(sname, 0)
s.Type = obj.SDWARFSECT
syms = append(syms, s)
* because we need die->offs of dwarf.DW_globals.
*/
func writearanges(ctxt *Link, syms []*Symbol) []*Symbol {
- s := Linklookup(ctxt, ".debug_aranges", 0)
+ s := ctxt.Syms.Lookup(".debug_aranges", 0)
s.Type = obj.SDWARFSECT
// The first tuple is aligned to a multiple of the size of a single tuple
// (twice the size of an address)
func writegdbscript(ctxt *Link, syms []*Symbol) []*Symbol {
if gdbscript != "" {
- s := Linklookup(ctxt, ".debug_gdb_scripts", 0)
+ s := ctxt.Syms.Lookup(".debug_gdb_scripts", 0)
s.Type = obj.SDWARFSECT
syms = append(syms, s)
Adduint8(ctxt, s, 1) // magic 1 byte?
if Linkmode != LinkExternal {
return
}
- sym := Linklookup(ctxt, ".debug_info", 0)
+ sym := ctxt.Syms.Lookup(".debug_info", 0)
putelfsectionsym(sym, sym.Sect.Elfsect.shnum)
- sym = Linklookup(ctxt, ".debug_abbrev", 0)
+ sym = ctxt.Syms.Lookup(".debug_abbrev", 0)
putelfsectionsym(sym, sym.Sect.Elfsect.shnum)
- sym = Linklookup(ctxt, ".debug_line", 0)
+ sym = ctxt.Syms.Lookup(".debug_line", 0)
putelfsectionsym(sym, sym.Sect.Elfsect.shnum)
- sym = Linklookup(ctxt, ".debug_frame", 0)
+ sym = ctxt.Syms.Lookup(".debug_frame", 0)
putelfsectionsym(sym, sym.Sect.Elfsect.shnum)
}
}
nsym := Nelfsym
- s := Linklookup(ctxt, ".hash", 0)
+ s := ctxt.Syms.Lookup(".hash", 0)
s.Type = obj.SELFROSECT
s.Attr |= AttrReachable
}
// version symbols
- dynstr := Linklookup(ctxt, ".dynstr", 0)
+ dynstr := ctxt.Syms.Lookup(".dynstr", 0)
- s = Linklookup(ctxt, ".gnu.version_r", 0)
+ s = ctxt.Syms.Lookup(".gnu.version_r", 0)
i = 2
nfile := 0
var j int
}
// version references
- s = Linklookup(ctxt, ".gnu.version", 0)
+ s = ctxt.Syms.Lookup(".gnu.version", 0)
for i := 0; i < nsym; i++ {
if i == 0 {
}
}
- s = Linklookup(ctxt, ".dynamic", 0)
+ s = ctxt.Syms.Lookup(".dynamic", 0)
elfverneed = nfile
if elfverneed != 0 {
- elfwritedynentsym(ctxt, s, DT_VERNEED, Linklookup(ctxt, ".gnu.version_r", 0))
+ elfwritedynentsym(ctxt, s, DT_VERNEED, ctxt.Syms.Lookup(".gnu.version_r", 0))
Elfwritedynent(ctxt, s, DT_VERNEEDNUM, uint64(nfile))
- elfwritedynentsym(ctxt, s, DT_VERSYM, Linklookup(ctxt, ".gnu.version", 0))
+ elfwritedynentsym(ctxt, s, DT_VERSYM, ctxt.Syms.Lookup(".gnu.version", 0))
}
- sy := Linklookup(ctxt, elfRelType+".plt", 0)
+ sy := ctxt.Syms.Lookup(elfRelType+".plt", 0)
if sy.Size > 0 {
if elfRelType == ".rela" {
Elfwritedynent(ctxt, s, DT_PLTREL, DT_RELA)
}
func addgonote(ctxt *Link, sectionName string, tag uint32, desc []byte) {
- s := Linklookup(ctxt, sectionName, 0)
+ s := ctxt.Syms.Lookup(sectionName, 0)
s.Attr |= AttrReachable
s.Type = obj.SELFROSECT
// namesz
}
/* predefine strings we need for section headers */
- shstrtab := Linklookup(ctxt, ".shstrtab", 0)
+ shstrtab := ctxt.Syms.Lookup(".shstrtab", 0)
shstrtab.Type = obj.SELFROSECT
shstrtab.Attr |= AttrReachable
Addstring(ctxt, shstrtab, ".gnu.version_r")
/* dynamic symbol table - first entry all zeros */
- s := Linklookup(ctxt, ".dynsym", 0)
+ s := ctxt.Syms.Lookup(".dynsym", 0)
s.Type = obj.SELFROSECT
s.Attr |= AttrReachable
}
/* dynamic string table */
- s = Linklookup(ctxt, ".dynstr", 0)
+ s = ctxt.Syms.Lookup(".dynstr", 0)
s.Type = obj.SELFROSECT
s.Attr |= AttrReachable
dynstr := s
/* relocation table */
- s = Linklookup(ctxt, elfRelType, 0)
+ s = ctxt.Syms.Lookup(elfRelType, 0)
s.Attr |= AttrReachable
s.Type = obj.SELFROSECT
/* global offset table */
- s = Linklookup(ctxt, ".got", 0)
+ s = ctxt.Syms.Lookup(".got", 0)
s.Attr |= AttrReachable
s.Type = obj.SELFGOT // writable
/* ppc64 glink resolver */
if SysArch.Family == sys.PPC64 {
- s := Linklookup(ctxt, ".glink", 0)
+ s := ctxt.Syms.Lookup(".glink", 0)
s.Attr |= AttrReachable
s.Type = obj.SELFRXSECT
}
/* hash */
- s = Linklookup(ctxt, ".hash", 0)
+ s = ctxt.Syms.Lookup(".hash", 0)
s.Attr |= AttrReachable
s.Type = obj.SELFROSECT
- s = Linklookup(ctxt, ".got.plt", 0)
+ s = ctxt.Syms.Lookup(".got.plt", 0)
s.Attr |= AttrReachable
s.Type = obj.SELFSECT // writable
- s = Linklookup(ctxt, ".plt", 0)
+ s = ctxt.Syms.Lookup(".plt", 0)
s.Attr |= AttrReachable
if SysArch.Family == sys.PPC64 {
Thearch.Elfsetupplt(ctxt)
- s = Linklookup(ctxt, elfRelType+".plt", 0)
+ s = ctxt.Syms.Lookup(elfRelType+".plt", 0)
s.Attr |= AttrReachable
s.Type = obj.SELFROSECT
- s = Linklookup(ctxt, ".gnu.version", 0)
+ s = ctxt.Syms.Lookup(".gnu.version", 0)
s.Attr |= AttrReachable
s.Type = obj.SELFROSECT
- s = Linklookup(ctxt, ".gnu.version_r", 0)
+ s = ctxt.Syms.Lookup(".gnu.version_r", 0)
s.Attr |= AttrReachable
s.Type = obj.SELFROSECT
/* define dynamic elf table */
- s = Linklookup(ctxt, ".dynamic", 0)
+ s = ctxt.Syms.Lookup(".dynamic", 0)
s.Attr |= AttrReachable
s.Type = obj.SELFSECT // writable
/*
* .dynamic table
*/
- elfwritedynentsym(ctxt, s, DT_HASH, Linklookup(ctxt, ".hash", 0))
+ elfwritedynentsym(ctxt, s, DT_HASH, ctxt.Syms.Lookup(".hash", 0))
- elfwritedynentsym(ctxt, s, DT_SYMTAB, Linklookup(ctxt, ".dynsym", 0))
+ elfwritedynentsym(ctxt, s, DT_SYMTAB, ctxt.Syms.Lookup(".dynsym", 0))
if elf64 {
Elfwritedynent(ctxt, s, DT_SYMENT, ELF64SYMSIZE)
} else {
Elfwritedynent(ctxt, s, DT_SYMENT, ELF32SYMSIZE)
}
- elfwritedynentsym(ctxt, s, DT_STRTAB, Linklookup(ctxt, ".dynstr", 0))
- elfwritedynentsymsize(ctxt, s, DT_STRSZ, Linklookup(ctxt, ".dynstr", 0))
+ elfwritedynentsym(ctxt, s, DT_STRTAB, ctxt.Syms.Lookup(".dynstr", 0))
+ elfwritedynentsymsize(ctxt, s, DT_STRSZ, ctxt.Syms.Lookup(".dynstr", 0))
if elfRelType == ".rela" {
- elfwritedynentsym(ctxt, s, DT_RELA, Linklookup(ctxt, ".rela", 0))
- elfwritedynentsymsize(ctxt, s, DT_RELASZ, Linklookup(ctxt, ".rela", 0))
+ elfwritedynentsym(ctxt, s, DT_RELA, ctxt.Syms.Lookup(".rela", 0))
+ elfwritedynentsymsize(ctxt, s, DT_RELASZ, ctxt.Syms.Lookup(".rela", 0))
Elfwritedynent(ctxt, s, DT_RELAENT, ELF64RELASIZE)
} else {
- elfwritedynentsym(ctxt, s, DT_REL, Linklookup(ctxt, ".rel", 0))
- elfwritedynentsymsize(ctxt, s, DT_RELSZ, Linklookup(ctxt, ".rel", 0))
+ elfwritedynentsym(ctxt, s, DT_REL, ctxt.Syms.Lookup(".rel", 0))
+ elfwritedynentsymsize(ctxt, s, DT_RELSZ, ctxt.Syms.Lookup(".rel", 0))
Elfwritedynent(ctxt, s, DT_RELENT, ELF32RELSIZE)
}
}
if SysArch.Family == sys.PPC64 {
- elfwritedynentsym(ctxt, s, DT_PLTGOT, Linklookup(ctxt, ".plt", 0))
+ elfwritedynentsym(ctxt, s, DT_PLTGOT, ctxt.Syms.Lookup(".plt", 0))
} else if SysArch.Family == sys.S390X {
- elfwritedynentsym(ctxt, s, DT_PLTGOT, Linklookup(ctxt, ".got", 0))
+ elfwritedynentsym(ctxt, s, DT_PLTGOT, ctxt.Syms.Lookup(".got", 0))
} else {
- elfwritedynentsym(ctxt, s, DT_PLTGOT, Linklookup(ctxt, ".got.plt", 0))
+ elfwritedynentsym(ctxt, s, DT_PLTGOT, ctxt.Syms.Lookup(".got.plt", 0))
}
if SysArch.Family == sys.PPC64 {
if Buildmode == BuildmodeShared {
// The go.link.abihashbytes symbol will be pointed at the appropriate
// part of the .note.go.abihash section in data.go:func address().
- s := Linklookup(ctxt, "go.link.abihashbytes", 0)
+ s := ctxt.Syms.Lookup("go.link.abihashbytes", 0)
s.Attr |= AttrLocal
s.Type = obj.SRODATA
s.Attr |= AttrSpecial
sh.link = uint32(elfshname(".dynstr").shnum)
// sh->info = index of first non-local symbol (number of local symbols)
- shsym(ctxt, sh, Linklookup(ctxt, ".dynsym", 0))
+ shsym(ctxt, sh, ctxt.Syms.Lookup(".dynsym", 0))
sh = elfshname(".dynstr")
sh.type_ = SHT_STRTAB
sh.flags = SHF_ALLOC
sh.addralign = 1
- shsym(ctxt, sh, Linklookup(ctxt, ".dynstr", 0))
+ shsym(ctxt, sh, ctxt.Syms.Lookup(".dynstr", 0))
if elfverneed != 0 {
sh := elfshname(".gnu.version")
sh.addralign = 2
sh.link = uint32(elfshname(".dynsym").shnum)
sh.entsize = 2
- shsym(ctxt, sh, Linklookup(ctxt, ".gnu.version", 0))
+ shsym(ctxt, sh, ctxt.Syms.Lookup(".gnu.version", 0))
sh = elfshname(".gnu.version_r")
sh.type_ = SHT_GNU_VERNEED
sh.addralign = uint64(SysArch.RegSize)
sh.info = uint32(elfverneed)
sh.link = uint32(elfshname(".dynstr").shnum)
- shsym(ctxt, sh, Linklookup(ctxt, ".gnu.version_r", 0))
+ shsym(ctxt, sh, ctxt.Syms.Lookup(".gnu.version_r", 0))
}
if elfRelType == ".rela" {
sh.addralign = uint64(SysArch.RegSize)
sh.link = uint32(elfshname(".dynsym").shnum)
sh.info = uint32(elfshname(".plt").shnum)
- shsym(ctxt, sh, Linklookup(ctxt, ".rela.plt", 0))
+ shsym(ctxt, sh, ctxt.Syms.Lookup(".rela.plt", 0))
sh = elfshname(".rela")
sh.type_ = SHT_RELA
sh.entsize = ELF64RELASIZE
sh.addralign = 8
sh.link = uint32(elfshname(".dynsym").shnum)
- shsym(ctxt, sh, Linklookup(ctxt, ".rela", 0))
+ shsym(ctxt, sh, ctxt.Syms.Lookup(".rela", 0))
} else {
sh := elfshname(".rel.plt")
sh.type_ = SHT_REL
sh.entsize = ELF32RELSIZE
sh.addralign = 4
sh.link = uint32(elfshname(".dynsym").shnum)
- shsym(ctxt, sh, Linklookup(ctxt, ".rel.plt", 0))
+ shsym(ctxt, sh, ctxt.Syms.Lookup(".rel.plt", 0))
sh = elfshname(".rel")
sh.type_ = SHT_REL
sh.entsize = ELF32RELSIZE
sh.addralign = 4
sh.link = uint32(elfshname(".dynsym").shnum)
- shsym(ctxt, sh, Linklookup(ctxt, ".rel", 0))
+ shsym(ctxt, sh, ctxt.Syms.Lookup(".rel", 0))
}
if eh.machine == EM_PPC64 {
sh.type_ = SHT_PROGBITS
sh.flags = SHF_ALLOC + SHF_EXECINSTR
sh.addralign = 4
- shsym(ctxt, sh, Linklookup(ctxt, ".glink", 0))
+ shsym(ctxt, sh, ctxt.Syms.Lookup(".glink", 0))
}
sh = elfshname(".plt")
sh.entsize = 4
}
sh.addralign = sh.entsize
- shsym(ctxt, sh, Linklookup(ctxt, ".plt", 0))
+ shsym(ctxt, sh, ctxt.Syms.Lookup(".plt", 0))
// On ppc64, .got comes from the input files, so don't
// create it here, and .got.plt is not used.
sh.flags = SHF_ALLOC + SHF_WRITE
sh.entsize = uint64(SysArch.RegSize)
sh.addralign = uint64(SysArch.RegSize)
- shsym(ctxt, sh, Linklookup(ctxt, ".got", 0))
+ shsym(ctxt, sh, ctxt.Syms.Lookup(".got", 0))
sh = elfshname(".got.plt")
sh.type_ = SHT_PROGBITS
sh.flags = SHF_ALLOC + SHF_WRITE
sh.entsize = uint64(SysArch.RegSize)
sh.addralign = uint64(SysArch.RegSize)
- shsym(ctxt, sh, Linklookup(ctxt, ".got.plt", 0))
+ shsym(ctxt, sh, ctxt.Syms.Lookup(".got.plt", 0))
}
sh = elfshname(".hash")
sh.entsize = 4
sh.addralign = uint64(SysArch.RegSize)
sh.link = uint32(elfshname(".dynsym").shnum)
- shsym(ctxt, sh, Linklookup(ctxt, ".hash", 0))
+ shsym(ctxt, sh, ctxt.Syms.Lookup(".hash", 0))
/* sh and PT_DYNAMIC for .dynamic section */
sh = elfshname(".dynamic")
sh.entsize = 2 * uint64(SysArch.RegSize)
sh.addralign = uint64(SysArch.RegSize)
sh.link = uint32(elfshname(".dynstr").shnum)
- shsym(ctxt, sh, Linklookup(ctxt, ".dynamic", 0))
+ shsym(ctxt, sh, ctxt.Syms.Lookup(".dynamic", 0))
ph := newElfPhdr()
ph.type_ = PT_DYNAMIC
ph.flags = PF_R + PF_W
sh := elfshname(".shstrtab")
sh.type_ = SHT_STRTAB
sh.addralign = 1
- shsym(ctxt, sh, Linklookup(ctxt, ".shstrtab", 0))
+ shsym(ctxt, sh, ctxt.Syms.Lookup(".shstrtab", 0))
eh.shstrndx = uint16(sh.shnum)
// put these sections early in the list
s.Dynid = int32(Nelfsym)
Nelfsym++
- d := Linklookup(ctxt, ".dynsym", 0)
+ d := ctxt.Syms.Lookup(".dynsym", 0)
name := s.Extname
- Adduint32(ctxt, d, uint32(Addstring(ctxt, Linklookup(ctxt, ".dynstr", 0), name)))
+ Adduint32(ctxt, d, uint32(Addstring(ctxt, ctxt.Syms.Lookup(".dynstr", 0), name)))
/* type */
t := STB_GLOBAL << 4
Adduint64(ctxt, d, uint64(s.Size))
if SysArch.Family == sys.AMD64 && !s.Attr.CgoExportDynamic() && s.Dynimplib != "" && !seenlib[s.Dynimplib] {
- Elfwritedynent(ctxt, Linklookup(ctxt, ".dynamic", 0), DT_NEEDED, uint64(Addstring(ctxt, Linklookup(ctxt, ".dynstr", 0), s.Dynimplib)))
+ Elfwritedynent(ctxt, ctxt.Syms.Lookup(".dynamic", 0), DT_NEEDED, uint64(Addstring(ctxt, ctxt.Syms.Lookup(".dynstr", 0), s.Dynimplib)))
}
} else {
s.Dynid = int32(Nelfsym)
Nelfsym++
- d := Linklookup(ctxt, ".dynsym", 0)
+ d := ctxt.Syms.Lookup(".dynsym", 0)
/* name */
name := s.Extname
- Adduint32(ctxt, d, uint32(Addstring(ctxt, Linklookup(ctxt, ".dynstr", 0), name)))
+ Adduint32(ctxt, d, uint32(Addstring(ctxt, ctxt.Syms.Lookup(".dynstr", 0), name)))
/* value */
if s.Type == obj.SDYNIMPORT {
if i := strings.Index(remote, "#"); i >= 0 {
remote, q = remote[:i], remote[i+1:]
}
- s = Linklookup(ctxt, local, 0)
+ s = ctxt.Syms.Lookup(local, 0)
if local != f[1] {
}
if s.Type == 0 || s.Type == obj.SXREF || s.Type == obj.SHOSTOBJ {
goto err
}
local = f[1]
- s = Linklookup(ctxt, local, 0)
+ s = ctxt.Syms.Lookup(local, 0)
s.Type = obj.SHOSTOBJ
s.Size = 0
continue
remote = local
}
local = expandpkg(local, pkg)
- s = Linklookup(ctxt, local, 0)
+ s = ctxt.Syms.Lookup(local, 0)
switch Buildmode {
case BuildmodeCShared, BuildmodeCArchive, BuildmodePlugin:
- if s == Linklookup(ctxt, "main", 0) {
+ if s == ctxt.Syms.Lookup("main", 0) {
continue
}
}
seenlib[lib] = true
if Iself {
- s := Linklookup(ctxt, ".dynstr", 0)
+ s := ctxt.Syms.Lookup(".dynstr", 0)
if s.Size == 0 {
Addstring(ctxt, s, "")
}
- Elfwritedynent(ctxt, Linklookup(ctxt, ".dynamic", 0), DT_NEEDED, uint64(Addstring(ctxt, s, lib)))
+ Elfwritedynent(ctxt, ctxt.Syms.Lookup(".dynamic", 0), DT_NEEDED, uint64(Addstring(ctxt, s, lib)))
} else {
Errorf(nil, "adddynlib: unsupported binary format")
}
if *flagFieldTrack == "" {
return
}
- s := Linklookup(ctxt, *flagFieldTrack, 0)
+ s := ctxt.Syms.Lookup(*flagFieldTrack, 0)
if !s.Attr.Reachable() {
return
}
}
name = fmt.Sprintf("%s(%s)", pkg, sect.name)
- s = Linklookup(ctxt, name, ctxt.Syms.Version)
+ s = ctxt.Syms.Lookup(name, ctxt.Syms.Version)
switch int(sect.flags) & (ElfSectFlagAlloc | ElfSectFlagWrite | ElfSectFlagExec) {
default:
switch sym.bind {
case ElfSymBindGlobal:
if needSym != 0 {
- s = Linklookup(ctxt, sym.name, 0)
+ s = ctxt.Syms.Lookup(sym.name, 0)
// for global scoped hidden symbols we should insert it into
// symbol hash table, but mark them as hidden.
// We need to be able to look this up,
// so put it in the hash table.
if needSym != 0 {
- s = Linklookup(ctxt, sym.name, ctxt.Syms.Version)
+ s = ctxt.Syms.Lookup(sym.name, ctxt.Syms.Version)
s.Type |= obj.SHIDDEN
}
case ElfSymBindWeak:
if needSym != 0 {
- s = Linklookup(ctxt, sym.name, 0)
+ s = ctxt.Syms.Lookup(sym.name, 0)
if sym.other == 2 {
s.Type |= obj.SHIDDEN
}
continue
}
name = fmt.Sprintf("%s(%s/%s)", pkg, sect.segname, sect.name)
- s = Linklookup(ctxt, name, ctxt.Syms.Version)
+ s = ctxt.Syms.Lookup(name, ctxt.Syms.Version)
if s.Type != 0 {
err = fmt.Errorf("duplicate %s/%s", sect.segname, sect.name)
goto bad
if sym.type_&N_EXT == 0 {
v = ctxt.Syms.Version
}
- s = Linklookup(ctxt, name, v)
+ s = ctxt.Syms.Lookup(name, v)
if sym.type_&N_EXT == 0 {
s.Attr |= AttrDuplicateOK
}
}
name = fmt.Sprintf("%s(%s)", pkg, sect.name)
- s = Linklookup(ctxt, name, ctxt.Syms.Version)
+ s = ctxt.Syms.Lookup(name, ctxt.Syms.Version)
switch sect.sh.Characteristics & (IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE | IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE) {
case IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ: //.rdata
case IMAGE_SYM_DTYPE_FUNCTION, IMAGE_SYM_DTYPE_NULL:
switch sym.sclass {
case IMAGE_SYM_CLASS_EXTERNAL: //global
- s = Linklookup(ctxt, name, 0)
+ s = ctxt.Syms.Lookup(name, 0)
case IMAGE_SYM_CLASS_NULL, IMAGE_SYM_CLASS_STATIC, IMAGE_SYM_CLASS_LABEL:
- s = Linklookup(ctxt, name, ctxt.Syms.Version)
+ s = ctxt.Syms.Lookup(name, ctxt.Syms.Version)
s.Attr |= AttrDuplicateOK
default:
if !ctxt.Loaded {
panic("DynlinkingGo called before all symbols loaded")
}
- canUsePlugins := Linkrlookup(ctxt, "plugin.Open", 0) != nil
+ canUsePlugins := ctxt.Syms.ROLookup("plugin.Open", 0) != nil
return Buildmode == BuildmodeShared || *FlagLinkshared || Buildmode == BuildmodePlugin || canUsePlugins
}
func (ctxt *Link) loadlib() {
switch Buildmode {
case BuildmodeCShared, BuildmodePlugin:
- s := Linklookup(ctxt, "runtime.islibrary", 0)
+ s := ctxt.Syms.Lookup("runtime.islibrary", 0)
s.Attr |= AttrDuplicateOK
Adduint8(ctxt, s, 1)
case BuildmodeCArchive:
- s := Linklookup(ctxt, "runtime.isarchive", 0)
+ s := ctxt.Syms.Lookup("runtime.isarchive", 0)
s.Attr |= AttrDuplicateOK
Adduint8(ctxt, s, 1)
}
determineLinkMode(ctxt)
if Linkmode == LinkExternal && SysArch.Family == sys.PPC64 {
- toc := Linklookup(ctxt, ".TOC.", 0)
+ toc := ctxt.Syms.Lookup(".TOC.", 0)
toc.Type = obj.SDYNIMPORT
}
}
}
- tlsg := Linklookup(ctxt, "runtime.tlsg", 0)
+ tlsg := ctxt.Syms.Lookup("runtime.tlsg", 0)
// runtime.tlsg is used for external linking on platforms that do not define
// a variable to hold g in assembly (currently only intel).
var moduledata *Symbol
if Buildmode == BuildmodePlugin {
- moduledata = Linklookup(ctxt, "local.pluginmoduledata", 0)
+ moduledata = ctxt.Syms.Lookup("local.pluginmoduledata", 0)
moduledata.Attr |= AttrLocal
} else {
- moduledata = Linklookup(ctxt, "runtime.firstmoduledata", 0)
+ moduledata = ctxt.Syms.Lookup("runtime.firstmoduledata", 0)
}
if moduledata.Type != 0 && moduledata.Type != obj.SDYNIMPORT {
// If the module (toolchain-speak for "executable or shared
// In addition, on ARM, the runtime depends on the linker
// recording the value of GOARM.
if SysArch.Family == sys.ARM {
- s := Linklookup(ctxt, "runtime.goarm", 0)
+ s := ctxt.Syms.Lookup("runtime.goarm", 0)
s.Type = obj.SRODATA
s.Size = 0
Adduint8(ctxt, s, uint8(obj.GOARM))
}
if obj.Framepointer_enabled(obj.GOOS, obj.GOARCH) {
- s := Linklookup(ctxt, "runtime.framepointer_enabled", 0)
+ s := ctxt.Syms.Lookup("runtime.framepointer_enabled", 0)
s.Type = obj.SRODATA
s.Size = 0
Adduint8(ctxt, s, 1)
} else {
// If OTOH the module does not contain the runtime package,
// create a local symbol for the moduledata.
- moduledata = Linklookup(ctxt, "local.moduledata", 0)
+ moduledata = ctxt.Syms.Lookup("local.moduledata", 0)
moduledata.Attr |= AttrLocal
}
// In all cases way we mark the moduledata as noptrdata to hide it from
if SysArch == sys.Arch386 {
if (Buildmode == BuildmodeCArchive && Iself) || Buildmode == BuildmodeCShared || Buildmode == BuildmodePIE || ctxt.DynlinkingGo() {
- got := Linklookup(ctxt, "_GLOBAL_OFFSET_TABLE_", 0)
+ got := ctxt.Syms.Lookup("_GLOBAL_OFFSET_TABLE_", 0)
got.Type = obj.SDYNIMPORT
got.Attr |= AttrReachable
}
if elf.ST_TYPE(elfsym.Info) == elf.STT_NOTYPE || elf.ST_TYPE(elfsym.Info) == elf.STT_SECTION {
continue
}
- lsym := Linklookup(ctxt, elfsym.Name, 0)
+ lsym := ctxt.Syms.Lookup(elfsym.Name, 0)
// Because loadlib above loads all .a files before loading any shared
// libraries, any non-dynimport symbols we find that duplicate symbols
// already loaded should be ignored (the symbols from the .a files
func (ctxt *Link) dostkcheck() {
var ch chain
- morestack = Linklookup(ctxt, "runtime.morestack", 0)
+ morestack = ctxt.Syms.Lookup("runtime.morestack", 0)
// Every splitting function ensures that there are at least StackLimit
// bytes available below SP when the splitting prologue finishes.
func genasmsym(ctxt *Link, put func(*Link, *Symbol, string, SymbolType, int64, *Symbol)) {
// These symbols won't show up in the first loop below because we
// skip STEXT symbols. Normal STEXT symbols are emitted by walking textp.
- s := Linklookup(ctxt, "runtime.text", 0)
+ s := ctxt.Syms.Lookup("runtime.text", 0)
if s.Type == obj.STEXT {
put(ctxt, s, s.Name, TextSym, s.Value, nil)
}
- s = Linklookup(ctxt, "runtime.etext", 0)
+ s = ctxt.Syms.Lookup("runtime.etext", 0)
if s.Type == obj.STEXT {
put(ctxt, s, s.Name, TextSym, s.Value, nil)
}
}
func (ctxt *Link) xdefine(p string, t obj.SymKind, v int64) {
- s := Linklookup(ctxt, p, 0)
+ s := ctxt.Syms.Lookup(p, 0)
s.Type = t
s.Value = v
s.Attr |= AttrReachable
if a[0] >= '0' && a[0] <= '9' {
return atolwhex(a)
}
- s := Linklookup(ctxt, a, 0)
+ s := ctxt.Syms.Lookup(a, 0)
if s.Type == 0 {
return *FlagTextAddr
}
}
// empirically, string table must begin with " \x00".
- s := Linklookup(ctxt, ".machosymstr", 0)
+ s := ctxt.Syms.Lookup(".machosymstr", 0)
s.Type = obj.SMACHOSYMSTR
s.Attr |= AttrReachable
Adduint8(ctxt, s, ' ')
Adduint8(ctxt, s, '\x00')
- s = Linklookup(ctxt, ".machosymtab", 0)
+ s = ctxt.Syms.Lookup(".machosymtab", 0)
s.Type = obj.SMACHOSYMTAB
s.Attr |= AttrReachable
if Linkmode != LinkExternal {
- s := Linklookup(ctxt, ".plt", 0) // will be __symbol_stub
+ s := ctxt.Syms.Lookup(".plt", 0) // will be __symbol_stub
s.Type = obj.SMACHOPLT
s.Attr |= AttrReachable
- s = Linklookup(ctxt, ".got", 0) // will be __nl_symbol_ptr
+ s = ctxt.Syms.Lookup(".got", 0) // will be __nl_symbol_ptr
s.Type = obj.SMACHOGOT
s.Attr |= AttrReachable
s.Align = 4
- s = Linklookup(ctxt, ".linkedit.plt", 0) // indirect table for .plt
+ s = ctxt.Syms.Lookup(".linkedit.plt", 0) // indirect table for .plt
s.Type = obj.SMACHOINDIRECTPLT
s.Attr |= AttrReachable
- s = Linklookup(ctxt, ".linkedit.got", 0) // indirect table for .got
+ s = ctxt.Syms.Lookup(".linkedit.got", 0) // indirect table for .got
s.Type = obj.SMACHOINDIRECTGOT
s.Attr |= AttrReachable
}
if sect.Name == ".got" {
msect.name = "__nl_symbol_ptr"
msect.flag = 6 /* section with nonlazy symbol pointers */
- msect.res1 = uint32(Linklookup(ctxt, ".linkedit.plt", 0).Size / 4) /* offset into indirect symbol table */
+ msect.res1 = uint32(ctxt.Syms.Lookup(".linkedit.plt", 0).Size / 4) /* offset into indirect symbol table */
}
if sect.Name == ".init_array" {
if !*FlagD {
// must match domacholink below
- s1 := Linklookup(ctxt, ".machosymtab", 0)
- s2 := Linklookup(ctxt, ".linkedit.plt", 0)
- s3 := Linklookup(ctxt, ".linkedit.got", 0)
- s4 := Linklookup(ctxt, ".machosymstr", 0)
+ s1 := ctxt.Syms.Lookup(".machosymtab", 0)
+ s2 := ctxt.Syms.Lookup(".linkedit.plt", 0)
+ s3 := ctxt.Syms.Lookup(".linkedit.got", 0)
+ s4 := ctxt.Syms.Lookup(".machosymstr", 0)
if Linkmode != LinkExternal {
ms := newMachoSeg("__LINKEDIT", 0)
}
func machosymtab(ctxt *Link) {
- symtab := Linklookup(ctxt, ".machosymtab", 0)
- symstr := Linklookup(ctxt, ".machosymstr", 0)
+ symtab := ctxt.Syms.Lookup(".machosymtab", 0)
+ symstr := ctxt.Syms.Lookup(".machosymstr", 0)
for i := 0; i < nsortsym; i++ {
s := sortsym[i]
ml.data[11] = 0 /* nextrefsyms */
// must match domacholink below
- s1 := Linklookup(ctxt, ".machosymtab", 0)
+ s1 := ctxt.Syms.Lookup(".machosymtab", 0)
- s2 := Linklookup(ctxt, ".linkedit.plt", 0)
- s3 := Linklookup(ctxt, ".linkedit.got", 0)
+ s2 := ctxt.Syms.Lookup(".linkedit.plt", 0)
+ s3 := ctxt.Syms.Lookup(".linkedit.got", 0)
ml.data[12] = uint32(linkoff + s1.Size) /* indirectsymoff */
ml.data[13] = uint32((s2.Size + s3.Size) / 4) /* nindirectsyms */
machosymtab(ctxt)
// write data that will be linkedit section
- s1 := Linklookup(ctxt, ".machosymtab", 0)
+ s1 := ctxt.Syms.Lookup(".machosymtab", 0)
- s2 := Linklookup(ctxt, ".linkedit.plt", 0)
- s3 := Linklookup(ctxt, ".linkedit.got", 0)
- s4 := Linklookup(ctxt, ".machosymstr", 0)
+ s2 := ctxt.Syms.Lookup(".linkedit.plt", 0)
+ s3 := ctxt.Syms.Lookup(".linkedit.got", 0)
+ s4 := ctxt.Syms.Lookup(".machosymstr", 0)
// Force the linkedit section to end on a 16-byte
// boundary. This allows pure (non-cgo) Go binaries
if v == 1 {
v = r.ctxt.Syms.Version
}
- s := Linklookup(r.ctxt, name, v)
+ s := r.ctxt.Syms.Lookup(name, v)
r.refs = append(r.refs, s)
if s == nil || v != 0 {
func (ctxt *Link) pclntab() {
funcdataBytes := int64(0)
- ftab := Linklookup(ctxt, "runtime.pclntab", 0)
+ ftab := ctxt.Syms.Lookup("runtime.pclntab", 0)
ftab.Type = obj.SPCLNTAB
ftab.Attr |= AttrReachable
// findfunctab generates a lookup table to quickly find the containing
// function for a pc. See src/runtime/symtab.go:findfunc for details.
func (ctxt *Link) findfunctab() {
- t := Linklookup(ctxt, "runtime.findfunctab", 0)
+ t := ctxt.Syms.Lookup("runtime.findfunctab", 0)
t.Type = obj.SRODATA
t.Attr |= AttrReachable
t.Attr |= AttrLocal
if SysArch.Family == sys.I386 && m.argsize >= 0 {
dynName += fmt.Sprintf("@%d", m.argsize)
}
- dynSym := Linklookup(ctxt, dynName, 0)
+ dynSym := ctxt.Syms.Lookup(dynName, 0)
dynSym.Attr |= AttrReachable
dynSym.Type = obj.SHOSTOBJ
r := Addrel(m.s)
}
}
} else {
- dynamic := Linklookup(ctxt, ".windynamic", 0)
+ dynamic := ctxt.Syms.Lookup(".windynamic", 0)
dynamic.Attr |= AttrReachable
dynamic.Type = obj.SWINDOWS
for d := dr; d != nil; d = d.next {
func addimports(ctxt *Link, datsect *IMAGE_SECTION_HEADER) {
startoff := coutbuf.Offset()
- dynamic := Linklookup(ctxt, ".windynamic", 0)
+ dynamic := ctxt.Syms.Lookup(".windynamic", 0)
// skip import descriptor table (will write it later)
n := uint64(0)
}
data.NumberOfRelocations = uint16(n - 1)
- dottext := Linklookup(ctxt, ".text", 0)
+ dottext := ctxt.Syms.Lookup(".text", 0)
ctors.NumberOfRelocations = 1
ctors.PointerToRelocations = uint32(coutbuf.Offset())
sectoff := ctors.VirtualAddress
func (ctxt *Link) dope() {
/* relocation table */
- rel := Linklookup(ctxt, ".rel", 0)
+ rel := ctxt.Syms.Lookup(".rel", 0)
rel.Attr |= AttrReachable
rel.Type = obj.SELFROSECT
}
}
- s := Linklookup(ctxt, ".text", 0)
+ s := ctxt.Syms.Lookup(".text", 0)
if s.Type == obj.STEXT {
put(ctxt, s, s.Name, TextSym, s.Value, nil)
}
Cseek(int64(c.PointerToRawData))
chksectoff(ctxt, c, coutbuf.Offset())
- init_entry := Linklookup(ctxt, *flagEntrySymbol, 0)
+ init_entry := ctxt.Syms.Lookup(*flagEntrySymbol, 0)
addr := uint64(init_entry.Value) - init_entry.Sect.Vaddr
switch obj.GOARCH {
ctxt.xdefine("runtime.esymtab", obj.SRODATA, 0)
// garbage collection symbols
- s := Linklookup(ctxt, "runtime.gcdata", 0)
+ s := ctxt.Syms.Lookup("runtime.gcdata", 0)
s.Type = obj.SRODATA
s.Size = 0
s.Attr |= AttrReachable
ctxt.xdefine("runtime.egcdata", obj.SRODATA, 0)
- s = Linklookup(ctxt, "runtime.gcbss", 0)
+ s = ctxt.Syms.Lookup("runtime.gcbss", 0)
s.Type = obj.SRODATA
s.Size = 0
s.Attr |= AttrReachable
var symtype *Symbol
var symtyperel *Symbol
if UseRelro() && (Buildmode == BuildmodeCArchive || Buildmode == BuildmodeCShared || Buildmode == BuildmodePIE) {
- s = Linklookup(ctxt, "type.*", 0)
+ s = ctxt.Syms.Lookup("type.*", 0)
s.Type = obj.STYPE
s.Size = 0
s.Attr |= AttrReachable
symtype = s
- s = Linklookup(ctxt, "typerel.*", 0)
+ s = ctxt.Syms.Lookup("typerel.*", 0)
s.Type = obj.STYPERELRO
s.Size = 0
s.Attr |= AttrReachable
symtyperel = s
} else if !ctxt.DynlinkingGo() {
- s = Linklookup(ctxt, "type.*", 0)
+ s = ctxt.Syms.Lookup("type.*", 0)
s.Type = obj.STYPE
s.Size = 0
}
groupSym := func(name string, t obj.SymKind) *Symbol {
- s := Linklookup(ctxt, name, 0)
+ s := ctxt.Syms.Lookup(name, 0)
s.Type = t
s.Size = 0
s.Attr |= AttrLocal | AttrReachable
}
}
- symtypelink := Linklookup(ctxt, "runtime.typelink", 0)
+ symtypelink := ctxt.Syms.Lookup("runtime.typelink", 0)
symtypelink.Type = obj.STYPELINK
- symitablink := Linklookup(ctxt, "runtime.itablink", 0)
+ symitablink := ctxt.Syms.Lookup("runtime.itablink", 0)
symitablink.Type = obj.SITABLINK
- symt = Linklookup(ctxt, "runtime.symtab", 0)
+ symt = ctxt.Syms.Lookup("runtime.symtab", 0)
symt.Attr |= AttrLocal
symt.Type = obj.SSYMTAB
symt.Size = 0
}
if Buildmode == BuildmodeShared {
- abihashgostr := Linklookup(ctxt, "go.link.abihash."+filepath.Base(*flagOutfile), 0)
+ abihashgostr := ctxt.Syms.Lookup("go.link.abihash."+filepath.Base(*flagOutfile), 0)
abihashgostr.Attr |= AttrReachable
abihashgostr.Type = obj.SRODATA
- hashsym := Linklookup(ctxt, "go.link.abihashbytes", 0)
+ hashsym := ctxt.Syms.Lookup("go.link.abihashbytes", 0)
Addaddr(ctxt, abihashgostr, hashsym)
adduint(ctxt, abihashgostr, uint64(hashsym.Size))
}
// This code uses several global variables that are set by pcln.go:pclntab.
moduledata := ctxt.Moduledata
// The pclntab slice
- Addaddr(ctxt, moduledata, Linklookup(ctxt, "runtime.pclntab", 0))
- adduint(ctxt, moduledata, uint64(Linklookup(ctxt, "runtime.pclntab", 0).Size))
- adduint(ctxt, moduledata, uint64(Linklookup(ctxt, "runtime.pclntab", 0).Size))
+ Addaddr(ctxt, moduledata, ctxt.Syms.Lookup("runtime.pclntab", 0))
+ adduint(ctxt, moduledata, uint64(ctxt.Syms.Lookup("runtime.pclntab", 0).Size))
+ adduint(ctxt, moduledata, uint64(ctxt.Syms.Lookup("runtime.pclntab", 0).Size))
// The ftab slice
- Addaddrplus(ctxt, moduledata, Linklookup(ctxt, "runtime.pclntab", 0), int64(pclntabPclntabOffset))
+ Addaddrplus(ctxt, moduledata, ctxt.Syms.Lookup("runtime.pclntab", 0), int64(pclntabPclntabOffset))
adduint(ctxt, moduledata, uint64(pclntabNfunc+1))
adduint(ctxt, moduledata, uint64(pclntabNfunc+1))
// The filetab slice
- Addaddrplus(ctxt, moduledata, Linklookup(ctxt, "runtime.pclntab", 0), int64(pclntabFiletabOffset))
+ Addaddrplus(ctxt, moduledata, ctxt.Syms.Lookup("runtime.pclntab", 0), int64(pclntabFiletabOffset))
adduint(ctxt, moduledata, uint64(len(ctxt.Filesyms))+1)
adduint(ctxt, moduledata, uint64(len(ctxt.Filesyms))+1)
// findfunctab
- Addaddr(ctxt, moduledata, Linklookup(ctxt, "runtime.findfunctab", 0))
+ Addaddr(ctxt, moduledata, ctxt.Syms.Lookup("runtime.findfunctab", 0))
// minpc, maxpc
Addaddr(ctxt, moduledata, pclntabFirstFunc)
Addaddrplus(ctxt, moduledata, pclntabLastFunc, pclntabLastFunc.Size)
// pointers to specific parts of the module
- Addaddr(ctxt, moduledata, Linklookup(ctxt, "runtime.text", 0))
- Addaddr(ctxt, moduledata, Linklookup(ctxt, "runtime.etext", 0))
- Addaddr(ctxt, moduledata, Linklookup(ctxt, "runtime.noptrdata", 0))
- Addaddr(ctxt, moduledata, Linklookup(ctxt, "runtime.enoptrdata", 0))
- Addaddr(ctxt, moduledata, Linklookup(ctxt, "runtime.data", 0))
- Addaddr(ctxt, moduledata, Linklookup(ctxt, "runtime.edata", 0))
- Addaddr(ctxt, moduledata, Linklookup(ctxt, "runtime.bss", 0))
- Addaddr(ctxt, moduledata, Linklookup(ctxt, "runtime.ebss", 0))
- Addaddr(ctxt, moduledata, Linklookup(ctxt, "runtime.noptrbss", 0))
- Addaddr(ctxt, moduledata, Linklookup(ctxt, "runtime.enoptrbss", 0))
- Addaddr(ctxt, moduledata, Linklookup(ctxt, "runtime.end", 0))
- Addaddr(ctxt, moduledata, Linklookup(ctxt, "runtime.gcdata", 0))
- Addaddr(ctxt, moduledata, Linklookup(ctxt, "runtime.gcbss", 0))
- Addaddr(ctxt, moduledata, Linklookup(ctxt, "runtime.types", 0))
- Addaddr(ctxt, moduledata, Linklookup(ctxt, "runtime.etypes", 0))
+ Addaddr(ctxt, moduledata, ctxt.Syms.Lookup("runtime.text", 0))
+ Addaddr(ctxt, moduledata, ctxt.Syms.Lookup("runtime.etext", 0))
+ Addaddr(ctxt, moduledata, ctxt.Syms.Lookup("runtime.noptrdata", 0))
+ Addaddr(ctxt, moduledata, ctxt.Syms.Lookup("runtime.enoptrdata", 0))
+ Addaddr(ctxt, moduledata, ctxt.Syms.Lookup("runtime.data", 0))
+ Addaddr(ctxt, moduledata, ctxt.Syms.Lookup("runtime.edata", 0))
+ Addaddr(ctxt, moduledata, ctxt.Syms.Lookup("runtime.bss", 0))
+ Addaddr(ctxt, moduledata, ctxt.Syms.Lookup("runtime.ebss", 0))
+ Addaddr(ctxt, moduledata, ctxt.Syms.Lookup("runtime.noptrbss", 0))
+ Addaddr(ctxt, moduledata, ctxt.Syms.Lookup("runtime.enoptrbss", 0))
+ Addaddr(ctxt, moduledata, ctxt.Syms.Lookup("runtime.end", 0))
+ Addaddr(ctxt, moduledata, ctxt.Syms.Lookup("runtime.gcdata", 0))
+ Addaddr(ctxt, moduledata, ctxt.Syms.Lookup("runtime.gcbss", 0))
+ Addaddr(ctxt, moduledata, ctxt.Syms.Lookup("runtime.types", 0))
+ Addaddr(ctxt, moduledata, ctxt.Syms.Lookup("runtime.etypes", 0))
// The typelinks slice
- Addaddr(ctxt, moduledata, Linklookup(ctxt, "runtime.typelink", 0))
+ Addaddr(ctxt, moduledata, ctxt.Syms.Lookup("runtime.typelink", 0))
adduint(ctxt, moduledata, uint64(ntypelinks))
adduint(ctxt, moduledata, uint64(ntypelinks))
// The itablinks slice
- Addaddr(ctxt, moduledata, Linklookup(ctxt, "runtime.itablink", 0))
+ Addaddr(ctxt, moduledata, ctxt.Syms.Lookup("runtime.itablink", 0))
adduint(ctxt, moduledata, uint64(nitablinks))
adduint(ctxt, moduledata, uint64(nitablinks))
// The ptab slice
if Buildmode == BuildmodePlugin {
- ptab := Linkrlookup(ctxt, "go.plugin.tabs", 0)
+ ptab := ctxt.Syms.ROLookup("go.plugin.tabs", 0)
ptab.Attr |= AttrReachable
ptab.Attr |= AttrLocal
ptab.Type = obj.SRODATA
}
addgostring(ctxt, moduledata, "go.link.thismodulename", thismodulename)
- modulehashes := Linklookup(ctxt, "go.link.abihashes", 0)
+ modulehashes := ctxt.Syms.Lookup("go.link.abihashes", 0)
modulehashes.Attr |= AttrReachable
modulehashes.Attr |= AttrLocal
modulehashes.Type = obj.SRODATA
addgostring(ctxt, modulehashes, fmt.Sprintf("go.link.linkhash.%d", i), string(shlib.Hash))
// modulehashes[i].runtimehash
- abihash := Linklookup(ctxt, "go.link.abihash."+modulename, 0)
+ abihash := ctxt.Syms.Lookup("go.link.abihash."+modulename, 0)
abihash.Attr |= AttrReachable
Addaddr(ctxt, modulehashes, abihash)
}
// When linking an object that does not contain the runtime we are
// creating the moduledata from scratch and it does not have a
// compiler-provided size, so read it from the type data.
- moduledatatype := Linkrlookup(ctxt, "type.runtime.moduledata", 0)
+ moduledatatype := ctxt.Syms.ROLookup("type.runtime.moduledata", 0)
moduledata.Size = decodetypeSize(ctxt.Arch, moduledatatype)
Symgrow(ctxt, moduledata, moduledata.Size)
- lastmoduledatap := Linklookup(ctxt, "runtime.lastmoduledatap", 0)
+ lastmoduledatap := ctxt.Syms.Lookup("runtime.lastmoduledatap", 0)
if lastmoduledatap.Type != obj.SDYNIMPORT {
lastmoduledatap.Type = obj.SNOPTRDATA
lastmoduledatap.Size = 0 // overwrite existing value
return 0
case obj.R_GOTOFF:
- *val = ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(ld.Linklookup(ctxt, ".got", 0))
+ *val = ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(ctxt.Syms.Lookup(".got", 0))
return 0
case obj.R_ADDRMIPS,
ld.Asmplan9sym(ctxt)
ld.Cflush()
- sym := ld.Linklookup(ctxt, "pclntab", 0)
+ sym := ctxt.Syms.Lookup("pclntab", 0)
if sym != nil {
ld.Lcsize = int32(len(sym.P))
for i := 0; int32(i) < ld.Lcsize; i++ {
// Generate call stub
n := fmt.Sprintf("%s.%s", s.Name, r.Sym.Name)
- stub := ld.Linklookup(ctxt, n, 0)
+ stub := ctxt.Syms.Lookup(n, 0)
if s.Attr.Reachable() {
stub.Attr |= ld.AttrReachable
}
}
func genaddmoduledata(ctxt *ld.Link) {
- addmoduledata := ld.Linkrlookup(ctxt, "runtime.addmoduledata", 0)
+ addmoduledata := ctxt.Syms.ROLookup("runtime.addmoduledata", 0)
if addmoduledata.Type == obj.STEXT {
return
}
addmoduledata.Attr |= ld.AttrReachable
- initfunc := ld.Linklookup(ctxt, "go.link.addmoduledata", 0)
+ initfunc := ctxt.Syms.Lookup("go.link.addmoduledata", 0)
initfunc.Type = obj.STEXT
initfunc.Attr |= ld.AttrLocal
initfunc.Attr |= ld.AttrReachable
rel := ld.Addrel(initfunc)
rel.Off = int32(initfunc.Size)
rel.Siz = 8
- rel.Sym = ld.Linklookup(ctxt, ".TOC.", 0)
+ rel.Sym = ctxt.Syms.Lookup(".TOC.", 0)
rel.Type = obj.R_ADDRPOWER_PCREL
o(0x3c4c0000)
// addi r2, r2, .TOC.-func@l
rel = ld.Addrel(initfunc)
rel.Off = int32(initfunc.Size)
rel.Siz = 8
- rel.Sym = ld.Linklookup(ctxt, "local.moduledata", 0)
+ rel.Sym = ctxt.Syms.Lookup("local.moduledata", 0)
rel.Type = obj.R_ADDRPOWER_GOT
o(0x3c620000)
// ld r3, local.moduledata@got@l(r3)
o(0x4e800020)
ctxt.Textp = append(ctxt.Textp, initfunc)
- initarray_entry := ld.Linklookup(ctxt, "go.link.addmoduledatainit", 0)
+ initarray_entry := ctxt.Syms.Lookup("go.link.addmoduledatainit", 0)
initarray_entry.Attr |= ld.AttrReachable
initarray_entry.Attr |= ld.AttrLocal
initarray_entry.Type = obj.SINITARR
log.Fatalf("gencallstub only implements case 1 calls")
}
- plt := ld.Linklookup(ctxt, ".plt", 0)
+ plt := ctxt.Syms.Lookup(".plt", 0)
stub.Type = obj.STEXT
// These happen in .toc sections
ld.Adddynsym(ctxt, targ)
- rela := ld.Linklookup(ctxt, ".rela", 0)
+ rela := ctxt.Syms.Lookup(".rela", 0)
ld.Addaddrplus(ctxt, rela, s, int64(r.Off))
ld.Adduint64(ctxt, rela, ld.ELF64_R_INFO(uint32(targ.Dynid), ld.R_PPC64_ADDR64))
ld.Adduint64(ctxt, rela, uint64(r.Add))
}
func elfsetupplt(ctxt *ld.Link) {
- plt := ld.Linklookup(ctxt, ".plt", 0)
+ plt := ctxt.Syms.Lookup(".plt", 0)
if plt.Size == 0 {
// The dynamic linker stores the address of the
// dynamic resolver and the DSO identifier in the two
var toc *ld.Symbol
if s.Outer != nil {
- toc = ld.Linkrlookup(ctxt, ".TOC.", int(s.Outer.Version))
+ toc = ctxt.Syms.ROLookup(".TOC.", int(s.Outer.Version))
} else {
- toc = ld.Linkrlookup(ctxt, ".TOC.", int(s.Version))
+ toc = ctxt.Syms.ROLookup(".TOC.", int(s.Version))
}
if toc == nil {
return 0
case obj.R_GOTOFF:
- *val = ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(ld.Linklookup(ctxt, ".got", 0))
+ *val = ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(ctxt.Syms.Lookup(".got", 0))
return 0
case obj.R_ADDRPOWER, obj.R_ADDRPOWER_DS:
ld.Adddynsym(ctxt, s)
if ld.Iself {
- plt := ld.Linklookup(ctxt, ".plt", 0)
- rela := ld.Linklookup(ctxt, ".rela.plt", 0)
+ plt := ctxt.Syms.Lookup(".plt", 0)
+ rela := ctxt.Syms.Lookup(".rela.plt", 0)
if plt.Size == 0 {
elfsetupplt(ctxt)
}
// Generate the glink resolver stub if necessary and return the .glink section
func ensureglinkresolver(ctxt *ld.Link) *ld.Symbol {
- glink := ld.Linklookup(ctxt, ".glink", 0)
+ glink := ctxt.Syms.Lookup(".glink", 0)
if glink.Size != 0 {
return glink
}
r := ld.Addrel(glink)
r.Off = int32(glink.Size)
- r.Sym = ld.Linklookup(ctxt, ".plt", 0)
+ r.Sym = ctxt.Syms.Lookup(".plt", 0)
r.Siz = 8
r.Type = obj.R_ADDRPOWER
// Add DT_PPC64_GLINK .dynamic entry, which points to 32 bytes
// before the first symbol resolver stub.
- s := ld.Linklookup(ctxt, ".dynamic", 0)
+ s := ctxt.Syms.Lookup(".dynamic", 0)
ld.Elfwritedynentsymplus(ctxt, s, ld.DT_PPC64_GLINK, glink, glink.Size-32)
ld.Asmplan9sym(ctxt)
ld.Cflush()
- sym := ld.Linklookup(ctxt, "pclntab", 0)
+ sym := ctxt.Syms.Lookup("pclntab", 0)
if sym != nil {
ld.Lcsize = int32(len(sym.P))
for i := 0; int32(i) < ld.Lcsize; i++ {
if !ctxt.DynlinkingGo() {
return
}
- addmoduledata := ld.Linklookup(ctxt, "runtime.addmoduledata", 0)
+ addmoduledata := ctxt.Syms.Lookup("runtime.addmoduledata", 0)
if addmoduledata.Type == obj.STEXT {
// we're linking a module containing the runtime -> no need for
// an init function
return
}
addmoduledata.Attr |= ld.AttrReachable
- initfunc := ld.Linklookup(ctxt, "go.link.addmoduledata", 0)
+ initfunc := ctxt.Syms.Lookup("go.link.addmoduledata", 0)
initfunc.Type = obj.STEXT
initfunc.Attr |= ld.AttrLocal
initfunc.Attr |= ld.AttrReachable
rel := ld.Addrel(initfunc)
rel.Off = int32(initfunc.Size)
rel.Siz = 4
- rel.Sym = ld.Linklookup(ctxt, "runtime.addmoduledata", 0)
+ rel.Sym = ctxt.Syms.Lookup("runtime.addmoduledata", 0)
rel.Type = obj.R_CALL
rel.Variant = ld.RV_390_DBL
rel.Add = 2 + int64(rel.Siz)
ld.Adduint32(ctxt, initfunc, 0)
ctxt.Textp = append(ctxt.Textp, initfunc)
- initarray_entry := ld.Linklookup(ctxt, "go.link.addmoduledatainit", 0)
+ initarray_entry := ctxt.Syms.Lookup("go.link.addmoduledatainit", 0)
initarray_entry.Attr |= ld.AttrLocal
initarray_entry.Attr |= ld.AttrReachable
initarray_entry.Type = obj.SINITARR
r.Add += int64(r.Siz)
if targ.Type == obj.SDYNIMPORT {
addpltsym(ctxt, targ)
- r.Sym = ld.Linklookup(ctxt, ".plt", 0)
+ r.Sym = ctxt.Syms.Lookup(".plt", 0)
r.Add += int64(targ.Plt)
}
return true
r.Add += int64(r.Siz)
if targ.Type == obj.SDYNIMPORT {
addpltsym(ctxt, targ)
- r.Sym = ld.Linklookup(ctxt, ".plt", 0)
+ r.Sym = ctxt.Syms.Lookup(".plt", 0)
r.Add += int64(targ.Plt)
}
return true
case 256 + ld.R_390_GOTPC:
r.Type = obj.R_PCREL
- r.Sym = ld.Linklookup(ctxt, ".got", 0)
+ r.Sym = ctxt.Syms.Lookup(".got", 0)
r.Add += int64(r.Siz)
return true
case 256 + ld.R_390_GOTPCDBL:
r.Type = obj.R_PCREL
r.Variant = ld.RV_390_DBL
- r.Sym = ld.Linklookup(ctxt, ".got", 0)
+ r.Sym = ctxt.Syms.Lookup(".got", 0)
r.Add += int64(r.Siz)
return true
r.Type = obj.R_PCREL
r.Variant = ld.RV_390_DBL
- r.Sym = ld.Linklookup(ctxt, ".got", 0)
+ r.Sym = ctxt.Syms.Lookup(".got", 0)
r.Add += int64(targ.Got)
r.Add += int64(r.Siz)
return true
}
func elfsetupplt(ctxt *ld.Link) {
- plt := ld.Linklookup(ctxt, ".plt", 0)
- got := ld.Linklookup(ctxt, ".got", 0)
+ plt := ctxt.Syms.Lookup(".plt", 0)
+ got := ctxt.Syms.Lookup(".got", 0)
if plt.Size == 0 {
// stg %r1,56(%r15)
ld.Adduint8(ctxt, plt, 0xe3)
ld.Adduint8(ctxt, plt, 0x00)
// assume got->size == 0 too
- ld.Addaddrplus(ctxt, got, ld.Linklookup(ctxt, ".dynamic", 0), 0)
+ ld.Addaddrplus(ctxt, got, ctxt.Syms.Lookup(".dynamic", 0), 0)
ld.Adduint64(ctxt, got, 0)
ld.Adduint64(ctxt, got, 0)
return 0
case obj.R_GOTOFF:
- *val = ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(ld.Linklookup(ctxt, ".got", 0))
+ *val = ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(ctxt.Syms.Lookup(".got", 0))
return 0
}
ld.Adddynsym(ctxt, s)
if ld.Iself {
- plt := ld.Linklookup(ctxt, ".plt", 0)
- got := ld.Linklookup(ctxt, ".got", 0)
- rela := ld.Linklookup(ctxt, ".rela.plt", 0)
+ plt := ctxt.Syms.Lookup(".plt", 0)
+ got := ctxt.Syms.Lookup(".got", 0)
+ rela := ctxt.Syms.Lookup(".rela.plt", 0)
if plt.Size == 0 {
elfsetupplt(ctxt)
}
}
ld.Adddynsym(ctxt, s)
- got := ld.Linklookup(ctxt, ".got", 0)
+ got := ctxt.Syms.Lookup(".got", 0)
s.Got = int32(got.Size)
ld.Adduint64(ctxt, got, 0)
if ld.Iself {
- rela := ld.Linklookup(ctxt, ".rela", 0)
+ rela := ctxt.Syms.Lookup(".rela", 0)
ld.Addaddrplus(ctxt, rela, got, int64(s.Got))
ld.Adduint64(ctxt, rela, ld.ELF64_R_INFO(uint32(s.Dynid), ld.R_390_GLOB_DAT))
ld.Adduint64(ctxt, rela, 0)
{"si", 6},
{"di", 7},
} {
- thunkfunc := ld.Linklookup(ctxt, "__x86.get_pc_thunk."+r.name, 0)
+ thunkfunc := ctxt.Syms.Lookup("__x86.get_pc_thunk."+r.name, 0)
thunkfunc.Type = obj.STEXT
thunkfunc.Attr |= ld.AttrLocal
thunkfunc.Attr |= ld.AttrReachable //TODO: remove?
ctxt.Textp = append(ctxt.Textp, thunkfunc)
}
- addmoduledata := ld.Linklookup(ctxt, "runtime.addmoduledata", 0)
+ addmoduledata := ctxt.Syms.Lookup("runtime.addmoduledata", 0)
if addmoduledata.Type == obj.STEXT && ld.Buildmode != ld.BuildmodePlugin {
// we're linking a module containing the runtime -> no need for
// an init function
addmoduledata.Attr |= ld.AttrReachable
- initfunc := ld.Linklookup(ctxt, "go.link.addmoduledata", 0)
+ initfunc := ctxt.Syms.Lookup("go.link.addmoduledata", 0)
initfunc.Type = obj.STEXT
initfunc.Attr |= ld.AttrLocal
initfunc.Attr |= ld.AttrReachable
o(0x53)
o(0xe8)
- addcall(ctxt, initfunc, ld.Linklookup(ctxt, "__x86.get_pc_thunk.cx", 0))
+ addcall(ctxt, initfunc, ctxt.Syms.Lookup("__x86.get_pc_thunk.cx", 0))
o(0x8d, 0x81)
ld.Addpcrelplus(ctxt, initfunc, ctxt.Moduledata, 6)
initfunc.Size += 4
ld.Symgrow(ctxt, initfunc, initfunc.Size)
r := ld.Addrel(initfunc)
- r.Sym = ld.Linklookup(ctxt, "_GLOBAL_OFFSET_TABLE_", 0)
+ r.Sym = ctxt.Syms.Lookup("_GLOBAL_OFFSET_TABLE_", 0)
r.Off = int32(i)
r.Type = obj.R_PCREL
r.Add = 12
if ld.Buildmode == ld.BuildmodePlugin {
ctxt.Textp = append(ctxt.Textp, addmoduledata)
}
- initarray_entry := ld.Linklookup(ctxt, "go.link.addmoduledatainit", 0)
+ initarray_entry := ctxt.Syms.Lookup("go.link.addmoduledatainit", 0)
initarray_entry.Attr |= ld.AttrReachable
initarray_entry.Attr |= ld.AttrLocal
initarray_entry.Type = obj.SINITARR
r.Add += 4
if targ.Type == obj.SDYNIMPORT {
addpltsym(ctxt, targ)
- r.Sym = ld.Linklookup(ctxt, ".plt", 0)
+ r.Sym = ctxt.Syms.Lookup(".plt", 0)
r.Add += int64(targ.Plt)
}
case 256 + ld.R_386_GOTPC:
r.Type = obj.R_PCREL
- r.Sym = ld.Linklookup(ctxt, ".got", 0)
+ r.Sym = ctxt.Syms.Lookup(".got", 0)
r.Add += 4
return true
case 512 + ld.MACHO_GENERIC_RELOC_VANILLA*2 + 1:
if targ.Type == obj.SDYNIMPORT {
addpltsym(ctxt, targ)
- r.Sym = ld.Linklookup(ctxt, ".plt", 0)
+ r.Sym = ctxt.Syms.Lookup(".plt", 0)
r.Add = int64(targ.Plt)
r.Type = obj.R_PCREL
return true
}
addgotsym(ctxt, targ)
- r.Sym = ld.Linklookup(ctxt, ".got", 0)
+ r.Sym = ctxt.Syms.Lookup(".got", 0)
r.Add += int64(targ.Got)
r.Type = obj.R_PCREL
return true
case obj.R_CALL,
obj.R_PCREL:
addpltsym(ctxt, targ)
- r.Sym = ld.Linklookup(ctxt, ".plt", 0)
+ r.Sym = ctxt.Syms.Lookup(".plt", 0)
r.Add = int64(targ.Plt)
return true
}
if ld.Iself {
ld.Adddynsym(ctxt, targ)
- rel := ld.Linklookup(ctxt, ".rel", 0)
+ rel := ctxt.Syms.Lookup(".rel", 0)
ld.Addaddrplus(ctxt, rel, s, int64(r.Off))
ld.Adduint32(ctxt, rel, ld.ELF32_R_INFO(uint32(targ.Dynid), ld.R_386_32))
r.Type = obj.R_CONST // write r->add during relocsym
// but we only need to support cgo and that's all it needs.
ld.Adddynsym(ctxt, targ)
- got := ld.Linklookup(ctxt, ".got", 0)
+ got := ctxt.Syms.Lookup(".got", 0)
s.Type = got.Type | obj.SSUB
s.Outer = got
s.Sub = got.Sub
got.Sub = s
s.Value = got.Size
ld.Adduint32(ctxt, got, 0)
- ld.Adduint32(ctxt, ld.Linklookup(ctxt, ".linkedit.got", 0), uint32(targ.Dynid))
+ ld.Adduint32(ctxt, ctxt.Syms.Lookup(".linkedit.got", 0), uint32(targ.Dynid))
r.Type = 256 // ignore during relocsym
return true
}
return 0
case obj.R_GOTOFF:
- *val = ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(ld.Linklookup(ctxt, ".got", 0))
+ *val = ld.Symaddr(r.Sym) + r.Add - ld.Symaddr(ctxt.Syms.Lookup(".got", 0))
return 0
}
}
func elfsetupplt(ctxt *ld.Link) {
- plt := ld.Linklookup(ctxt, ".plt", 0)
- got := ld.Linklookup(ctxt, ".got.plt", 0)
+ plt := ctxt.Syms.Lookup(".plt", 0)
+ got := ctxt.Syms.Lookup(".got.plt", 0)
if plt.Size == 0 {
// pushl got+4
ld.Adduint8(ctxt, plt, 0xff)
ld.Adduint32(ctxt, plt, 0)
// assume got->size == 0 too
- ld.Addaddrplus(ctxt, got, ld.Linklookup(ctxt, ".dynamic", 0), 0)
+ ld.Addaddrplus(ctxt, got, ctxt.Syms.Lookup(".dynamic", 0), 0)
ld.Adduint32(ctxt, got, 0)
ld.Adduint32(ctxt, got, 0)
ld.Adddynsym(ctxt, s)
if ld.Iself {
- plt := ld.Linklookup(ctxt, ".plt", 0)
- got := ld.Linklookup(ctxt, ".got.plt", 0)
- rel := ld.Linklookup(ctxt, ".rel.plt", 0)
+ plt := ctxt.Syms.Lookup(".plt", 0)
+ got := ctxt.Syms.Lookup(".got.plt", 0)
+ rel := ctxt.Syms.Lookup(".rel.plt", 0)
if plt.Size == 0 {
elfsetupplt(ctxt)
}
} else if ld.Headtype == obj.Hdarwin {
// Same laziness as in 6l.
- plt := ld.Linklookup(ctxt, ".plt", 0)
+ plt := ctxt.Syms.Lookup(".plt", 0)
addgotsym(ctxt, s)
- ld.Adduint32(ctxt, ld.Linklookup(ctxt, ".linkedit.plt", 0), uint32(s.Dynid))
+ ld.Adduint32(ctxt, ctxt.Syms.Lookup(".linkedit.plt", 0), uint32(s.Dynid))
// jmpq *got+size(IP)
s.Plt = int32(plt.Size)
ld.Adduint8(ctxt, plt, 0xff)
ld.Adduint8(ctxt, plt, 0x25)
- ld.Addaddrplus(ctxt, plt, ld.Linklookup(ctxt, ".got", 0), int64(s.Got))
+ ld.Addaddrplus(ctxt, plt, ctxt.Syms.Lookup(".got", 0), int64(s.Got))
} else {
ld.Errorf(s, "addpltsym: unsupported binary format")
}
}
ld.Adddynsym(ctxt, s)
- got := ld.Linklookup(ctxt, ".got", 0)
+ got := ctxt.Syms.Lookup(".got", 0)
s.Got = int32(got.Size)
ld.Adduint32(ctxt, got, 0)
if ld.Iself {
- rel := ld.Linklookup(ctxt, ".rel", 0)
+ rel := ctxt.Syms.Lookup(".rel", 0)
ld.Addaddrplus(ctxt, rel, got, int64(s.Got))
ld.Adduint32(ctxt, rel, ld.ELF32_R_INFO(uint32(s.Dynid), ld.R_386_GLOB_DAT))
} else if ld.Headtype == obj.Hdarwin {
- ld.Adduint32(ctxt, ld.Linklookup(ctxt, ".linkedit.got", 0), uint32(s.Dynid))
+ ld.Adduint32(ctxt, ctxt.Syms.Lookup(".linkedit.got", 0), uint32(s.Dynid))
} else {
ld.Errorf(s, "addgotsym: unsupported binary format")
}
ld.Asmplan9sym(ctxt)
ld.Cflush()
- sym := ld.Linklookup(ctxt, "pclntab", 0)
+ sym := ctxt.Syms.Lookup("pclntab", 0)
if sym != nil {
ld.Lcsize = int32(len(sym.P))
for i := 0; int32(i) < ld.Lcsize; i++ {