mirror of https://github.com/golang/go.git
343 lines
7.6 KiB
C
343 lines
7.6 KiB
C
// Inferno utils/5l/asm.c
|
|
// http://code.google.com/p/inferno-os/source/browse/utils/5l/asm.c
|
|
//
|
|
// Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved.
|
|
// Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
|
|
// Portions Copyright © 1997-1999 Vita Nuova Limited
|
|
// Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
|
|
// Portions Copyright © 2004,2006 Bruce Ellis
|
|
// Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
|
|
// Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
|
|
// Portions Copyright © 2009 The Go Authors. All rights reserved.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to deal
|
|
// in the Software without restriction, including without limitation the rights
|
|
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
// copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
// THE SOFTWARE.
|
|
|
|
// Writing object files.
|
|
|
|
#include "l.h"
|
|
#include "../ld/lib.h"
|
|
#include "../ld/elf.h"
|
|
#include "../ld/dwarf.h"
|
|
|
|
|
|
char linuxdynld[] = "/lib64/ld64.so.1";
|
|
char freebsddynld[] = "XXX";
|
|
char openbsddynld[] = "XXX";
|
|
char netbsddynld[] = "XXX";
|
|
char dragonflydynld[] = "XXX";
|
|
char solarisdynld[] = "XXX";
|
|
|
|
static int
|
|
needlib(char *name)
|
|
{
|
|
char *p;
|
|
LSym *s;
|
|
|
|
if(*name == '\0')
|
|
return 0;
|
|
|
|
/* reuse hash code in symbol table */
|
|
p = smprint(".dynlib.%s", name);
|
|
s = linklookup(ctxt, p, 0);
|
|
free(p);
|
|
if(s->type == 0) {
|
|
s->type = 100; // avoid SDATA, etc.
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int nelfsym = 1;
|
|
|
|
void
|
|
adddynrela(LSym *rel, LSym *s, Reloc *r)
|
|
{
|
|
// TODO(minux)
|
|
USED(rel); USED(s); USED(r);
|
|
}
|
|
|
|
void
|
|
adddynrel(LSym *s, Reloc *r)
|
|
{
|
|
LSym *targ;
|
|
|
|
// TODO(minux)
|
|
|
|
targ = r->sym;
|
|
ctxt->cursym = s;
|
|
diag("unsupported relocation for dynamic symbol %s (type=%d stype=%d)", targ->name, r->type, targ->type);
|
|
}
|
|
|
|
int
|
|
elfreloc1(Reloc *r, vlong sectoff)
|
|
{
|
|
USED(r); USED(sectoff);
|
|
// TODO(minux)
|
|
return -1;
|
|
}
|
|
|
|
void
|
|
elfsetupplt(void)
|
|
{
|
|
// TODO(minux)
|
|
return;
|
|
}
|
|
|
|
int
|
|
machoreloc1(Reloc *r, vlong sectoff)
|
|
{
|
|
USED(r);
|
|
USED(sectoff);
|
|
|
|
return -1;
|
|
}
|
|
|
|
|
|
int
|
|
archreloc(Reloc *r, LSym *s, vlong *val)
|
|
{
|
|
uint32 o1, o2;
|
|
int32 t;
|
|
|
|
if(linkmode == LinkExternal) {
|
|
// TODO(minux): translate R_ADDRPOWER and R_CALLPOWER into standard ELF relocations.
|
|
// R_ADDRPOWER corresponds to R_PPC_ADDR16_HA and R_PPC_ADDR16_LO.
|
|
// R_CALLPOWER corresponds to R_PPC_REL24.
|
|
return -1;
|
|
}
|
|
switch(r->type) {
|
|
case R_CONST:
|
|
*val = r->add;
|
|
return 0;
|
|
case R_GOTOFF:
|
|
*val = symaddr(r->sym) + r->add - symaddr(linklookup(ctxt, ".got", 0));
|
|
return 0;
|
|
case R_ADDRPOWER:
|
|
// r->add is two power64 instructions holding an immediate 32-bit constant.
|
|
// We want to add r->sym's address to that constant.
|
|
// The encoding of the immediate x<<16 + y,
|
|
// where x is the low 16 bits of the first instruction and y is the low 16
|
|
// bits of the second. Both x and y are signed (int16, not uint16).
|
|
o1 = r->add >> 32;
|
|
o2 = r->add;
|
|
t = symaddr(r->sym);
|
|
if(t < 0) {
|
|
ctxt->diag("relocation for %s is too big (>=2G): %lld", s->name, symaddr(r->sym));
|
|
}
|
|
t += ((o1 & 0xffff) << 16) + ((int32)o2 << 16 >> 16);
|
|
if(t & 0x8000)
|
|
t += 0x10000;
|
|
o1 = (o1 & 0xffff0000) | ((t >> 16) & 0xffff);
|
|
o2 = (o2 & 0xffff0000) | (t & 0xffff);
|
|
// when laid out, the instruction order must always be o1, o2.
|
|
if(ctxt->arch->endian == BigEndian)
|
|
*val = ((vlong)o1 << 32) | o2;
|
|
else
|
|
*val = ((vlong)o2 << 32) | o1;
|
|
return 0;
|
|
case R_CALLPOWER:
|
|
// Bits 6 through 29 = (S + A - P) >> 2
|
|
if(ctxt->arch->endian == BigEndian)
|
|
o1 = be32(s->p + r->off);
|
|
else
|
|
o1 = le32(s->p + r->off);
|
|
|
|
t = symaddr(r->sym) + r->add - (s->value + r->off);
|
|
if(t & 3)
|
|
ctxt->diag("relocation for %s is not aligned: %lld", s->name, t);
|
|
if(t << 6 >> 6 != t)
|
|
ctxt->diag("relocation for %s is too big: %lld", s->name, t);
|
|
|
|
*val = (o1 & 0xfc000003U) | (t & ~0xfc000003U);
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void
|
|
adddynsym(Link *ctxt, LSym *s)
|
|
{
|
|
USED(ctxt); USED(s);
|
|
// TODO(minux)
|
|
return;
|
|
}
|
|
|
|
void
|
|
adddynlib(char *lib)
|
|
{
|
|
LSym *s;
|
|
|
|
if(!needlib(lib))
|
|
return;
|
|
|
|
if(iself) {
|
|
s = linklookup(ctxt, ".dynstr", 0);
|
|
if(s->size == 0)
|
|
addstring(s, "");
|
|
elfwritedynent(linklookup(ctxt, ".dynamic", 0), DT_NEEDED, addstring(s, lib));
|
|
} else {
|
|
diag("adddynlib: unsupported binary format");
|
|
}
|
|
}
|
|
|
|
void
|
|
asmb(void)
|
|
{
|
|
uint32 symo;
|
|
Section *sect;
|
|
LSym *sym;
|
|
int i;
|
|
|
|
if(debug['v'])
|
|
Bprint(&bso, "%5.2f asmb\n", cputime());
|
|
Bflush(&bso);
|
|
|
|
if(iself)
|
|
asmbelfsetup();
|
|
|
|
sect = segtext.sect;
|
|
cseek(sect->vaddr - segtext.vaddr + segtext.fileoff);
|
|
codeblk(sect->vaddr, sect->len);
|
|
for(sect = sect->next; sect != nil; sect = sect->next) {
|
|
cseek(sect->vaddr - segtext.vaddr + segtext.fileoff);
|
|
datblk(sect->vaddr, sect->len);
|
|
}
|
|
|
|
if(segrodata.filelen > 0) {
|
|
if(debug['v'])
|
|
Bprint(&bso, "%5.2f rodatblk\n", cputime());
|
|
Bflush(&bso);
|
|
|
|
cseek(segrodata.fileoff);
|
|
datblk(segrodata.vaddr, segrodata.filelen);
|
|
}
|
|
|
|
if(debug['v'])
|
|
Bprint(&bso, "%5.2f datblk\n", cputime());
|
|
Bflush(&bso);
|
|
|
|
cseek(segdata.fileoff);
|
|
datblk(segdata.vaddr, segdata.filelen);
|
|
|
|
/* output symbol table */
|
|
symsize = 0;
|
|
lcsize = 0;
|
|
symo = 0;
|
|
if(!debug['s']) {
|
|
// TODO: rationalize
|
|
if(debug['v'])
|
|
Bprint(&bso, "%5.2f sym\n", cputime());
|
|
Bflush(&bso);
|
|
switch(HEADTYPE) {
|
|
default:
|
|
if(iself)
|
|
goto ElfSym;
|
|
case Hplan9:
|
|
symo = segdata.fileoff+segdata.filelen;
|
|
break;
|
|
ElfSym:
|
|
symo = segdata.fileoff+segdata.filelen;
|
|
symo = rnd(symo, INITRND);
|
|
break;
|
|
}
|
|
cseek(symo);
|
|
switch(HEADTYPE) {
|
|
default:
|
|
if(iself) {
|
|
if(debug['v'])
|
|
Bprint(&bso, "%5.2f elfsym\n", cputime());
|
|
asmelfsym();
|
|
cflush();
|
|
cwrite(elfstrdat, elfstrsize);
|
|
|
|
if(debug['v'])
|
|
Bprint(&bso, "%5.2f dwarf\n", cputime());
|
|
dwarfemitdebugsections();
|
|
|
|
if(linkmode == LinkExternal)
|
|
elfemitreloc();
|
|
}
|
|
break;
|
|
case Hplan9:
|
|
asmplan9sym();
|
|
cflush();
|
|
|
|
sym = linklookup(ctxt, "pclntab", 0);
|
|
if(sym != nil) {
|
|
lcsize = sym->np;
|
|
for(i=0; i < lcsize; i++)
|
|
cput(sym->p[i]);
|
|
|
|
cflush();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
ctxt->cursym = nil;
|
|
if(debug['v'])
|
|
Bprint(&bso, "%5.2f header\n", cputime());
|
|
Bflush(&bso);
|
|
cseek(0L);
|
|
switch(HEADTYPE) {
|
|
default:
|
|
case Hplan9: /* plan 9 */
|
|
LPUT(0x647); /* magic */
|
|
LPUT(segtext.filelen); /* sizes */
|
|
LPUT(segdata.filelen);
|
|
LPUT(segdata.len - segdata.filelen);
|
|
LPUT(symsize); /* nsyms */
|
|
LPUT(entryvalue()); /* va of entry */
|
|
LPUT(0L);
|
|
LPUT(lcsize);
|
|
break;
|
|
case Hlinux:
|
|
case Hfreebsd:
|
|
case Hnetbsd:
|
|
case Hopenbsd:
|
|
case Hnacl:
|
|
asmbelf(symo);
|
|
break;
|
|
}
|
|
cflush();
|
|
if(debug['c']){
|
|
print("textsize=%ulld\n", segtext.filelen);
|
|
print("datsize=%ulld\n", segdata.filelen);
|
|
print("bsssize=%ulld\n", segdata.len - segdata.filelen);
|
|
print("symsize=%d\n", symsize);
|
|
print("lcsize=%d\n", lcsize);
|
|
print("total=%lld\n", segtext.filelen+segdata.len+symsize+lcsize);
|
|
}
|
|
}
|
|
|
|
vlong
|
|
rnd(vlong v, int32 r)
|
|
{
|
|
vlong c;
|
|
|
|
if(r <= 0)
|
|
return v;
|
|
v += r - 1;
|
|
c = v % r;
|
|
if(c < 0)
|
|
c += r;
|
|
v -= c;
|
|
return v;
|
|
}
|