func pereloc1(ctxt *ld.Link, r *ld.Reloc, sectoff int64) bool { var v uint32 rs := r.Xsym if rs.Dynid < 0 { ctxt.Diag("reloc %d to non-coff symbol %s type=%d", r.Type, rs.Name, rs.Type) return false } ld.Thearch.Lput(uint32(sectoff)) ld.Thearch.Lput(uint32(rs.Dynid)) switch r.Type { default: return false case obj.R_ADDR: v = ld.IMAGE_REL_I386_DIR32 case obj.R_CALL, obj.R_PCREL: v = ld.IMAGE_REL_I386_REL32 } ld.Thearch.Wput(uint16(v)) return true }
func machoreloc1(ctxt *ld.Link, r *ld.Reloc, sectoff int64) int { var v uint32 rs := r.Xsym if rs.Type == obj.SHOSTOBJ || r.Type == obj.R_PCREL { if rs.Dynid < 0 { ctxt.Diag("reloc %d to non-macho symbol %s type=%d", r.Type, rs.Name, rs.Type) return -1 } v = uint32(rs.Dynid) v |= 1 << 27 // external relocation } else { v = uint32(rs.Sect.Extnum) if v == 0 { ctxt.Diag("reloc %d to symbol %s in non-macho section %s type=%d", r.Type, rs.Name, rs.Sect.Name, rs.Type) return -1 } } switch r.Type { default: return -1 case obj.R_ADDR: v |= ld.MACHO_X86_64_RELOC_UNSIGNED << 28 case obj.R_CALL: v |= 1 << 24 // pc-relative bit v |= ld.MACHO_X86_64_RELOC_BRANCH << 28 // NOTE: Only works with 'external' relocation. Forced above. case obj.R_PCREL: v |= 1 << 24 // pc-relative bit v |= ld.MACHO_X86_64_RELOC_SIGNED << 28 } switch r.Siz { default: return -1 case 1: v |= 0 << 25 case 2: v |= 1 << 25 case 4: v |= 2 << 25 case 8: v |= 3 << 25 } ld.Thearch.Lput(uint32(sectoff)) ld.Thearch.Lput(v) return 0 }
func addpltsym(ctxt *ld.Link, s *ld.Symbol) { if s.Plt >= 0 { return } 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) if plt.Size == 0 { elfsetupplt(ctxt) } // jmpq *got+size ld.Adduint8(ctxt, plt, 0xff) ld.Adduint8(ctxt, plt, 0x25) ld.Addaddrplus(ctxt, plt, got, got.Size) // add to got: pointer to current pos in plt ld.Addaddrplus(ctxt, got, plt, plt.Size) // pushl $x ld.Adduint8(ctxt, plt, 0x68) ld.Adduint32(ctxt, plt, uint32(rel.Size)) // jmp .plt ld.Adduint8(ctxt, plt, 0xe9) ld.Adduint32(ctxt, plt, uint32(-(plt.Size + 4))) // rel ld.Addaddrplus(ctxt, rel, got, got.Size-4) ld.Adduint32(ctxt, rel, ld.ELF32_R_INFO(uint32(s.Dynid), ld.R_386_JMP_SLOT)) s.Plt = int32(plt.Size - 16) } else if ld.HEADTYPE == obj.Hdarwin { // Same laziness as in 6l. plt := ld.Linklookup(ctxt, ".plt", 0) addgotsym(ctxt, s) ld.Adduint32(ctxt, ld.Linklookup(ctxt, ".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)) } else { ctxt.Diag("addpltsym: unsupported binary format") } }
func gentext(ctxt *ld.Link) { if ctxt.DynlinkingGo() { genaddmoduledata(ctxt) } if ld.Linkmode == ld.LinkInternal { genplt(ctxt) } }
// Convert the direct jump relocation r to refer to a trampoline if the target is too far func trampoline(ctxt *ld.Link, r *ld.Reloc, s *ld.Symbol) { switch r.Type { case obj.R_CALLARM: // r.Add is the instruction // low 24-bit encodes the target address t := (ld.Symaddr(r.Sym) + int64(signext24(r.Add&0xffffff)*4) - (s.Value + int64(r.Off))) / 4 if t > 0x7fffff || t < -0x800000 || (*ld.FlagDebugTramp > 1 && s.File != r.Sym.File) { // direct call too far, need to insert trampoline. // look up existing trampolines first. if we found one within the range // of direct call, we can reuse it. otherwise create a new one. offset := (signext24(r.Add&0xffffff) + 2) * 4 var tramp *ld.Symbol for i := 0; ; i++ { name := r.Sym.Name + fmt.Sprintf("%+d-tramp%d", offset, i) tramp = ctxt.Syms.Lookup(name, int(r.Sym.Version)) if tramp.Type == obj.SDYNIMPORT { // don't reuse trampoline defined in other module continue } if tramp.Value == 0 { // either the trampoline does not exist -- we need to create one, // or found one the address which is not assigned -- this will be // laid down immediately after the current function. use this one. break } t = (ld.Symaddr(tramp) - 8 - (s.Value + int64(r.Off))) / 4 if t >= -0x800000 && t < 0x7fffff { // found an existing trampoline that is not too far // we can just use it break } } if tramp.Type == 0 { // trampoline does not exist, create one ctxt.AddTramp(tramp) if ctxt.DynlinkingGo() { if immrot(uint32(offset)) == 0 { ld.Errorf(s, "odd offset in dynlink direct call: %v+%d", r.Sym, offset) } gentrampdyn(tramp, r.Sym, int64(offset)) } else if ld.Buildmode == ld.BuildmodeCArchive || ld.Buildmode == ld.BuildmodeCShared || ld.Buildmode == ld.BuildmodePIE { gentramppic(tramp, r.Sym, int64(offset)) } else { gentramp(tramp, r.Sym, int64(offset)) } } // modify reloc to point to tramp, which will be resolved later r.Sym = tramp r.Add = r.Add&0xff000000 | 0xfffffe // clear the offset embedded in the instruction r.Done = 0 } default: ld.Errorf(s, "trampoline called with non-jump reloc: %v", r.Type) } }
func machoreloc1(ctxt *ld.Link, r *ld.Reloc, sectoff int64) int { var v uint32 rs := r.Xsym if rs.Type == obj.SHOSTOBJ { if rs.Dynid < 0 { ctxt.Diag("reloc %d to non-macho symbol %s type=%d", r.Type, rs.Name, rs.Type) return -1 } v = uint32(rs.Dynid) v |= 1 << 27 // external relocation } else { v = uint32(rs.Sect.Extnum) if v == 0 { ctxt.Diag("reloc %d to symbol %s in non-macho section %s type=%d", r.Type, rs.Name, rs.Sect.Name, rs.Type) return -1 } } switch r.Type { default: return -1 case obj.R_ADDR: v |= ld.MACHO_GENERIC_RELOC_VANILLA << 28 case obj.R_CALL, obj.R_PCREL: v |= 1 << 24 // pc-relative bit v |= ld.MACHO_GENERIC_RELOC_VANILLA << 28 } switch r.Siz { default: return -1 case 1: v |= 0 << 25 case 2: v |= 1 << 25 case 4: v |= 2 << 25 case 8: v |= 3 << 25 } ld.Thearch.Lput(uint32(sectoff)) ld.Thearch.Lput(v) return 0 }
// gentext generates assembly to append the local moduledata to the global // moduledata linked list at initialization time. This is only done if the runtime // is in a different module. // // <go.link.addmoduledata>: // larl %r2, <local.moduledata> // jg <runtime.addmoduledata@plt> // undef // // The job of appending the moduledata is delegated to runtime.addmoduledata. func gentext(ctxt *ld.Link) { if !ctxt.DynlinkingGo() { return } 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 := ctxt.Syms.Lookup("go.link.addmoduledata", 0) initfunc.Type = obj.STEXT initfunc.Attr |= ld.AttrLocal initfunc.Attr |= ld.AttrReachable // larl %r2, <local.moduledata> ld.Adduint8(ctxt, initfunc, 0xc0) ld.Adduint8(ctxt, initfunc, 0x20) lmd := ld.Addrel(initfunc) lmd.Off = int32(initfunc.Size) lmd.Siz = 4 lmd.Sym = ctxt.Moduledata lmd.Type = obj.R_PCREL lmd.Variant = ld.RV_390_DBL lmd.Add = 2 + int64(lmd.Siz) ld.Adduint32(ctxt, initfunc, 0) // jg <runtime.addmoduledata[@plt]> ld.Adduint8(ctxt, initfunc, 0xc0) ld.Adduint8(ctxt, initfunc, 0xf4) rel := ld.Addrel(initfunc) rel.Off = int32(initfunc.Size) rel.Siz = 4 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) // undef (for debugging) ld.Adduint32(ctxt, initfunc, 0) ctxt.Textp = append(ctxt.Textp, initfunc) initarray_entry := ctxt.Syms.Lookup("go.link.addmoduledatainit", 0) initarray_entry.Attr |= ld.AttrLocal initarray_entry.Attr |= ld.AttrReachable initarray_entry.Type = obj.SINITARR ld.Addaddr(ctxt, initarray_entry, initfunc) }
// Convert the direct jump relocation r to refer to a trampoline if the target is too far func trampoline(ctxt *ld.Link, r *ld.Reloc, s *ld.Symbol) { switch r.Type { case obj.R_CALLARM: // r.Add is the instruction // low 24-bit encodes the target address t := (ld.Symaddr(r.Sym) + int64(signext24(r.Add&0xffffff)*4) - (s.Value + int64(r.Off))) / 4 if t > 0x7fffff || t < -0x800000 || (*ld.FlagDebugTramp > 1 && s.File != r.Sym.File) { // direct call too far, need to insert trampoline offset := (signext24(r.Add&0xffffff) + 2) * 4 var tramp *ld.Symbol for i := 0; ; i++ { name := r.Sym.Name + fmt.Sprintf("%+d-tramp%d", offset, i) tramp = ctxt.Syms.Lookup(name, int(r.Sym.Version)) if tramp.Value == 0 { // either the trampoline does not exist -- we need to create one, // or found one the address which is not assigned -- this will be // laid down immediately after the current function. use this one. break } t = (ld.Symaddr(tramp) - 8 - (s.Value + int64(r.Off))) / 4 if t >= -0x800000 && t < 0x7fffff { // found an existing trampoline that is not too far // we can just use it break } } if tramp.Type == 0 { // trampoline does not exist, create one ctxt.AddTramp(tramp) tramp.Size = 12 // 3 instructions tramp.P = make([]byte, tramp.Size) t = ld.Symaddr(r.Sym) + int64(offset) o1 := uint32(0xe5900000 | 11<<12 | 15<<16) // MOVW (R15), R11 // R15 is actual pc + 8 o2 := uint32(0xe12fff10 | 11) // JMP (R11) o3 := uint32(t) // WORD $target ld.SysArch.ByteOrder.PutUint32(tramp.P, o1) ld.SysArch.ByteOrder.PutUint32(tramp.P[4:], o2) ld.SysArch.ByteOrder.PutUint32(tramp.P[8:], o3) } // modify reloc to point to tramp, which will be resolved later r.Sym = tramp r.Add = r.Add&0xff000000 | 0xfffffe // clear the offset embedded in the instruction r.Done = 0 } default: ld.Errorf(s, "trampoline called with non-jump reloc: %v", r.Type) } }
func addgotsyminternal(ctxt *ld.Link, s *ld.Symbol) { if s.Got >= 0 { return } got := ld.Linklookup(ctxt, ".got", 0) s.Got = int32(got.Size) ld.Addaddrplus(ctxt, got, s, 0) if ld.Iself { } else { ctxt.Diag("addgotsyminternal: unsupported binary format") } }
func archrelocaddr(ctxt *ld.Link, r *ld.Reloc, s *ld.Symbol, val *int64) int { var o1, o2 uint32 if ctxt.Arch.ByteOrder == binary.BigEndian { o1 = uint32(*val >> 32) o2 = uint32(*val) } else { o1 = uint32(*val) o2 = uint32(*val >> 32) } // We are spreading a 31-bit address across two instructions, putting the // high (adjusted) part in the low 16 bits of the first instruction and the // low part in the low 16 bits of the second instruction, or, in the DS case, // bits 15-2 (inclusive) of the address into bits 15-2 of the second // instruction (it is an error in this case if the low 2 bits of the address // are non-zero). t := ld.Symaddr(ctxt, r.Sym) + r.Add if t < 0 || t >= 1<<31 { ctxt.Diag("relocation for %s is too big (>=2G): %d", s.Name, ld.Symaddr(ctxt, r.Sym)) } if t&0x8000 != 0 { t += 0x10000 } switch r.Type { case obj.R_ADDRPOWER: o1 |= (uint32(t) >> 16) & 0xffff o2 |= uint32(t) & 0xffff case obj.R_ADDRPOWER_DS: o1 |= (uint32(t) >> 16) & 0xffff if t&3 != 0 { ctxt.Diag("bad DS reloc for %s: %d", s.Name, ld.Symaddr(ctxt, r.Sym)) } o2 |= uint32(t) & 0xfffc default: return -1 } if ctxt.Arch.ByteOrder == binary.BigEndian { *val = int64(o1)<<32 | int64(o2) } else { *val = int64(o2)<<32 | int64(o1) } return 0 }
func genaddmoduledata(ctxt *ld.Link) { addmoduledata := ctxt.Syms.ROLookup("runtime.addmoduledata", 0) if addmoduledata.Type == obj.STEXT { return } addmoduledata.Attr |= ld.AttrReachable initfunc := ctxt.Syms.Lookup("go.link.addmoduledata", 0) initfunc.Type = obj.STEXT initfunc.Attr |= ld.AttrLocal initfunc.Attr |= ld.AttrReachable o := func(op uint32) { ld.Adduint32(ctxt, initfunc, op) } // addis r2, r12, .TOC.-func@ha rel := ld.Addrel(initfunc) rel.Off = int32(initfunc.Size) rel.Siz = 8 rel.Sym = ctxt.Syms.Lookup(".TOC.", 0) rel.Type = obj.R_ADDRPOWER_PCREL o(0x3c4c0000) // addi r2, r2, .TOC.-func@l o(0x38420000) // mflr r31 o(0x7c0802a6) // stdu r31, -32(r1) o(0xf801ffe1) // addis r3, r2, local.moduledata@got@ha rel = ld.Addrel(initfunc) rel.Off = int32(initfunc.Size) rel.Siz = 8 rel.Sym = ctxt.Syms.Lookup("local.moduledata", 0) rel.Type = obj.R_ADDRPOWER_GOT o(0x3c620000) // ld r3, local.moduledata@got@l(r3) o(0xe8630000) // bl runtime.addmoduledata rel = ld.Addrel(initfunc) rel.Off = int32(initfunc.Size) rel.Siz = 4 rel.Sym = addmoduledata rel.Type = obj.R_CALLPOWER o(0x48000001) // nop o(0x60000000) // ld r31, 0(r1) o(0xe8010000) // mtlr r31 o(0x7c0803a6) // addi r1,r1,32 o(0x38210020) // blr o(0x4e800020) ctxt.Textp = append(ctxt.Textp, initfunc) initarray_entry := ctxt.Syms.Lookup("go.link.addmoduledatainit", 0) initarray_entry.Attr |= ld.AttrReachable initarray_entry.Attr |= ld.AttrLocal initarray_entry.Type = obj.SINITARR ld.Addaddr(ctxt, initarray_entry, initfunc) }
// Return the value of .TOC. for symbol s func symtoc(ctxt *ld.Link, s *ld.Symbol) int64 { var toc *ld.Symbol if s.Outer != nil { toc = ld.Linkrlookup(ctxt, ".TOC.", int(s.Outer.Version)) } else { toc = ld.Linkrlookup(ctxt, ".TOC.", int(s.Version)) } if toc == nil { ctxt.Diag("TOC-relative relocation in object without .TOC.") return 0 } return toc.Value }
func archrelocvariant(ctxt *ld.Link, r *ld.Reloc, s *ld.Symbol, t int64) int64 { switch r.Variant & ld.RV_TYPE_MASK { default: ctxt.Diag("unexpected relocation variant %d", r.Variant) return t case ld.RV_NONE: return t case ld.RV_390_DBL: if (t & 1) != 0 { ctxt.Diag("%s+%v is not 2-byte aligned", r.Sym.Name, r.Sym.Value) } return t >> 1 } }
func gentext(ctxt *ld.Link) { if !ctxt.DynlinkingGo() { return } 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 := ctxt.Syms.Lookup("go.link.addmoduledata", 0) initfunc.Type = obj.STEXT initfunc.Attr |= ld.AttrLocal initfunc.Attr |= ld.AttrReachable o := func(op uint32) { ld.Adduint32(ctxt, initfunc, op) } o(0xe59f0004) o(0xe08f0000) o(0xeafffffe) rel := ld.Addrel(initfunc) rel.Off = 8 rel.Siz = 4 rel.Sym = ctxt.Syms.Lookup("runtime.addmoduledata", 0) rel.Type = obj.R_CALLARM rel.Add = 0xeafffffe // vomit o(0x00000000) rel = ld.Addrel(initfunc) rel.Off = 12 rel.Siz = 4 rel.Sym = ctxt.Moduledata rel.Type = obj.R_PCREL rel.Add = 4 if ld.Buildmode == ld.BuildmodePlugin { ctxt.Textp = append(ctxt.Textp, addmoduledata) } ctxt.Textp = append(ctxt.Textp, initfunc) initarray_entry := ctxt.Syms.Lookup("go.link.addmoduledatainit", 0) initarray_entry.Attr |= ld.AttrReachable initarray_entry.Attr |= ld.AttrLocal initarray_entry.Type = obj.SINITARR ld.Addaddr(ctxt, initarray_entry, initfunc) }
func gentext(ctxt *ld.Link) { if !ctxt.DynlinkingGo() { return } 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 := ctxt.Syms.Lookup("go.link.addmoduledata", 0) initfunc.Type = obj.STEXT initfunc.Attr |= ld.AttrLocal initfunc.Attr |= ld.AttrReachable o := func(op uint32) { ld.Adduint32(ctxt, initfunc, op) } // 0000000000000000 <local.dso_init>: // 0: 90000000 adrp x0, 0 <runtime.firstmoduledata> // 0: R_AARCH64_ADR_PREL_PG_HI21 local.moduledata // 4: 91000000 add x0, x0, #0x0 // 4: R_AARCH64_ADD_ABS_LO12_NC local.moduledata o(0x90000000) o(0x91000000) rel := ld.Addrel(initfunc) rel.Off = 0 rel.Siz = 8 rel.Sym = ctxt.Moduledata rel.Type = obj.R_ADDRARM64 // 8: 14000000 bl 0 <runtime.addmoduledata> // 8: R_AARCH64_CALL26 runtime.addmoduledata o(0x14000000) rel = ld.Addrel(initfunc) rel.Off = 8 rel.Siz = 4 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 := ctxt.Syms.Lookup("go.link.addmoduledatainit", 0) initarray_entry.Attr |= ld.AttrReachable initarray_entry.Attr |= ld.AttrLocal initarray_entry.Type = obj.SINITARR ld.Addaddr(ctxt, initarray_entry, initfunc) }
func addgotsym(ctxt *ld.Link, s *ld.Symbol) { if s.Got >= 0 { return } ld.Adddynsym(ctxt, s) got := ld.Linklookup(ctxt, ".got", 0) s.Got = int32(got.Size) ld.Adduint32(ctxt, got, 0) if ld.Iself { rel := ld.Linklookup(ctxt, ".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 { ctxt.Diag("addgotsym: unsupported binary format") } }
func addpltsym(ctxt *ld.Link, s *ld.Symbol) { if s.Plt >= 0 { return } ld.Adddynsym(ctxt, s) if ld.Iself { plt := ld.Linklookup(ctxt, ".plt", 0) rela := ld.Linklookup(ctxt, ".rela.plt", 0) if plt.Size == 0 { elfsetupplt(ctxt) } // Create the glink resolver if necessary glink := ensureglinkresolver(ctxt) // Write symbol resolver stub (just a branch to the // glink resolver stub) r := ld.Addrel(glink) r.Sym = glink r.Off = int32(glink.Size) r.Siz = 4 r.Type = obj.R_CALLPOWER ld.Adduint32(ctxt, glink, 0x48000000) // b .glink // In the ppc64 ABI, the dynamic linker is responsible // for writing the entire PLT. We just need to // reserve 8 bytes for each PLT entry and generate a // JMP_SLOT dynamic relocation for it. // // TODO(austin): ABI v1 is different s.Plt = int32(plt.Size) plt.Size += 8 ld.Addaddrplus(ctxt, rela, plt, int64(s.Plt)) ld.Adduint64(ctxt, rela, ld.ELF64_R_INFO(uint32(s.Dynid), ld.R_PPC64_JMP_SLOT)) ld.Adduint64(ctxt, rela, 0) } else { ctxt.Diag("addpltsym: unsupported binary format") } }
func gentext(ctxt *ld.Link) { if !ctxt.DynlinkingGo() { return } 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 := ctxt.Syms.Lookup("go.link.addmoduledata", 0) initfunc.Type = obj.STEXT initfunc.Attr |= ld.AttrLocal initfunc.Attr |= ld.AttrReachable o := func(op ...uint8) { for _, op1 := range op { ld.Adduint8(ctxt, initfunc, op1) } } // 0000000000000000 <local.dso_init>: // 0: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 7 <local.dso_init+0x7> // 3: R_X86_64_PC32 runtime.firstmoduledata-0x4 o(0x48, 0x8d, 0x3d) ld.Addpcrelplus(ctxt, initfunc, ctxt.Moduledata, 0) // 7: e8 00 00 00 00 callq c <local.dso_init+0xc> // 8: R_X86_64_PLT32 runtime.addmoduledata-0x4 o(0xe8) Addcall(ctxt, initfunc, addmoduledata) // c: c3 retq o(0xc3) if ld.Buildmode == ld.BuildmodePlugin { ctxt.Textp = append(ctxt.Textp, addmoduledata) } ctxt.Textp = append(ctxt.Textp, initfunc) initarray_entry := ctxt.Syms.Lookup("go.link.addmoduledatainit", 0) initarray_entry.Attr |= ld.AttrReachable initarray_entry.Attr |= ld.AttrLocal initarray_entry.Type = obj.SINITARR ld.Addaddr(ctxt, initarray_entry, initfunc) }
func addgotsym(ctxt *ld.Link, s *ld.Symbol) { if s.Got >= 0 { return } ld.Adddynsym(ctxt, s) got := ld.Linklookup(ctxt, ".got", 0) s.Got = int32(got.Size) ld.Adduint64(ctxt, got, 0) if ld.Iself { rela := ld.Linklookup(ctxt, ".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)) } else { ctxt.Diag("addgotsym: unsupported binary format") } }
func addpltsym(ctxt *ld.Link, s *ld.Symbol) { if s.Plt >= 0 { return } 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) if plt.Size == 0 { elfsetupplt(ctxt) } // .got entry s.Got = int32(got.Size) // In theory, all GOT should point to the first PLT entry, // Linux/ARM's dynamic linker will do that for us, but FreeBSD/ARM's // dynamic linker won't, so we'd better do it ourselves. ld.Addaddrplus(ctxt, got, plt, 0) // .plt entry, this depends on the .got entry s.Plt = int32(plt.Size) addpltreloc(ctxt, plt, got, s, obj.R_PLT0) // add lr, pc, #0xXX00000 addpltreloc(ctxt, plt, got, s, obj.R_PLT1) // add lr, lr, #0xYY000 addpltreloc(ctxt, plt, got, s, obj.R_PLT2) // ldr pc, [lr, #0xZZZ]! // rel ld.Addaddrplus(ctxt, rel, got, int64(s.Got)) ld.Adduint32(ctxt, rel, ld.ELF32_R_INFO(uint32(s.Dynid), ld.R_ARM_JUMP_SLOT)) } else { ctxt.Diag("addpltsym: unsupported binary format") } }
func archreloc(ctxt *ld.Link, r *ld.Reloc, s *ld.Symbol, val *int64) int { if ld.Linkmode == ld.LinkExternal { switch r.Type { case obj.R_CALLARM: r.Done = 0 // set up addend for eventual relocation via outer symbol. rs := r.Sym r.Xadd = r.Add if r.Xadd&0x800000 != 0 { r.Xadd |= ^0xffffff } r.Xadd *= 4 for rs.Outer != nil { r.Xadd += ld.Symaddr(ctxt, rs) - ld.Symaddr(ctxt, rs.Outer) rs = rs.Outer } if rs.Type != obj.SHOSTOBJ && rs.Type != obj.SDYNIMPORT && rs.Sect == nil { ctxt.Diag("missing section for %s", rs.Name) } r.Xsym = rs // ld64 for arm seems to want the symbol table to contain offset // into the section rather than pseudo virtual address that contains // the section load address. // we need to compensate that by removing the instruction's address // from addend. if ld.HEADTYPE == obj.Hdarwin { r.Xadd -= ld.Symaddr(ctxt, s) + int64(r.Off) } *val = int64(braddoff(int32(0xff000000&uint32(r.Add)), int32(0xffffff&uint32(r.Xadd/4)))) return 0 } return -1 } switch r.Type { case obj.R_CONST: *val = r.Add return 0 case obj.R_GOTOFF: *val = ld.Symaddr(ctxt, r.Sym) + r.Add - ld.Symaddr(ctxt, ld.Linklookup(ctxt, ".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(ctxt, ld.Linklookup(ctxt, ".got.plt", 0)) < ld.Symaddr(ctxt, ld.Linklookup(ctxt, ".plt", 0)) { ctxt.Diag(".got.plt should be placed after .plt section.") } *val = 0xe28fc600 + (0xff & (int64(uint32(ld.Symaddr(ctxt, r.Sym)-(ld.Symaddr(ctxt, ld.Linklookup(ctxt, ".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(ctxt, r.Sym)-(ld.Symaddr(ctxt, ld.Linklookup(ctxt, ".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(ctxt, r.Sym)-(ld.Symaddr(ctxt, ld.Linklookup(ctxt, ".plt", 0))+int64(r.Off))+r.Add+8))) return 0 case obj.R_CALLARM: // bl XXXXXX or b YYYYYY *val = int64(braddoff(int32(0xff000000&uint32(r.Add)), int32(0xffffff&uint32((ld.Symaddr(ctxt, r.Sym)+int64((uint32(r.Add))*4)-(s.Value+int64(r.Off)))/4)))) return 0 } return -1 }
func machoreloc1(ctxt *ld.Link, r *ld.Reloc, sectoff int64) int { var v uint32 rs := r.Xsym if r.Type == obj.R_PCREL { if rs.Type == obj.SHOSTOBJ { ctxt.Diag("pc-relative relocation of external symbol is not supported") return -1 } if r.Siz != 4 { return -1 } // emit a pair of "scattered" relocations that // resolve to the difference of section addresses of // the symbol and the instruction // this value is added to the field being relocated o1 := uint32(sectoff) o1 |= 1 << 31 // scattered bit o1 |= ld.MACHO_ARM_RELOC_SECTDIFF << 24 o1 |= 2 << 28 // size = 4 o2 := uint32(0) o2 |= 1 << 31 // scattered bit o2 |= ld.MACHO_ARM_RELOC_PAIR << 24 o2 |= 2 << 28 // size = 4 ld.Thearch.Lput(o1) ld.Thearch.Lput(uint32(ld.Symaddr(ctxt, rs))) ld.Thearch.Lput(o2) ld.Thearch.Lput(uint32(ctxt.Cursym.Value + int64(r.Off))) return 0 } if rs.Type == obj.SHOSTOBJ || r.Type == obj.R_CALLARM { if rs.Dynid < 0 { ctxt.Diag("reloc %d to non-macho symbol %s type=%d", r.Type, rs.Name, rs.Type) return -1 } v = uint32(rs.Dynid) v |= 1 << 27 // external relocation } else { v = uint32(rs.Sect.Extnum) if v == 0 { ctxt.Diag("reloc %d to symbol %s in non-macho section %s type=%d", r.Type, rs.Name, rs.Sect.Name, rs.Type) return -1 } } switch r.Type { default: return -1 case obj.R_ADDR: v |= ld.MACHO_GENERIC_RELOC_VANILLA << 28 case obj.R_CALLARM: v |= 1 << 24 // pc-relative bit v |= ld.MACHO_ARM_RELOC_BR24 << 28 } switch r.Siz { default: return -1 case 1: v |= 0 << 25 case 2: v |= 1 << 25 case 4: v |= 2 << 25 case 8: v |= 3 << 25 } ld.Thearch.Lput(uint32(sectoff)) ld.Thearch.Lput(v) return 0 }
func adddynrel(ctxt *ld.Link, s *ld.Symbol, r *ld.Reloc) { targ := r.Sym ctxt.Cursym = s switch r.Type { default: if r.Type >= 256 { ctxt.Diag("unexpected relocation type %d", r.Type) return } // Handle relocations found in ELF object files. case 256 + ld.R_ARM_PLT32: r.Type = obj.R_CALLARM if targ.Type == obj.SDYNIMPORT { addpltsym(ctxt, targ) r.Sym = ld.Linklookup(ctxt, ".plt", 0) r.Add = int64(braddoff(int32(r.Add), targ.Plt/4)) } return case 256 + ld.R_ARM_THM_PC22: // R_ARM_THM_CALL ld.Exitf("R_ARM_THM_CALL, are you using -marm?") return case 256 + ld.R_ARM_GOT32: // R_ARM_GOT_BREL if targ.Type != obj.SDYNIMPORT { addgotsyminternal(ctxt, targ) } else { addgotsym(ctxt, targ) } r.Type = obj.R_CONST // write r->add during relocsym r.Sym = nil r.Add += int64(targ.Got) return case 256 + ld.R_ARM_GOT_PREL: // GOT(nil) + A - nil if targ.Type != obj.SDYNIMPORT { addgotsyminternal(ctxt, targ) } else { addgotsym(ctxt, targ) } r.Type = obj.R_PCREL r.Sym = ld.Linklookup(ctxt, ".got", 0) r.Add += int64(targ.Got) + 4 return case 256 + ld.R_ARM_GOTOFF: // R_ARM_GOTOFF32 r.Type = obj.R_GOTOFF return case 256 + ld.R_ARM_GOTPC: // R_ARM_BASE_PREL r.Type = obj.R_PCREL r.Sym = ld.Linklookup(ctxt, ".got", 0) r.Add += 4 return case 256 + ld.R_ARM_CALL: r.Type = obj.R_CALLARM if targ.Type == obj.SDYNIMPORT { addpltsym(ctxt, targ) r.Sym = ld.Linklookup(ctxt, ".plt", 0) r.Add = int64(braddoff(int32(r.Add), targ.Plt/4)) } return case 256 + ld.R_ARM_REL32: // R_ARM_REL32 r.Type = obj.R_PCREL r.Add += 4 return case 256 + ld.R_ARM_ABS32: if targ.Type == obj.SDYNIMPORT { ctxt.Diag("unexpected R_ARM_ABS32 relocation for dynamic symbol %s", targ.Name) } r.Type = obj.R_ADDR return // we can just ignore this, because we are targeting ARM V5+ anyway case 256 + ld.R_ARM_V4BX: if r.Sym != nil { // R_ARM_V4BX is ABS relocation, so this symbol is a dummy symbol, ignore it r.Sym.Type = 0 } r.Sym = nil return case 256 + ld.R_ARM_PC24, 256 + ld.R_ARM_JUMP24: r.Type = obj.R_CALLARM if targ.Type == obj.SDYNIMPORT { addpltsym(ctxt, targ) r.Sym = ld.Linklookup(ctxt, ".plt", 0) r.Add = int64(braddoff(int32(r.Add), targ.Plt/4)) } return } // Handle references to ELF symbols from our own object files. if targ.Type != obj.SDYNIMPORT { return } switch r.Type { case obj.R_CALLARM: addpltsym(ctxt, targ) r.Sym = ld.Linklookup(ctxt, ".plt", 0) r.Add = int64(targ.Plt) return case obj.R_ADDR: if s.Type != obj.SDATA { break } if ld.Iself { ld.Adddynsym(ctxt, targ) rel := ld.Linklookup(ctxt, ".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 r.Sym = nil return } } ctxt.Cursym = s ctxt.Diag("unsupported relocation for dynamic symbol %s (type=%d stype=%d)", targ.Name, r.Type, targ.Type) }
func gentext(ctxt *ld.Link) { if !ld.DynlinkingGo() && ld.Buildmode != ld.BuildmodePIE && ld.Buildmode != ld.BuildmodeCShared { return } // Generate little thunks that load the PC of the next instruction into a register. for _, r := range [...]struct { name string num uint8 }{ {"ax", 0}, {"cx", 1}, {"dx", 2}, {"bx", 3}, // sp {"bp", 5}, {"si", 6}, {"di", 7}, } { thunkfunc := ld.Linklookup(ctxt, "__x86.get_pc_thunk."+r.name, 0) thunkfunc.Type = obj.STEXT thunkfunc.Attr |= ld.AttrLocal thunkfunc.Attr |= ld.AttrReachable //TODO: remove? o := func(op ...uint8) { for _, op1 := range op { ld.Adduint8(ctxt, thunkfunc, op1) } } // 8b 04 24 mov (%esp),%eax // Destination register is in bits 3-5 of the middle byte, so add that in. o(0x8b, 0x04+r.num<<3, 0x24) // c3 ret o(0xc3) ctxt.Textp = append(ctxt.Textp, thunkfunc) } addmoduledata := ld.Linklookup(ctxt, "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.Type = obj.STEXT initfunc.Attr |= ld.AttrLocal initfunc.Attr |= ld.AttrReachable o := func(op ...uint8) { for _, op1 := range op { ld.Adduint8(ctxt, initfunc, op1) } } // go.link.addmoduledata: // 53 push %ebx // e8 00 00 00 00 call __x86.get_pc_thunk.cx + R_CALL __x86.get_pc_thunk.cx // 8d 81 00 00 00 00 lea 0x0(%ecx), %eax + R_PCREL ctxt.Moduledata // 8d 99 00 00 00 00 lea 0x0(%ecx), %ebx + R_GOTPC _GLOBAL_OFFSET_TABLE_ // e8 00 00 00 00 call runtime.addmoduledata@plt + R_CALL runtime.addmoduledata // 5b pop %ebx // c3 ret o(0x53) o(0xe8) addcall(ctxt, initfunc, ld.Linklookup(ctxt, "__x86.get_pc_thunk.cx", 0)) o(0x8d, 0x81) ld.Addpcrelplus(ctxt, initfunc, ctxt.Moduledata, 6) o(0x8d, 0x99) i := initfunc.Size initfunc.Size += 4 ld.Symgrow(ctxt, initfunc, initfunc.Size) r := ld.Addrel(initfunc) r.Sym = ld.Linklookup(ctxt, "_GLOBAL_OFFSET_TABLE_", 0) r.Off = int32(i) r.Type = obj.R_PCREL r.Add = 12 r.Siz = 4 o(0xe8) addcall(ctxt, initfunc, addmoduledata) o(0x5b) o(0xc3) ctxt.Textp = append(ctxt.Textp, initfunc) initarray_entry := ld.Linklookup(ctxt, "go.link.addmoduledatainit", 0) initarray_entry.Attr |= ld.AttrReachable initarray_entry.Attr |= ld.AttrLocal initarray_entry.Type = obj.SINITARR ld.Addaddr(ctxt, initarray_entry, initfunc) }
func adddynrel(ctxt *ld.Link, s *ld.Symbol, r *ld.Reloc) { targ := r.Sym ctxt.Cursym = s switch r.Type { default: if r.Type >= 256 { ctxt.Diag("unexpected relocation type %d", r.Type) return } // Handle relocations found in ELF object files. case 256 + ld.R_386_PC32: if targ.Type == obj.SDYNIMPORT { ctxt.Diag("unexpected R_386_PC32 relocation for dynamic symbol %s", targ.Name) } if targ.Type == 0 || targ.Type == obj.SXREF { ctxt.Diag("unknown symbol %s in pcrel", targ.Name) } r.Type = obj.R_PCREL r.Add += 4 return case 256 + ld.R_386_PLT32: r.Type = obj.R_PCREL r.Add += 4 if targ.Type == obj.SDYNIMPORT { addpltsym(ctxt, targ) r.Sym = ld.Linklookup(ctxt, ".plt", 0) r.Add += int64(targ.Plt) } return case 256 + ld.R_386_GOT32, 256 + ld.R_386_GOT32X: if targ.Type != obj.SDYNIMPORT { // have symbol if r.Off >= 2 && s.P[r.Off-2] == 0x8b { // turn MOVL of GOT entry into LEAL of symbol address, relative to GOT. s.P[r.Off-2] = 0x8d r.Type = obj.R_GOTOFF return } if r.Off >= 2 && s.P[r.Off-2] == 0xff && s.P[r.Off-1] == 0xb3 { // turn PUSHL of GOT entry into PUSHL of symbol itself. // use unnecessary SS prefix to keep instruction same length. s.P[r.Off-2] = 0x36 s.P[r.Off-1] = 0x68 r.Type = obj.R_ADDR return } ctxt.Diag("unexpected GOT reloc for non-dynamic symbol %s", targ.Name) return } addgotsym(ctxt, targ) r.Type = obj.R_CONST // write r->add during relocsym r.Sym = nil r.Add += int64(targ.Got) return case 256 + ld.R_386_GOTOFF: r.Type = obj.R_GOTOFF return case 256 + ld.R_386_GOTPC: r.Type = obj.R_PCREL r.Sym = ld.Linklookup(ctxt, ".got", 0) r.Add += 4 return case 256 + ld.R_386_32: if targ.Type == obj.SDYNIMPORT { ctxt.Diag("unexpected R_386_32 relocation for dynamic symbol %s", targ.Name) } r.Type = obj.R_ADDR return case 512 + ld.MACHO_GENERIC_RELOC_VANILLA*2 + 0: r.Type = obj.R_ADDR if targ.Type == obj.SDYNIMPORT { ctxt.Diag("unexpected reloc for dynamic symbol %s", targ.Name) } return 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.Add = int64(targ.Plt) r.Type = obj.R_PCREL return } r.Type = obj.R_PCREL return case 512 + ld.MACHO_FAKE_GOTPCREL: if targ.Type != obj.SDYNIMPORT { // have symbol // turn MOVL of GOT entry into LEAL of symbol itself if r.Off < 2 || s.P[r.Off-2] != 0x8b { ctxt.Diag("unexpected GOT reloc for non-dynamic symbol %s", targ.Name) return } s.P[r.Off-2] = 0x8d r.Type = obj.R_PCREL return } addgotsym(ctxt, targ) r.Sym = ld.Linklookup(ctxt, ".got", 0) r.Add += int64(targ.Got) r.Type = obj.R_PCREL return } // Handle references to ELF symbols from our own object files. if targ.Type != obj.SDYNIMPORT { return } switch r.Type { case obj.R_CALL, obj.R_PCREL: addpltsym(ctxt, targ) r.Sym = ld.Linklookup(ctxt, ".plt", 0) r.Add = int64(targ.Plt) return case obj.R_ADDR: if s.Type != obj.SDATA { break } if ld.Iself { ld.Adddynsym(ctxt, targ) rel := ld.Linklookup(ctxt, ".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 r.Sym = nil return } if ld.HEADTYPE == obj.Hdarwin && s.Size == int64(ld.SysArch.PtrSize) && r.Off == 0 { // Mach-O relocations are a royal pain to lay out. // They use a compact stateful bytecode representation // that is too much bother to deal with. // Instead, interpret the C declaration // void *_Cvar_stderr = &stderr; // as making _Cvar_stderr the name of a GOT entry // for stderr. This is separate from the usual GOT entry, // just in case the C code assigns to the variable, // and of course it only works for single pointers, // but we only need to support cgo and that's all it needs. ld.Adddynsym(ctxt, targ) got := ld.Linklookup(ctxt, ".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)) r.Type = 256 // ignore during relocsym return } if ld.HEADTYPE == obj.Hwindows && s.Size == int64(ld.SysArch.PtrSize) { // nothing to do, the relocation will be laid out in pereloc1 return } } ctxt.Cursym = s ctxt.Diag("unsupported relocation for dynamic symbol %s (type=%d stype=%d)", targ.Name, r.Type, targ.Type) }
func asmb(ctxt *ld.Link) { if ctxt.Debugvlog != 0 { ctxt.Logf("%5.2f asmb\n", obj.Cputime()) } if ld.Iself { ld.Asmbelfsetup(ctxt) } sect := ld.Segtext.Sect ld.Cseek(int64(sect.Vaddr - ld.Segtext.Vaddr + ld.Segtext.Fileoff)) ld.Codeblk(ctxt, int64(sect.Vaddr), int64(sect.Length)) for sect = sect.Next; sect != nil; sect = sect.Next { ld.Cseek(int64(sect.Vaddr - ld.Segtext.Vaddr + ld.Segtext.Fileoff)) ld.Datblk(ctxt, int64(sect.Vaddr), int64(sect.Length)) } if ld.Segrodata.Filelen > 0 { if ctxt.Debugvlog != 0 { ctxt.Logf("%5.2f rodatblk\n", obj.Cputime()) } ld.Cseek(int64(ld.Segrodata.Fileoff)) ld.Datblk(ctxt, int64(ld.Segrodata.Vaddr), int64(ld.Segrodata.Filelen)) } if ctxt.Debugvlog != 0 { ctxt.Logf("%5.2f datblk\n", obj.Cputime()) } ld.Cseek(int64(ld.Segdata.Fileoff)) ld.Datblk(ctxt, int64(ld.Segdata.Vaddr), int64(ld.Segdata.Filelen)) ld.Cseek(int64(ld.Segdwarf.Fileoff)) ld.Dwarfblk(ctxt, int64(ld.Segdwarf.Vaddr), int64(ld.Segdwarf.Filelen)) /* output symbol table */ ld.Symsize = 0 ld.Lcsize = 0 symo := uint32(0) if !*ld.FlagS { if !ld.Iself { ctxt.Diag("unsupported executable format") } if ctxt.Debugvlog != 0 { ctxt.Logf("%5.2f sym\n", obj.Cputime()) } symo = uint32(ld.Segdwarf.Fileoff + ld.Segdwarf.Filelen) symo = uint32(ld.Rnd(int64(symo), int64(*ld.FlagRound))) ld.Cseek(int64(symo)) if ctxt.Debugvlog != 0 { ctxt.Logf("%5.2f elfsym\n", obj.Cputime()) } ld.Asmelfsym(ctxt) ld.Cflush() ld.Cwrite(ld.Elfstrdat) if ctxt.Debugvlog != 0 { ctxt.Logf("%5.2f dwarf\n", obj.Cputime()) } if ld.Linkmode == ld.LinkExternal { ld.Elfemitreloc(ctxt) } } ctxt.Cursym = nil if ctxt.Debugvlog != 0 { ctxt.Logf("%5.2f header\n", obj.Cputime()) } ld.Cseek(0) switch ld.HEADTYPE { default: ctxt.Diag("unsupported operating system") case obj.Hlinux: ld.Asmbelf(ctxt, int64(symo)) } ld.Cflush() if *ld.FlagC { fmt.Printf("textsize=%d\n", ld.Segtext.Filelen) fmt.Printf("datsize=%d\n", ld.Segdata.Filelen) fmt.Printf("bsssize=%d\n", ld.Segdata.Length-ld.Segdata.Filelen) fmt.Printf("symsize=%d\n", ld.Symsize) fmt.Printf("lcsize=%d\n", ld.Lcsize) fmt.Printf("total=%d\n", ld.Segtext.Filelen+ld.Segdata.Length+uint64(ld.Symsize)+uint64(ld.Lcsize)) } }
func archreloc(ctxt *ld.Link, r *ld.Reloc, s *ld.Symbol, val *int64) int { if ld.Linkmode == ld.LinkExternal { switch r.Type { default: return -1 case obj.R_ADDRMIPS, obj.R_ADDRMIPSU: r.Done = 0 // set up addend for eventual relocation via outer symbol. rs := r.Sym r.Xadd = r.Add for rs.Outer != nil { r.Xadd += ld.Symaddr(ctxt, rs) - ld.Symaddr(ctxt, rs.Outer) rs = rs.Outer } if rs.Type != obj.SHOSTOBJ && rs.Type != obj.SDYNIMPORT && rs.Sect == nil { ctxt.Diag("missing section for %s", rs.Name) } r.Xsym = rs return 0 case obj.R_ADDRMIPSTLS, obj.R_CALLMIPS, obj.R_JMPMIPS: r.Done = 0 r.Xsym = r.Sym r.Xadd = r.Add return 0 } } switch r.Type { case obj.R_CONST: *val = r.Add return 0 case obj.R_GOTOFF: *val = ld.Symaddr(ctxt, r.Sym) + r.Add - ld.Symaddr(ctxt, ld.Linklookup(ctxt, ".got", 0)) return 0 case obj.R_ADDRMIPS, obj.R_ADDRMIPSU: t := ld.Symaddr(ctxt, r.Sym) + r.Add o1 := ld.SysArch.ByteOrder.Uint32(s.P[r.Off:]) if r.Type == obj.R_ADDRMIPS { *val = int64(o1&0xffff0000 | uint32(t)&0xffff) } else { *val = int64(o1&0xffff0000 | uint32((t+1<<15)>>16)&0xffff) } return 0 case obj.R_ADDRMIPSTLS: // thread pointer is at 0x7000 offset from the start of TLS data area t := ld.Symaddr(ctxt, r.Sym) + r.Add - 0x7000 if t < -32768 || t >= 32678 { ctxt.Diag("TLS offset out of range %d", t) } o1 := ld.SysArch.ByteOrder.Uint32(s.P[r.Off:]) *val = int64(o1&0xffff0000 | uint32(t)&0xffff) return 0 case obj.R_CALLMIPS, obj.R_JMPMIPS: // Low 26 bits = (S + A) >> 2 t := ld.Symaddr(ctxt, r.Sym) + r.Add o1 := ld.SysArch.ByteOrder.Uint32(s.P[r.Off:]) *val = int64(o1&0xfc000000 | uint32(t>>2)&^0xfc000000) return 0 } return -1 }
func adddynrel(ctxt *ld.Link, s *ld.Symbol, r *ld.Reloc) { targ := r.Sym ctxt.Cursym = s switch r.Type { default: if r.Type >= 256 { ctxt.Diag("unexpected relocation type %d", r.Type) return } // Handle relocations found in ELF object files. case 256 + ld.R_390_12, 256 + ld.R_390_GOT12: ctxt.Diag("s390x 12-bit relocations have not been implemented (relocation type %d)", r.Type-256) return case 256 + ld.R_390_8, 256 + ld.R_390_16, 256 + ld.R_390_32, 256 + ld.R_390_64: if targ.Type == obj.SDYNIMPORT { ctxt.Diag("unexpected R_390_nn relocation for dynamic symbol %s", targ.Name) } r.Type = obj.R_ADDR return case 256 + ld.R_390_PC16, 256 + ld.R_390_PC32, 256 + ld.R_390_PC64: if targ.Type == obj.SDYNIMPORT { ctxt.Diag("unexpected R_390_PCnn relocation for dynamic symbol %s", targ.Name) } if targ.Type == 0 || targ.Type == obj.SXREF { ctxt.Diag("unknown symbol %s in pcrel", targ.Name) } r.Type = obj.R_PCREL r.Add += int64(r.Siz) return case 256 + ld.R_390_GOT16, 256 + ld.R_390_GOT32, 256 + ld.R_390_GOT64: ctxt.Diag("unimplemented S390x relocation: %v", r.Type-256) return case 256 + ld.R_390_PLT16DBL, 256 + ld.R_390_PLT32DBL: r.Type = obj.R_PCREL r.Variant = ld.RV_390_DBL r.Add += int64(r.Siz) if targ.Type == obj.SDYNIMPORT { addpltsym(ctxt, targ) r.Sym = ld.Linklookup(ctxt, ".plt", 0) r.Add += int64(targ.Plt) } return case 256 + ld.R_390_PLT32, 256 + ld.R_390_PLT64: r.Type = obj.R_PCREL r.Add += int64(r.Siz) if targ.Type == obj.SDYNIMPORT { addpltsym(ctxt, targ) r.Sym = ld.Linklookup(ctxt, ".plt", 0) r.Add += int64(targ.Plt) } return case 256 + ld.R_390_COPY: ctxt.Diag("unimplemented S390x relocation: %v", r.Type-256) case 256 + ld.R_390_GLOB_DAT: ctxt.Diag("unimplemented S390x relocation: %v", r.Type-256) case 256 + ld.R_390_JMP_SLOT: ctxt.Diag("unimplemented S390x relocation: %v", r.Type-256) case 256 + ld.R_390_RELATIVE: ctxt.Diag("unimplemented S390x relocation: %v", r.Type-256) case 256 + ld.R_390_GOTOFF: if targ.Type == obj.SDYNIMPORT { ctxt.Diag("unexpected R_390_GOTOFF relocation for dynamic symbol %s", targ.Name) } r.Type = obj.R_GOTOFF return case 256 + ld.R_390_GOTPC: r.Type = obj.R_PCREL r.Sym = ld.Linklookup(ctxt, ".got", 0) r.Add += int64(r.Siz) return case 256 + ld.R_390_PC16DBL, 256 + ld.R_390_PC32DBL: r.Type = obj.R_PCREL r.Variant = ld.RV_390_DBL r.Add += int64(r.Siz) if targ.Type == obj.SDYNIMPORT { ctxt.Diag("unexpected R_390_PCnnDBL relocation for dynamic symbol %s", targ.Name) } return 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.Add += int64(r.Siz) return case 256 + ld.R_390_GOTENT: addgotsym(ctxt, targ) r.Type = obj.R_PCREL r.Variant = ld.RV_390_DBL r.Sym = ld.Linklookup(ctxt, ".got", 0) r.Add += int64(targ.Got) r.Add += int64(r.Siz) return } // Handle references to ELF symbols from our own object files. if targ.Type != obj.SDYNIMPORT { return } ctxt.Diag("unsupported relocation for dynamic symbol %s (type=%d stype=%d)", targ.Name, r.Type, targ.Type) }
func asmb(ctxt *ld.Link) { if ctxt.Debugvlog != 0 { ctxt.Logf("%5.2f asmb\n", obj.Cputime()) } if ld.Iself { ld.Asmbelfsetup(ctxt) } sect := ld.Segtext.Sect ld.Cseek(int64(sect.Vaddr - ld.Segtext.Vaddr + ld.Segtext.Fileoff)) ld.Codeblk(ctxt, int64(sect.Vaddr), int64(sect.Length)) for sect = sect.Next; sect != nil; sect = sect.Next { ld.Cseek(int64(sect.Vaddr - ld.Segtext.Vaddr + ld.Segtext.Fileoff)) ld.Datblk(ctxt, int64(sect.Vaddr), int64(sect.Length)) } if ld.Segrodata.Filelen > 0 { if ctxt.Debugvlog != 0 { ctxt.Logf("%5.2f rodatblk\n", obj.Cputime()) } ld.Cseek(int64(ld.Segrodata.Fileoff)) ld.Datblk(ctxt, int64(ld.Segrodata.Vaddr), int64(ld.Segrodata.Filelen)) } if ctxt.Debugvlog != 0 { ctxt.Logf("%5.2f datblk\n", obj.Cputime()) } ld.Cseek(int64(ld.Segdata.Fileoff)) ld.Datblk(ctxt, int64(ld.Segdata.Vaddr), int64(ld.Segdata.Filelen)) ld.Cseek(int64(ld.Segdwarf.Fileoff)) ld.Dwarfblk(ctxt, int64(ld.Segdwarf.Vaddr), int64(ld.Segdwarf.Filelen)) /* output symbol table */ ld.Symsize = 0 ld.Lcsize = 0 symo := uint32(0) if !*ld.FlagS { // TODO: rationalize if ctxt.Debugvlog != 0 { ctxt.Logf("%5.2f sym\n", obj.Cputime()) } switch ld.HEADTYPE { default: if ld.Iself { symo = uint32(ld.Segdwarf.Fileoff + ld.Segdwarf.Filelen) symo = uint32(ld.Rnd(int64(symo), int64(*ld.FlagRound))) } case obj.Hplan9: symo = uint32(ld.Segdata.Fileoff + ld.Segdata.Filelen) } ld.Cseek(int64(symo)) switch ld.HEADTYPE { default: if ld.Iself { if ctxt.Debugvlog != 0 { ctxt.Logf("%5.2f elfsym\n", obj.Cputime()) } ld.Asmelfsym(ctxt) ld.Cflush() ld.Cwrite(ld.Elfstrdat) if ld.Linkmode == ld.LinkExternal { ld.Elfemitreloc(ctxt) } } case obj.Hplan9: ld.Asmplan9sym(ctxt) ld.Cflush() sym := ld.Linklookup(ctxt, "pclntab", 0) if sym != nil { ld.Lcsize = int32(len(sym.P)) for i := 0; int32(i) < ld.Lcsize; i++ { ld.Cput(sym.P[i]) } ld.Cflush() } } } ctxt.Cursym = nil if ctxt.Debugvlog != 0 { ctxt.Logf("%5.2f header\n", obj.Cputime()) } ld.Cseek(0) switch ld.HEADTYPE { default: case obj.Hplan9: /* plan 9 */ magic := uint32(4*18*18 + 7) if ld.SysArch == sys.ArchMIPS64LE { magic = uint32(4*26*26 + 7) } ld.Thearch.Lput(magic) /* magic */ ld.Thearch.Lput(uint32(ld.Segtext.Filelen)) /* sizes */ ld.Thearch.Lput(uint32(ld.Segdata.Filelen)) ld.Thearch.Lput(uint32(ld.Segdata.Length - ld.Segdata.Filelen)) ld.Thearch.Lput(uint32(ld.Symsize)) /* nsyms */ ld.Thearch.Lput(uint32(ld.Entryvalue(ctxt))) /* va of entry */ ld.Thearch.Lput(0) ld.Thearch.Lput(uint32(ld.Lcsize)) case obj.Hlinux, obj.Hfreebsd, obj.Hnetbsd, obj.Hopenbsd, obj.Hnacl: ld.Asmbelf(ctxt, int64(symo)) } ld.Cflush() if *ld.FlagC { fmt.Printf("textsize=%d\n", ld.Segtext.Filelen) fmt.Printf("datsize=%d\n", ld.Segdata.Filelen) fmt.Printf("bsssize=%d\n", ld.Segdata.Length-ld.Segdata.Filelen) fmt.Printf("symsize=%d\n", ld.Symsize) fmt.Printf("lcsize=%d\n", ld.Lcsize) fmt.Printf("total=%d\n", ld.Segtext.Filelen+ld.Segdata.Length+uint64(ld.Symsize)+uint64(ld.Lcsize)) } }
func addpltsym(ctxt *ld.Link, s *ld.Symbol) { if s.Plt >= 0 { return } 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) if plt.Size == 0 { elfsetupplt(ctxt) } // larl %r1,_GLOBAL_OFFSET_TABLE_+index ld.Adduint8(ctxt, plt, 0xc0) ld.Adduint8(ctxt, plt, 0x10) ld.Addpcrelplus(ctxt, plt, got, got.Size+6) // need variant? // add to got: pointer to current pos in plt ld.Addaddrplus(ctxt, got, plt, plt.Size+8) // weird but correct // lg %r1,0(%r1) ld.Adduint8(ctxt, plt, 0xe3) ld.Adduint8(ctxt, plt, 0x10) ld.Adduint8(ctxt, plt, 0x10) ld.Adduint8(ctxt, plt, 0x00) ld.Adduint8(ctxt, plt, 0x00) ld.Adduint8(ctxt, plt, 0x04) // br %r1 ld.Adduint8(ctxt, plt, 0x07) ld.Adduint8(ctxt, plt, 0xf1) // basr %r1,%r0 ld.Adduint8(ctxt, plt, 0x0d) ld.Adduint8(ctxt, plt, 0x10) // lgf %r1,12(%r1) ld.Adduint8(ctxt, plt, 0xe3) ld.Adduint8(ctxt, plt, 0x10) ld.Adduint8(ctxt, plt, 0x10) ld.Adduint8(ctxt, plt, 0x0c) ld.Adduint8(ctxt, plt, 0x00) ld.Adduint8(ctxt, plt, 0x14) // jg .plt ld.Adduint8(ctxt, plt, 0xc0) ld.Adduint8(ctxt, plt, 0xf4) ld.Adduint32(ctxt, plt, uint32(-((plt.Size - 2) >> 1))) // roll-your-own relocation //.plt index ld.Adduint32(ctxt, plt, uint32(rela.Size)) // rela size before current entry // rela ld.Addaddrplus(ctxt, rela, got, got.Size-8) ld.Adduint64(ctxt, rela, ld.ELF64_R_INFO(uint32(s.Dynid), ld.R_390_JMP_SLOT)) ld.Adduint64(ctxt, rela, 0) s.Plt = int32(plt.Size - 32) } else { ctxt.Diag("addpltsym: unsupported binary format") } }