void
elfsetupplt(void)
{
Sym *plt, *got;
plt = lookup(".plt", 0);
got = lookup(".got.plt", 0);
if(plt->size == 0) {
// pushq got+8(IP)
adduint8(plt, 0xff);
adduint8(plt, 0x35);
addpcrelplus(plt, got, 8);
// jmpq got+16(IP)
adduint8(plt, 0xff);
adduint8(plt, 0x25);
addpcrelplus(plt, got, 16);
// nopl 0(AX)
adduint32(plt, 0x00401f0f);
// assume got->size == 0 too
addaddrplus(got, lookup(".dynamic", 0), 0);
adduint64(got, 0);
adduint64(got, 0);
}
}
void
adddynsym(Link *ctxt, LSym *s)
{
LSym *d;
int t;
char *name;
if(s->dynid >= 0)
return;
if(iself) {
s->dynid = nelfsym++;
d = linklookup(ctxt, ".dynsym", 0);
name = s->extname;
adduint32(ctxt, d, addstring(linklookup(ctxt, ".dynstr", 0), name));
/* type */
t = STB_GLOBAL << 4;
if(s->cgoexport && (s->type&SMASK) == STEXT)
t |= STT_FUNC;
else
t |= STT_OBJECT;
adduint8(ctxt, d, t);
/* reserved */
adduint8(ctxt, d, 0);
/* section where symbol is defined */
if(s->type == SDYNIMPORT)
adduint16(ctxt, d, SHN_UNDEF);
else
adduint16(ctxt, d, 1);
/* value */
if(s->type == SDYNIMPORT)
adduint64(ctxt, d, 0);
else
addaddr(ctxt, d, s);
/* size of object */
adduint64(ctxt, d, s->size);
if(!(s->cgoexport & CgoExportDynamic) && s->dynimplib && needlib(s->dynimplib)) {
elfwritedynent(linklookup(ctxt, ".dynamic", 0), DT_NEEDED,
addstring(linklookup(ctxt, ".dynstr", 0), s->dynimplib));
}
} else if(HEADTYPE == Hdarwin) {
diag("adddynsym: missed symbol %s (%s)", s->name, s->extname);
} else if(HEADTYPE == Hwindows) {
// already taken care of
} else {
diag("adddynsym: unsupported binary format");
}
}
void
elfwritedynent(Sym *s, int tag, uint64 val)
{
if(elf64) {
adduint64(s, tag);
adduint64(s, val);
} else {
adduint32(s, tag);
adduint32(s, val);
}
}
void
adddynrela(Sym *rela, Sym *s, Reloc *r)
{
addaddrplus(rela, s, r->off);
adduint64(rela, R_X86_64_RELATIVE);
addaddrplus(rela, r->sym, r->add); // Addend
}
void
elfwritedynentsymsize(Sym *s, int tag, Sym *t)
{
if(elf64)
adduint64(s, tag);
else
adduint32(s, tag);
addsize(s, t);
}
void
elfwritedynentsymsize(LSym *s, int tag, LSym *t)
{
if(elf64)
adduint64(ctxt, s, tag);
else
adduint32(ctxt, s, tag);
addsize(ctxt, s, t);
}
static void
addgotsym(Sym *s)
{
Sym *got, *rela;
if(s->got >= 0)
return;
adddynsym(s);
got = lookup(".got", 0);
s->got = got->size;
adduint64(got, 0);
if(iself) {
rela = lookup(".rela", 0);
addaddrplus(rela, got, s->got);
adduint64(rela, ELF64_R_INFO(s->dynid, R_X86_64_GLOB_DAT));
adduint64(rela, 0);
} else if(HEADTYPE == Hdarwin) {
adduint32(lookup(".linkedit.got", 0), s->dynid);
} else {
diag("addgotsym: unsupported binary format");
}
}
void
adddynsym(Sym *s)
{
Sym *d, *str;
int t;
char *name;
vlong off;
if(s->dynid >= 0)
return;
if(s->dynimpname == nil)
diag("adddynsym: no dynamic name for %s", s->name);
if(iself) {
s->dynid = nelfsym++;
d = lookup(".dynsym", 0);
name = s->dynimpname;
if(name == nil)
name = s->name;
adduint32(d, addstring(lookup(".dynstr", 0), name));
/* type */
t = STB_GLOBAL << 4;
if(s->dynexport && (s->type&SMASK) == STEXT)
t |= STT_FUNC;
else
t |= STT_OBJECT;
adduint8(d, t);
/* reserved */
adduint8(d, 0);
/* section where symbol is defined */
if(!s->dynexport && s->dynimpname != nil)
adduint16(d, SHN_UNDEF);
else {
switch(s->type) {
default:
case STEXT:
t = 11;
break;
case SRODATA:
t = 12;
break;
case SDATA:
t = 13;
break;
case SBSS:
t = 14;
break;
}
adduint16(d, t);
}
/* value */
if(s->type == SDYNIMPORT)
adduint64(d, 0);
else
addaddr(d, s);
/* size of object */
adduint64(d, s->size);
if(!s->dynexport && s->dynimplib && needlib(s->dynimplib)) {
elfwritedynent(lookup(".dynamic", 0), DT_NEEDED,
addstring(lookup(".dynstr", 0), s->dynimplib));
}
} else if(HEADTYPE == Hdarwin) {
// Mach-o symbol nlist64
d = lookup(".dynsym", 0);
name = s->dynimpname;
if(name == nil)
name = s->name;
if(d->size == 0 && ndynexp > 0) { // pre-allocate for dynexps
symgrow(d, ndynexp*16);
}
if(s->dynid <= -100) { // pre-allocated, see cmd/ld/go.c:^sortdynexp()
s->dynid = -s->dynid-100;
off = s->dynid*16;
} else {
off = d->size;
s->dynid = off/16;
}
// darwin still puts _ prefixes on all C symbols
str = lookup(".dynstr", 0);
setuint32(d, off, str->size);
off += 4;
adduint8(str, '_');
addstring(str, name);
if(s->type == SDYNIMPORT) {
setuint8(d, off, 0x01); // type - N_EXT - external symbol
off++;
setuint8(d, off, 0); // section
off++;
} else {
setuint8(d, off, 0x0f);
off++;
switch(s->type) {
default:
case STEXT:
setuint8(d, off, 1);
break;
case SDATA:
setuint8(d, off, 2);
break;
case SBSS:
setuint8(d, off, 4);
break;
}
off++;
}
setuint16(d, off, 0); // desc
off += 2;
if(s->type == SDYNIMPORT)
setuint64(d, off, 0); // value
else
setaddr(d, off, s);
off += 8;
} else if(HEADTYPE != Hwindows) {
diag("adddynsym: unsupported binary format");
}
}
static void
addpltsym(Sym *s)
{
if(s->plt >= 0)
return;
adddynsym(s);
if(iself) {
Sym *plt, *got, *rela;
plt = lookup(".plt", 0);
got = lookup(".got.plt", 0);
rela = lookup(".rela.plt", 0);
if(plt->size == 0)
elfsetupplt();
// jmpq *got+size(IP)
adduint8(plt, 0xff);
adduint8(plt, 0x25);
addpcrelplus(plt, got, got->size);
// add to got: pointer to current pos in plt
addaddrplus(got, plt, plt->size);
// pushq $x
adduint8(plt, 0x68);
adduint32(plt, (got->size-24-8)/8);
// jmpq .plt
adduint8(plt, 0xe9);
adduint32(plt, -(plt->size+4));
// rela
addaddrplus(rela, got, got->size-8);
adduint64(rela, ELF64_R_INFO(s->dynid, R_X86_64_JMP_SLOT));
adduint64(rela, 0);
s->plt = plt->size - 16;
} else if(HEADTYPE == Hdarwin) {
// To do lazy symbol lookup right, we're supposed
// to tell the dynamic loader which library each
// symbol comes from and format the link info
// section just so. I'm too lazy (ha!) to do that
// so for now we'll just use non-lazy pointers,
// which don't need to be told which library to use.
//
// http://networkpx.blogspot.com/2009/09/about-lcdyldinfoonly-command.html
// has details about what we're avoiding.
Sym *plt;
addgotsym(s);
plt = lookup(".plt", 0);
adduint32(lookup(".linkedit.plt", 0), s->dynid);
// jmpq *got+size(IP)
s->plt = plt->size;
adduint8(plt, 0xff);
adduint8(plt, 0x25);
addpcrelplus(plt, lookup(".got", 0), s->got);
} else {
diag("addpltsym: unsupported binary format");
}
}
void
adddynrel(Sym *s, Reloc *r)
{
Sym *targ, *rela, *got;
targ = r->sym;
cursym = s;
switch(r->type) {
default:
if(r->type >= 256) {
diag("unexpected relocation type %d", r->type);
return;
}
break;
// Handle relocations found in ELF object files.
case 256 + R_X86_64_PC32:
if(targ->dynimpname != nil && !targ->dynexport)
diag("unexpected R_X86_64_PC32 relocation for dynamic symbol %s", targ->name);
if(targ->type == 0 || targ->type == SXREF)
diag("unknown symbol %s in pcrel", targ->name);
r->type = D_PCREL;
r->add += 4;
return;
case 256 + R_X86_64_PLT32:
r->type = D_PCREL;
r->add += 4;
if(targ->dynimpname != nil && !targ->dynexport) {
addpltsym(targ);
r->sym = lookup(".plt", 0);
r->add += targ->plt;
}
return;
case 256 + R_X86_64_GOTPCREL:
if(targ->dynimpname == nil || targ->dynexport) {
// have symbol
if(r->off >= 2 && s->p[r->off-2] == 0x8b) {
// turn MOVQ of GOT entry into LEAQ of symbol itself
s->p[r->off-2] = 0x8d;
r->type = D_PCREL;
r->add += 4;
return;
}
// fall back to using GOT and hope for the best (CMOV*)
// TODO: just needs relocation, no need to put in .dynsym
targ->dynimpname = targ->name;
}
addgotsym(targ);
r->type = D_PCREL;
r->sym = lookup(".got", 0);
r->add += 4;
r->add += targ->got;
return;
case 256 + R_X86_64_64:
if(targ->dynimpname != nil && !targ->dynexport)
diag("unexpected R_X86_64_64 relocation for dynamic symbol %s", targ->name);
r->type = D_ADDR;
return;
// Handle relocations found in Mach-O object files.
case 512 + MACHO_X86_64_RELOC_UNSIGNED*2 + 0:
case 512 + MACHO_X86_64_RELOC_SIGNED*2 + 0:
case 512 + MACHO_X86_64_RELOC_BRANCH*2 + 0:
// TODO: What is the difference between all these?
r->type = D_ADDR;
if(targ->dynimpname != nil && !targ->dynexport)
diag("unexpected reloc for dynamic symbol %s", targ->name);
return;
case 512 + MACHO_X86_64_RELOC_BRANCH*2 + 1:
if(targ->dynimpname != nil && !targ->dynexport) {
addpltsym(targ);
r->sym = lookup(".plt", 0);
r->add = targ->plt;
r->type = D_PCREL;
return;
}
// fall through
case 512 + MACHO_X86_64_RELOC_UNSIGNED*2 + 1:
case 512 + MACHO_X86_64_RELOC_SIGNED*2 + 1:
case 512 + MACHO_X86_64_RELOC_SIGNED_1*2 + 1:
case 512 + MACHO_X86_64_RELOC_SIGNED_2*2 + 1:
case 512 + MACHO_X86_64_RELOC_SIGNED_4*2 + 1:
r->type = D_PCREL;
if(targ->dynimpname != nil && !targ->dynexport)
diag("unexpected pc-relative reloc for dynamic symbol %s", targ->name);
return;
case 512 + MACHO_X86_64_RELOC_GOT_LOAD*2 + 1:
if(targ->dynimpname == nil || targ->dynexport) {
// have symbol
// turn MOVQ of GOT entry into LEAQ of symbol itself
if(r->off < 2 || s->p[r->off-2] != 0x8b) {
diag("unexpected GOT_LOAD reloc for non-dynamic symbol %s", targ->name);
return;
}
s->p[r->off-2] = 0x8d;
r->type = D_PCREL;
return;
}
// fall through
case 512 + MACHO_X86_64_RELOC_GOT*2 + 1:
if(targ->dynimpname == nil || targ->dynexport)
diag("unexpected GOT reloc for non-dynamic symbol %s", targ->name);
addgotsym(targ);
r->type = D_PCREL;
r->sym = lookup(".got", 0);
r->add += targ->got;
return;
}
// Handle references to ELF symbols from our own object files.
if(targ->dynimpname == nil || targ->dynexport)
return;
switch(r->type) {
case D_PCREL:
addpltsym(targ);
r->sym = lookup(".plt", 0);
r->add = targ->plt;
return;
case D_ADDR:
if(s->type != SDATA)
break;
if(iself) {
adddynsym(targ);
rela = lookup(".rela", 0);
addaddrplus(rela, s, r->off);
if(r->siz == 8)
adduint64(rela, ELF64_R_INFO(targ->dynid, R_X86_64_64));
else
adduint64(rela, ELF64_R_INFO(targ->dynid, R_X86_64_32));
adduint64(rela, r->add);
r->type = 256; // ignore during relocsym
return;
}
if(HEADTYPE == Hdarwin && s->size == 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.
adddynsym(targ);
got = lookup(".got", 0);
s->type = got->type | SSUB;
s->outer = got;
s->sub = got->sub;
got->sub = s;
s->value = got->size;
adduint64(got, 0);
adduint32(lookup(".linkedit.got", 0), targ->dynid);
r->type = 256; // ignore during relocsym
return;
}
break;
}
cursym = s;
diag("unsupported relocation for dynamic symbol %s (type=%d stype=%d)", targ->name, r->type, targ->type);
}
void
adddynsym(Sym *s)
{
Sym *d, *str;
int t;
char *name;
if(s->dynid >= 0)
return;
if(s->dynimpname == nil)
diag("adddynsym: no dynamic name for %s", s->name);
if(iself) {
s->dynid = nelfsym++;
d = lookup(".dynsym", 0);
name = s->dynimpname;
if(name == nil)
name = s->name;
adduint32(d, addstring(lookup(".dynstr", 0), name));
/* type */
t = STB_GLOBAL << 4;
if(s->dynexport && s->type == STEXT)
t |= STT_FUNC;
else
t |= STT_OBJECT;
adduint8(d, t);
/* reserved */
adduint8(d, 0);
/* section where symbol is defined */
if(!s->dynexport && s->dynimpname != nil)
adduint16(d, SHN_UNDEF);
else {
switch(s->type) {
default:
case STEXT:
t = 11;
break;
case SRODATA:
t = 12;
break;
case SDATA:
t = 13;
break;
case SBSS:
t = 14;
break;
}
adduint16(d, t);
}
/* value */
if(s->type == SDYNIMPORT)
adduint64(d, 0);
else
addaddr(d, s);
/* size of object */
adduint64(d, 0);
if(!s->dynexport && s->dynimplib && needlib(s->dynimplib)) {
elfwritedynent(lookup(".dynamic", 0), DT_NEEDED,
addstring(lookup(".dynstr", 0), s->dynimplib));
}
} else if(HEADTYPE == Hdarwin) {
// Mach-o symbol nlist64
d = lookup(".dynsym", 0);
name = s->dynimpname;
if(name == nil)
name = s->name;
s->dynid = d->size/16;
// darwin still puts _ prefixes on all C symbols
str = lookup(".dynstr", 0);
adduint32(d, str->size);
adduint8(str, '_');
addstring(str, name);
if(s->type == SDYNIMPORT) {
adduint8(d, 0x01); // type - N_EXT - external symbol
adduint8(d, 0); // section
} else {
adduint8(d, 0x0f);
switch(s->type) {
default:
case STEXT:
adduint8(d, 1);
break;
case SDATA:
adduint8(d, 2);
break;
case SBSS:
adduint8(d, 4);
break;
}
}
adduint16(d, 0); // desc
if(s->type == SDYNIMPORT)
adduint64(d, 0); // value
else
addaddr(d, s);
} else if(HEADTYPE != Hwindows) {
diag("adddynsym: unsupported binary format");
}
}
