#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <elf.h>
#include <fcntl.h>
#include <string.h>
#include <malloc.h>
#define IF_DEBUG(x,y) /* */
static int debug_linker = 0;
#define i386_TARGET_ARCH
// #define arm_TARGET_ARCH
#if !defined(i386_TARGET_ARCH) && !defined(arm_TARGET_ARCH)
# error "Must #define i386_TARGET_ARCH or arm_TARGET_ARCH"
#endif
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
//
// TYPES
#define FALSE 0
#define TRUE 1
typedef enum { OBJECT_LOADED, OBJECT_RESOLVED } OStatus;
#define N_FIXUP_PAGES 1
/* Indication of section kinds for loaded objects. Needed by
the GC for deciding whether or not a pointer on the stack
is a code pointer.
*/
typedef
enum { SECTIONKIND_CODE_OR_RODATA,
SECTIONKIND_RWDATA,
SECTIONKIND_OTHER,
SECTIONKIND_NOINFOAVAIL }
SectionKind;
typedef
struct _Section {
void* start;
void* end;
SectionKind kind;
struct _Section* next;
}
Section;
typedef
struct _ProddableBlock {
void* start;
int size;
struct _ProddableBlock* next;
}
ProddableBlock;
/* Top-level structure for an object module. One of these is allocated
* for each object file in use.
*/
typedef struct _ObjectCode {
OStatus status;
char* fileName;
int fileSize;
char* formatName; /* eg "ELF32", "DLL", "COFF", etc. */
/* An array containing ptrs to all the symbol names copied from
this object into the global symbol hash table. This is so that
we know which parts of the latter mapping to nuke when this
object is removed from the system. */
char** symbols;
int n_symbols;
/* ptr to malloc'd lump of memory holding the obj file */
void* image;
/* Fixup area for long-distance jumps. */
char* fixup;
int fixup_used;
int fixup_size;
/* The section-kind entries for this object module. Linked
list. */
Section* sections;
/* A private hash table for local symbols. */
/* HashTable* */ void* lochash;
/* Allow a chain of these things */
struct _ObjectCode * next;
/* SANITY CHECK ONLY: a list of the only memory regions which may
safely be prodded during relocation. Any attempt to prod
outside one of these is an error in the linker. */
ProddableBlock* proddables;
} ObjectCode;
/*
* Define a set of types which can be used for both ELF32 and ELF64
*/
#ifdef ELF_64BIT
#define ELFCLASS ELFCLASS64
#define Elf_Addr Elf64_Addr
#define Elf_Word Elf64_Word
#define Elf_Sword Elf64_Sword
#define Elf_Ehdr Elf64_Ehdr
#define Elf_Phdr Elf64_Phdr
#define Elf_Shdr Elf64_Shdr
#define Elf_Sym Elf64_Sym
#define Elf_Rel Elf64_Rel
#define Elf_Rela Elf64_Rela
#define ELF_ST_TYPE ELF64_ST_TYPE
#define ELF_ST_BIND ELF64_ST_BIND
#define ELF_R_TYPE ELF64_R_TYPE
#define ELF_R_SYM ELF64_R_SYM
#else
#define ELFCLASS ELFCLASS32
#define Elf_Addr Elf32_Addr
#define Elf_Word Elf32_Word
#define Elf_Sword Elf32_Sword
#define Elf_Ehdr Elf32_Ehdr
#define Elf_Phdr Elf32_Phdr
#define Elf_Shdr Elf32_Shdr
#define Elf_Sym Elf32_Sym
#define Elf_Rel Elf32_Rel
#define Elf_Rela Elf32_Rela
#ifndef ELF_ST_TYPE
#define ELF_ST_TYPE ELF32_ST_TYPE
#endif
#ifndef ELF_ST_BIND
#define ELF_ST_BIND ELF32_ST_BIND
#endif
#ifndef ELF_R_TYPE
#define ELF_R_TYPE ELF32_R_TYPE
#endif
#ifndef ELF_R_SYM
#define ELF_R_SYM ELF32_R_SYM
#endif
#endif
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
//
// PARANOIA
/* -----------------------------------------------------------------------
* Sanity checking. For each ObjectCode, maintain a list of address ranges
* which may be prodded during relocation, and abort if we try and write
* outside any of these.
*/
static void addProddableBlock ( ObjectCode* oc, void* start, int size )
{
ProddableBlock* pb
= malloc(sizeof(ProddableBlock));
if (debug_linker)
fprintf(stderr, "aPB oc=%p %p %d (%p .. %p)\n", oc, start, size,
start, ((char*)start)+size-1 );
assert(size > 0);
pb->start = start;
pb->size = size;
pb->next = oc->proddables;
oc->proddables = pb;
}
static void checkProddableBlock ( ObjectCode* oc, void* addr )
{
ProddableBlock* pb;
for (pb = oc->proddables; pb != NULL; pb = pb->next) {
char* s = (char*)(pb->start);
char* e = s + pb->size - 1;
char* a = (char*)addr;
/* Assumes that the biggest fixup involves a 4-byte write. This
probably needs to be changed to 8 (ie, +7) on 64-bit
plats. */
if (a >= s && (a+3) <= e) return;
}
fprintf(stderr,
"checkProddableBlock: invalid fixup %p in runtime linker\n",
addr);
exit(1);
}
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
//
// String->Addr mappings
typedef
struct { char* mp_name; void* mp_addr; }
Maplet;
typedef
struct {
int sm_size;
int sm_used;
Maplet* maplets;
}
StringMap;
static StringMap* new_StringMap ( void )
{
StringMap* sm = malloc(sizeof(StringMap));
sm->sm_size = 10;
sm->sm_used = 0;
sm->maplets = malloc(10 * sizeof(Maplet));
return sm;
}
static void delete_StringMap ( StringMap* sm )
{
assert(sm->maplets != NULL);
free(sm->maplets);
sm->maplets = NULL;
free(sm);
}
static void ensure_StringMap ( StringMap* sm )
{
int i;
Maplet* mp2;
assert(sm->maplets != NULL);
if (sm->sm_used < sm->sm_size)
return;
sm->sm_size *= 2;
mp2 = malloc(sm->sm_size * sizeof(Maplet));
for (i = 0; i < sm->sm_used; i++)
mp2[i] = sm->maplets[i];
free(sm->maplets);
sm->maplets = mp2;
}
static void* search_StringMap ( StringMap* sm, char* name )
{
int i;
for (i = 0; i < sm->sm_used; i++)
if (0 == strcmp(name, sm->maplets[i].mp_name))
return sm->maplets[i].mp_addr;
return NULL;
}
static void addto_StringMap ( StringMap* sm, char* name, void* addr )
{
ensure_StringMap(sm);
sm->maplets[sm->sm_used].mp_name = name;
sm->maplets[sm->sm_used].mp_addr = addr;
sm->sm_used++;
}
static void paranoid_addto_StringMap ( StringMap* sm, char* name, void* addr )
{
if (search_StringMap(sm,name) != NULL) {
fprintf(stderr, "paranoid_addto_StringMap(%s,%p)\n", name, addr);
exit(1);
}
addto_StringMap(sm,name,addr);
}
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
//
// Top-level linker control.
StringMap* global_symbol_table = NULL;
ObjectCode* global_object_list = NULL;
static void initLinker ( void )
{
if (global_symbol_table != NULL)
return;
global_symbol_table = new_StringMap();
}
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
//
// SYMBOL TABLE(s)
/* -----------------------------------------------------------------
* lookup a symbol in the global symbol table
*/
static
void * lookupSymbol( char *lbl )
{
void *val;
initLinker() ;
assert(global_symbol_table != NULL);
val = search_StringMap(global_symbol_table, lbl);
return val;
}
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
//
// HELPERS
/*
* Generic ELF functions
*/
static char *
findElfSection ( void* objImage, Elf_Word sh_type )
{
char* ehdrC = (char*)objImage;
Elf_Ehdr* ehdr = (Elf_Ehdr*)ehdrC;
Elf_Shdr* shdr = (Elf_Shdr*)(ehdrC + ehdr->e_shoff);
char* sh_strtab = ehdrC + shdr[ehdr->e_shstrndx].sh_offset;
char* ptr = NULL;
int i;
for (i = 0; i < ehdr->e_shnum; i++) {
if (shdr[i].sh_type == sh_type
/* Ignore the section header's string table. */
&& i != ehdr->e_shstrndx
/* Ignore string tables named .stabstr, as they contain
debugging info. */
&& 0 != memcmp(".stabstr", sh_strtab + shdr[i].sh_name, 8)
) {
ptr = ehdrC + shdr[i].sh_offset;
break;
}
}
return ptr;
}
#ifdef arm_TARGET_ARCH
static
char* alloc_fixup_bytes ( ObjectCode* oc, int nbytes )
{
char* res;
assert(nbytes % 4 == 0);
assert(nbytes > 0);
res = &(oc->fixup[oc->fixup_used]);
oc->fixup_used += nbytes;
if (oc->fixup_used >= oc->fixup_size) {
fprintf(stderr, "fixup area too small for %s\n", oc->fileName);
exit(1);
}
return res;
}
#endif
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
//
// RESOLVE
static
void* lookup_magic_hacks ( char* sym )
{
if (0==strcmp(sym, "printf")) return (void*)(&printf);
return NULL;
}
#ifdef arm_TARGET_ARCH
static
void arm_notify_new_code ( char* start, int length )
{
__asm __volatile ("mov r1, %0\n\t"
"mov r2, %1\n\t"
"mov r3, %2\n\t"
"swi 0x9f0002\n\t"
:
: "ir" (start), "ir" (length), "ir" (0) );
}
static
void gen_armle_goto ( char* fixup, char* dstP )
{
Elf_Word w = (Elf_Word)dstP;
/*
2 .text
3 0000 04F01FE5 ldr pc, value
4 0004 44332211 value: .word 0x11223344
*/
fprintf(stderr,"at %p generating jump to %p\n", fixup, dstP );
fixup[0] = 0x04; fixup[1] = 0xF0; fixup[2] = 0x1F; fixup[3] = 0xE5;
fixup[4] = w & 0xFF; w >>= 8;
fixup[5] = w & 0xFF; w >>= 8;
fixup[6] = w & 0xFF; w >>= 8;
fixup[7] = w & 0xFF; w >>= 8;
arm_notify_new_code(fixup, 8);
}
#endif /* arm_TARGET_ARCH */
/* Do ELF relocations which lack an explicit addend. All x86-linux
relocations appear to be of this form. */
static int
do_Elf_Rel_relocations ( ObjectCode* oc, char* ehdrC,
Elf_Shdr* shdr, int shnum,
Elf_Sym* stab, char* strtab )
{
int j;
char *symbol = NULL;
Elf_Word* targ;
Elf_Rel* rtab = (Elf_Rel*) (ehdrC + shdr[shnum].sh_offset);
int nent = shdr[shnum].sh_size / sizeof(Elf_Rel);
int target_shndx = shdr[shnum].sh_info;
int symtab_shndx = shdr[shnum].sh_link;
stab = (Elf_Sym*) (ehdrC + shdr[ symtab_shndx ].sh_offset);
targ = (Elf_Word*)(ehdrC + shdr[ target_shndx ].sh_offset);
IF_DEBUG(linker,belch( "relocations for section %d using symtab %d",
target_shndx, symtab_shndx ));
for (j = 0; j < nent; j++) {
Elf_Addr offset = rtab[j].r_offset;
Elf_Addr info = rtab[j].r_info;
Elf_Addr P = ((Elf_Addr)targ) + offset;
Elf_Word* pP = (Elf_Word*)P;
Elf_Addr A = *pP;
Elf_Addr S;
Elf_Addr value;
IF_DEBUG(linker,belch( "Rel entry %3d is raw(%6p %6p)",
j, (void*)offset, (void*)info ));
if (!info) {
IF_DEBUG(linker,belch( " ZERO" ));
S = 0;
} else {
Elf_Sym sym = stab[ELF_R_SYM(info)];
/* First see if it is a local symbol. */
if (ELF_ST_BIND(sym.st_info) == STB_LOCAL) {
/* Yes, so we can get the address directly from the ELF symbol
table. */
symbol = sym.st_name==0 ? "(noname)" : strtab+sym.st_name;
S = (Elf_Addr)
(ehdrC + shdr[ sym.st_shndx ].sh_offset
+ stab[ELF_R_SYM(info)].st_value);
} else {
/* No, so look up the name in our global table. */
symbol = strtab + sym.st_name;
S = (Elf_Addr)lookupSymbol( symbol );
}
if (!S) {
S = (Elf_Addr)lookup_magic_hacks(symbol);
}
if (!S) {
fprintf(stderr,"%s: unknown symbol `%s'\n",
oc->fileName, symbol);
return 0;
}
if (debug_linker>1)
fprintf(stderr, "\n`%s' resolves to %p\n", symbol, (void*)S );
}
if (debug_linker>1)
fprintf(stderr, "Reloc: P = %p S = %p A = %p\n",
(void*)P, (void*)S, (void*)A );
checkProddableBlock ( oc, pP );
value = S + A;
switch (ELF_R_TYPE(info)) {
# ifdef i386_TARGET_ARCH
case R_386_32: *pP = value; break;
case R_386_PC32: *pP = value - P; break;
# endif
# ifdef arm_TARGET_ARCH
case R_ARM_PC24: {
Elf_Word w, delta, deltaTop8;
/* Generate a jump sequence into the fixup area
and branch to that instead. */
char* fixup = alloc_fixup_bytes(oc, 8);
/* First of all, figure out where we're really trying to
jump to. */
// compensate for pc+8 bias
Elf_Word real_dst = (A & 0x00FFFFFF) + 2;
// sign-extend 24-to-32 of real_dst
if (real_dst & 0x00800000)
real_dst |= 0xFF000000;
else
real_dst &= 0x00FFFFFF;
real_dst <<= 2;
real_dst += S;
gen_armle_goto(fixup, (char*)real_dst);
/* Delta is in bytes .. */
delta = (((Elf_Word)fixup) - ((Elf_Word)pP) - 8);
deltaTop8 = (delta >> 24) & 0xFF;
if (deltaTop8 != 0 && deltaTop8 != 0xFF) {
fprintf(stderr,"R_ARM_PC24: out of range delta 0x%x for %s\n",
delta, symbol);
exit(1);
}
delta >>= 2;
w = *pP;
w &= 0xFF000000;
w |= (0x00FFFFFF & delta );
*pP = w;
break;
}
case R_ARM_ABS32:
*pP = value;
break;
# endif
default:
fprintf(stderr,
"%s: unhandled ELF relocation(Rel) type %d\n\n",
oc->fileName, ELF_R_TYPE(info));
return 0;
}
}
return 1;
}
/* Do ELF relocations for which explicit addends are supplied.
sparc-solaris relocations appear to be of this form. */
static int
do_Elf_Rela_relocations ( ObjectCode* oc, char* ehdrC,
Elf_Shdr* shdr, int shnum,
Elf_Sym* stab, char* strtab )
{
int j;
char *symbol;
Elf_Addr targ;
Elf_Rela* rtab = (Elf_Rela*) (ehdrC + shdr[shnum].sh_offset);
int nent = shdr[shnum].sh_size / sizeof(Elf_Rela);
int target_shndx = shdr[shnum].sh_info;
int symtab_shndx = shdr[shnum].sh_link;
stab = (Elf_Sym*) (ehdrC + shdr[ symtab_shndx ].sh_offset);
targ = (Elf_Addr) (ehdrC + shdr[ target_shndx ].sh_offset);
IF_DEBUG(linker,belch( "relocations for section %d using symtab %d",
target_shndx, symtab_shndx ));
for (j = 0; j < nent; j++) {
#if defined(DEBUG) || defined(sparc_TARGET_ARCH) || defined(ia64_TARGET_ARCH)
/* This #ifdef only serves to avoid unused-var warnings. */
Elf_Addr offset = rtab[j].r_offset;
Elf_Addr P = targ + offset;
#endif
Elf_Addr info = rtab[j].r_info;
Elf_Addr A = rtab[j].r_addend;
Elf_Addr S;
Elf_Addr value;
# if defined(sparc_TARGET_ARCH)
Elf_Word* pP = (Elf_Word*)P;
Elf_Word w1, w2;
# elif defined(ia64_TARGET_ARCH)
Elf64_Xword *pP = (Elf64_Xword *)P;
Elf_Addr addr;
# endif
IF_DEBUG(linker,belch( "Rel entry %3d is raw(%6p %6p %6p) ",
j, (void*)offset, (void*)info,
(void*)A ));
if (!info) {
IF_DEBUG(linker,belch( " ZERO" ));
S = 0;
} else {
Elf_Sym sym = stab[ELF_R_SYM(info)];
/* First see if it is a local symbol. */
if (ELF_ST_BIND(sym.st_info) == STB_LOCAL) {
/* Yes, so we can get the address directly from the ELF symbol
table. */
symbol = sym.st_name==0 ? "(noname)" : strtab+sym.st_name;
S = (Elf_Addr)
(ehdrC + shdr[ sym.st_shndx ].sh_offset
+ stab[ELF_R_SYM(info)].st_value);
#ifdef ELF_FUNCTION_DESC
/* Make a function descriptor for this function */
if (S && ELF_ST_TYPE(sym.st_info) == STT_FUNC) {
S = allocateFunctionDesc(S + A);
A = 0;
}
#endif
} else {
/* No, so look up the name in our global table. */
symbol = strtab + sym.st_name;
S = (Elf_Addr)lookupSymbol( symbol );
#ifdef ELF_FUNCTION_DESC
/* If a function, already a function descriptor - we would
have to copy it to add an offset. */
if (S && (ELF_ST_TYPE(sym.st_info) == STT_FUNC) && (A != 0))
belch("%s: function %s with addend %p", oc->fileName, symbol, (void *)A);
#endif
}
if (!S) {
fprintf(stderr,"%s: unknown symbol `%s'\n", oc->fileName, symbol);
return 0;
}
IF_DEBUG(linker,belch( "`%s' resolves to %p\n", symbol, (void*)S ));
}
IF_DEBUG(linker,fprintf ( stderr, "Reloc: P = %p S = %p A = %p\n",
(void*)P, (void*)S, (void*)A ));
/* checkProddableBlock ( oc, (void*)P ); */
value = S + A;
switch (ELF_R_TYPE(info)) {
# if defined(sparc_TARGET_ARCH)
case R_SPARC_WDISP30:
w1 = *pP & 0xC0000000;
w2 = (Elf_Word)((value - P) >> 2);
ASSERT((w2 & 0xC0000000) == 0);
w1 |= w2;
*pP = w1;
break;
case R_SPARC_HI22:
w1 = *pP & 0xFFC00000;
w2 = (Elf_Word)(value >> 10);
ASSERT((w2 & 0xFFC00000) == 0);
w1 |= w2;
*pP = w1;
break;
case R_SPARC_LO10:
w1 = *pP & ~0x3FF;
w2 = (Elf_Word)(value & 0x3FF);
ASSERT((w2 & ~0x3FF) == 0);
w1 |= w2;
*pP = w1;
break;
/* According to the Sun documentation:
R_SPARC_UA32
This relocation type resembles R_SPARC_32, except it refers to an
unaligned word. That is, the word to be relocated must be treated
as four separate bytes with arbitrary alignment, not as a word
aligned according to the architecture requirements.
(JRS: which means that freeloading on the R_SPARC_32 case
is probably wrong, but hey ...)
*/
case R_SPARC_UA32:
case R_SPARC_32:
w2 = (Elf_Word)value;
*pP = w2;
break;
# elif defined(ia64_TARGET_ARCH)
case R_IA64_DIR64LSB:
case R_IA64_FPTR64LSB:
*pP = value;
break;
case R_IA64_PCREL64LSB:
*pP = value - P;
break;
case R_IA64_SEGREL64LSB:
addr = findElfSegment(ehdrC, value);
*pP = value - addr;
break;
case R_IA64_GPREL22:
ia64_reloc_gprel22(P, value);
break;
case R_IA64_LTOFF22:
case R_IA64_LTOFF22X:
case R_IA64_LTOFF_FPTR22:
addr = allocateGOTEntry(value);
ia64_reloc_gprel22(P, addr);
break;
case R_IA64_PCREL21B:
ia64_reloc_pcrel21(P, S, oc);
break;
case R_IA64_LDXMOV:
/* This goes with R_IA64_LTOFF22X and points to the load to
* convert into a move. We don't implement relaxation. */
break;
# endif
default:
fprintf(stderr,
"%s: unhandled ELF relocation(RelA) type %d\n",
oc->fileName, ELF_R_TYPE(info));
return 0;
}
}
return 1;
}
static int
ocResolve_ELF ( ObjectCode* oc )
{
char *strtab;
int shnum, ok;
Elf_Sym* stab = NULL;
char* ehdrC = (char*)(oc->image);
Elf_Ehdr* ehdr = (Elf_Ehdr*) ehdrC;
Elf_Shdr* shdr = (Elf_Shdr*) (ehdrC + ehdr->e_shoff);
char* sh_strtab = ehdrC + shdr[ehdr->e_shstrndx].sh_offset;
/* first find "the" symbol table */
stab = (Elf_Sym*) findElfSection ( ehdrC, SHT_SYMTAB );
/* also go find the string table */
strtab = findElfSection ( ehdrC, SHT_STRTAB );
if (stab == NULL || strtab == NULL) {
fprintf(stderr,"%s: can't find string or symbol table\n", oc->fileName);
return 0;
}
/* Process the relocation sections. */
for (shnum = 0; shnum < ehdr->e_shnum; shnum++) {
/* Skip sections called ".rel.stab". These appear to contain
relocation entries that, when done, make the stabs debugging
info point at the right places. We ain't interested in all
dat jazz, mun. */
if (0 == memcmp(".rel.stab", sh_strtab + shdr[shnum].sh_name, 9))
continue;
if (shdr[shnum].sh_type == SHT_REL ) {
ok = do_Elf_Rel_relocations ( oc, ehdrC, shdr,
shnum, stab, strtab );
if (!ok) return ok;
}
else
if (shdr[shnum].sh_type == SHT_RELA) {
ok = do_Elf_Rela_relocations ( oc, ehdrC, shdr,
shnum, stab, strtab );
if (!ok) return ok;
}
}
/* Free the local symbol table; we won't need it again. */
delete_StringMap(oc->lochash);
oc->lochash = NULL;
return 1;
}
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
//
// VERIFY
static int
ocVerifyImage_ELF ( ObjectCode* oc )
{
Elf_Shdr* shdr;
Elf_Sym* stab;
int i, j, nent, nstrtab, nsymtabs;
char* sh_strtab;
char* strtab;
char* ehdrC = (char*)(oc->image);
Elf_Ehdr* ehdr = (Elf_Ehdr*)ehdrC;
if (ehdr->e_ident[EI_MAG0] != ELFMAG0 ||
ehdr->e_ident[EI_MAG1] != ELFMAG1 ||
ehdr->e_ident[EI_MAG2] != ELFMAG2 ||
ehdr->e_ident[EI_MAG3] != ELFMAG3) {
fprintf(stderr,"%s: not an ELF object\n", oc->fileName);
return 0;
}
if (ehdr->e_ident[EI_CLASS] != ELFCLASS) {
fprintf(stderr,"%s: unsupported ELF format\n", oc->fileName);
return 0;
}
if (ehdr->e_ident[EI_DATA] == ELFDATA2LSB) {
if (debug_linker)
fprintf(stderr, "Is little-endian\n" );
} else
if (ehdr->e_ident[EI_DATA] == ELFDATA2MSB) {
if (debug_linker)
fprintf(stderr, "Is big-endian\n" );
} else {
fprintf(stderr,"%s: unknown endiannness\n", oc->fileName);
return 0;
}
if (ehdr->e_type != ET_REL) {
fprintf(stderr,"%s: not a relocatable object (.o) file\n", oc->fileName);
return 0;
}
if (debug_linker)
fprintf(stderr, "Is a relocatable object (.o) file\n" );
if (debug_linker)
fprintf(stderr, "Architecture is " );
switch (ehdr->e_machine) {
case EM_386: if (debug_linker) fprintf(stderr, "x86\n" ); break;
case EM_SPARC: if (debug_linker) fprintf(stderr, "sparc\n" ); break;
case EM_ARM: if (debug_linker) fprintf(stderr, "arm\n" ); break;
#ifdef EM_IA_64
case EM_IA_64: if (debug_linker) fprintf(stderr, "ia64\n" ); break;
#endif
default: if (debug_linker) fprintf(stderr, "unknown\n" );
fprintf(stderr,"%s: unknown architecture\n", oc->fileName);
return 0;
}
if (debug_linker>1) fprintf(stderr,
"\nSection header table: start %d, n_entries %d, ent_size %d\n",
ehdr->e_shoff, ehdr->e_shnum, ehdr->e_shentsize );
assert (ehdr->e_shentsize == sizeof(Elf_Shdr));
shdr = (Elf_Shdr*) (ehdrC + ehdr->e_shoff);
if (ehdr->e_shstrndx == SHN_UNDEF) {
fprintf(stderr,"%s: no section header string table\n", oc->fileName);
return 0;
} else {
if (debug_linker>1)
fprintf(stderr, "Section header string table is section %d\n",
ehdr->e_shstrndx);
sh_strtab = ehdrC + shdr[ehdr->e_shstrndx].sh_offset;
}
for (i = 0; i < ehdr->e_shnum; i++) {
if (debug_linker>1) fprintf(stderr, "%2d: ", i );
if (debug_linker>1) fprintf(stderr, "type=%2d ", (int)shdr[i].sh_type );
if (debug_linker>1) fprintf(stderr, "size=%4d ", (int)shdr[i].sh_size );
if (debug_linker>1) fprintf(stderr, "offs=%4d ", (int)shdr[i].sh_offset );
if (debug_linker>1) fprintf(stderr, " (%p .. %p) ",
ehdrC + shdr[i].sh_offset,
ehdrC + shdr[i].sh_offset + shdr[i].sh_size - 1);
if (shdr[i].sh_type == SHT_REL) {
if (debug_linker>1) fprintf(stderr, "Rel " );
} else if (shdr[i].sh_type == SHT_RELA) {
if (debug_linker>1) fprintf(stderr, "RelA " );
} else {
if (debug_linker>1) fprintf(stderr," ");
}
if (sh_strtab) {
if (debug_linker>1) fprintf(stderr, "sname=%s\n",
sh_strtab + shdr[i].sh_name );
}
}
if (debug_linker>1) fprintf(stderr, "\nString tables\n" );
strtab = NULL;
nstrtab = 0;
for (i = 0; i < ehdr->e_shnum; i++) {
if (shdr[i].sh_type == SHT_STRTAB
/* Ignore the section header's string table. */
&& i != ehdr->e_shstrndx
/* Ignore string tables named .stabstr, as they contain
debugging info. */
&& 0 != memcmp(".stabstr", sh_strtab + shdr[i].sh_name, 8)
) {
if (debug_linker>1)
fprintf(stderr," section %d is a normal string table\n", i );
strtab = ehdrC + shdr[i].sh_offset;
nstrtab++;
}
}
if (nstrtab != 1) {
fprintf(stderr,"%s: no string tables, or too many\n", oc->fileName);
return 0;
}
nsymtabs = 0;
if (debug_linker>1) fprintf(stderr, "\nSymbol tables\n" );
for (i = 0; i < ehdr->e_shnum; i++) {
if (shdr[i].sh_type != SHT_SYMTAB) continue;
if (debug_linker>1) fprintf(stderr, "section %d is a symbol table\n", i );
nsymtabs++;
stab = (Elf_Sym*) (ehdrC + shdr[i].sh_offset);
nent = shdr[i].sh_size / sizeof(Elf_Sym);
if (debug_linker>1) fprintf(stderr,
" number of entries is apparently %d (%d rem)\n",
nent,
shdr[i].sh_size % sizeof(Elf_Sym)
);
if (0 != shdr[i].sh_size % sizeof(Elf_Sym)) {
fprintf(stderr,"%s: non-integral number of symbol table entries\n",
oc->fileName);
return 0;
}
for (j = 0; j < nent; j++) {
if (debug_linker>1) fprintf(stderr, " %2d ", j );
if (debug_linker>1) fprintf(stderr, " sec=%-5d size=%-3d val=%5p ",
(int)stab[j].st_shndx,
(int)stab[j].st_size,
(char*)stab[j].st_value );
if (debug_linker>1) fprintf(stderr, "type=" );
switch (ELF_ST_TYPE(stab[j].st_info)) {
case STT_NOTYPE: if (debug_linker>1) fprintf(stderr, "notype " ); break;
case STT_OBJECT: if (debug_linker>1) fprintf(stderr, "object " ); break;
case STT_FUNC : if (debug_linker>1) fprintf(stderr, "func " ); break;
case STT_SECTION: if (debug_linker>1) fprintf(stderr, "section" ); break;
case STT_FILE: if (debug_linker>1) fprintf(stderr, "file " ); break;
default: if (debug_linker>1) fprintf(stderr, "? " ); break;
}
if (debug_linker>1) fprintf(stderr, " " );
if (debug_linker>1) fprintf(stderr, "bind=" );
switch (ELF_ST_BIND(stab[j].st_info)) {
case STB_LOCAL : if (debug_linker>1) fprintf(stderr, "local " ); break;
case STB_GLOBAL: if (debug_linker>1) fprintf(stderr, "global" ); break;
case STB_WEAK : if (debug_linker>1) fprintf(stderr, "weak " ); break;
default: if (debug_linker>1) fprintf(stderr, "? " ); break;
}
if (debug_linker>1) fprintf(stderr, " " );
if (debug_linker>1) fprintf(stderr, "name=%s\n", strtab + stab[j].st_name );
}
}
if (nsymtabs == 0) {
fprintf(stderr,"%s: didn't find any symbol tables\n", oc->fileName);
return 0;
}
return 1;
}
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
//
// GETNAMES
static int
ocGetNames_ELF ( ObjectCode* oc )
{
int i, j, k, nent;
Elf_Sym* stab;
char* ehdrC = (char*)(oc->image);
Elf_Ehdr* ehdr = (Elf_Ehdr*)ehdrC;
char* strtab = findElfSection ( ehdrC, SHT_STRTAB );
Elf_Shdr* shdr = (Elf_Shdr*) (ehdrC + ehdr->e_shoff);
char* sh_strtab = ehdrC + shdr[ehdr->e_shstrndx].sh_offset;
char* sec_name;
assert(global_symbol_table != NULL);
if (!strtab) {
fprintf(stderr,"%s: no strtab\n", oc->fileName);
return 0;
}
k = 0;
for (i = 0; i < ehdr->e_shnum; i++) {
/* Figure out what kind of section it is. Logic derived from
Figure 1.14 ("Special Sections") of the ELF document
("Portable Formats Specification, Version 1.1"). */
Elf_Shdr hdr = shdr[i];
SectionKind kind = SECTIONKIND_OTHER;
int is_bss = FALSE;
if (hdr.sh_type == SHT_PROGBITS
&& (hdr.sh_flags & SHF_ALLOC) && (hdr.sh_flags & SHF_EXECINSTR)) {
/* .text-style section */
kind = SECTIONKIND_CODE_OR_RODATA;
}
else
if (hdr.sh_type == SHT_PROGBITS
&& (hdr.sh_flags & SHF_ALLOC) && (hdr.sh_flags & SHF_WRITE)) {
/* .data-style section */
kind = SECTIONKIND_RWDATA;
}
else
if (hdr.sh_type == SHT_PROGBITS
&& (hdr.sh_flags & SHF_ALLOC) && !(hdr.sh_flags & SHF_WRITE)) {
/* .rodata-style section */
kind = SECTIONKIND_CODE_OR_RODATA;
}
else
if (hdr.sh_type == SHT_NOBITS
&& (hdr.sh_flags & SHF_ALLOC) && (hdr.sh_flags & SHF_WRITE)) {
/* .bss-style section */
kind = SECTIONKIND_RWDATA;
is_bss = TRUE;
}
if (is_bss && shdr[i].sh_size > 0) {
/* This is a non-empty .bss section. Allocate zeroed space for
it, and set its .sh_offset field such that
ehdrC + .sh_offset == addr_of_zeroed_space. */
char* zspace = calloc(1, shdr[i].sh_size);
shdr[i].sh_offset = ((char*)zspace) - ((char*)ehdrC);
/*
fprintf(stderr, "BSS section at 0x%x, size %d\n",
zspace, shdr[i].sh_size);
*/
}
/* When loading objects compiled with -g, it seems there are
relocations in various debug-info sections. So we'd better
tell addProddableBlock to allow those bits to be prodded. */
//fprintf(stderr, "ZZZZZZZZZZ %s\n", sh_strtab + hdr.sh_name);
sec_name = sh_strtab + shdr[i].sh_name;
if (kind == SECTIONKIND_OTHER
&& (0 == strcmp(".debug_info", sec_name)
|| 0 == strcmp(".debug_line", sec_name)
|| 0 == strcmp(".debug_pubnames", sec_name)
|| 0 == strcmp(".debug_aranges", sec_name)
|| 0 == strcmp(".debug_frame", sec_name))) {
kind = SECTIONKIND_CODE_OR_RODATA;
}
/* fill in the section info */
if (kind != SECTIONKIND_OTHER && shdr[i].sh_size > 0) {
addProddableBlock(oc, ehdrC + shdr[i].sh_offset, shdr[i].sh_size);
//addSection(oc, kind, ehdrC + shdr[i].sh_offset,
// ehdrC + shdr[i].sh_offset + shdr[i].sh_size - 1);
}
if (shdr[i].sh_type != SHT_SYMTAB) continue;
/* copy stuff into this module's object symbol table */
stab = (Elf_Sym*) (ehdrC + shdr[i].sh_offset);
nent = shdr[i].sh_size / sizeof(Elf_Sym);
oc->n_symbols = nent;
oc->symbols = malloc(oc->n_symbols * sizeof(char*));
for (j = 0; j < nent; j++) {
char isLocal = FALSE; /* avoids uninit-var warning */
char* ad = NULL;
char* nm = strtab + stab[j].st_name;
int secno = stab[j].st_shndx;
/* Figure out if we want to add it; if so, set ad to its
address. Otherwise leave ad == NULL. */
if (secno == SHN_COMMON) {
isLocal = FALSE;
ad = calloc(1, stab[j].st_size);
/*
fprintf(stderr, "COMMON symbol, size %d name %s\n",
stab[j].st_size, nm);
*/
/* Pointless to do addProddableBlock() for this area,
since the linker should never poke around in it. */
}
else
if ( ( ELF_ST_BIND(stab[j].st_info)==STB_GLOBAL
|| ELF_ST_BIND(stab[j].st_info)==STB_LOCAL
)
/* and not an undefined symbol */
&& stab[j].st_shndx != SHN_UNDEF
/* and not in a "special section" */
&& stab[j].st_shndx < SHN_LORESERVE
&&
/* and it's a not a section or string table or anything silly */
( ELF_ST_TYPE(stab[j].st_info)==STT_FUNC ||
ELF_ST_TYPE(stab[j].st_info)==STT_OBJECT ||
ELF_ST_TYPE(stab[j].st_info)==STT_NOTYPE
)
) {
/* Section 0 is the undefined section, hence > and not >=. */
assert(secno > 0 && secno < ehdr->e_shnum);
/*
if (shdr[secno].sh_type == SHT_NOBITS) {
fprintf(stderr, " BSS symbol, size %d off %d name %s\n",
stab[j].st_size, stab[j].st_value, nm);
}
*/
ad = ehdrC + shdr[ secno ].sh_offset + stab[j].st_value;
if (ELF_ST_BIND(stab[j].st_info)==STB_LOCAL) {
isLocal = TRUE;
} else {
#ifdef ELF_FUNCTION_DESC
/* dlsym() and the initialisation table both give us function
* descriptors, so to be consistent we store function descriptors
* in the symbol table */
if (ELF_ST_TYPE(stab[j].st_info) == STT_FUNC)
ad = (char *)allocateFunctionDesc((Elf_Addr)ad);
#endif
if (debug_linker)
fprintf(stderr, "addOTabName(GLOB): %10p %s %s\n",
ad, oc->fileName, nm );
isLocal = FALSE;
}
}
/* And the decision is ... */
if (ad != NULL) {
assert(nm != NULL);
oc->symbols[j] = nm;
/* Acquire! */
if (isLocal) {
/* Ignore entirely. */
} else {
//ghciInsertStrHashTable(oc->fileName, global_symbol_table, nm, ad);
paranoid_addto_StringMap(global_symbol_table, nm, ad);
}
} else {
/* Skip. */
if (debug_linker>1) fprintf(stderr, "skipping `%s'\n",
strtab + stab[j].st_name );
/*
fprintf(stderr,
"skipping bind = %d, type = %d, shndx = %d `%s'\n",
(int)ELF_ST_BIND(stab[j].st_info),
(int)ELF_ST_TYPE(stab[j].st_info),
(int)stab[j].st_shndx,
strtab + stab[j].st_name
);
*/
oc->symbols[j] = NULL;
}
}
}
return 1;
}
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
//
// TOP-LEVEL CONTROL OF THE LINKER
/* ---------------------------------------------------------------------
* Load an obj (populate the global symbol table, but don't resolve yet)
*
* Returns: 1 if ok, 0 on error.
*/
static
int loadObj( char *path )
{
ObjectCode* oc;
struct stat st;
int r;
int fd, pagesize;
char* p;
initLinker();
fprintf(stderr, "==== loadObj %s ====\n", path );
/* Check that we haven't already loaded this object. */
{
ObjectCode *o;
int is_dup = 0;
for (o = global_object_list; o; o = o->next) {
if (0 == strcmp(o->fileName, path))
is_dup = 1;
}
if (is_dup) {
fprintf(stderr,
"\n\n"
"GHCi runtime linker: warning: looks like you're trying to load the\n"
"same object file twice:\n"
" %s\n"
, path);
exit(1);
}
}
oc = malloc(sizeof(ObjectCode));
oc->formatName = "ELF";
r = stat(path, &st);
if (r == -1) { return 0; }
/* sigh, strdup() isn't a POSIX function, so do it the long way */
oc->fileName = malloc( strlen(path)+1 );
strcpy(oc->fileName, path);
oc->fileSize = st.st_size;
oc->symbols = NULL;
oc->sections = NULL;
oc->lochash = new_StringMap();
oc->proddables = NULL;
oc->fixup = NULL;
oc->fixup_used = 0;
oc->fixup_size = 0;
/* chain it onto the list of objects */
oc->next = global_object_list;
global_object_list = oc;
fd = open(path, O_RDONLY);
if (fd == -1) {
fprintf(stderr,"loadObj: can't open `%s'\n", path);
exit(1);
}
/* Allocate a 1-page area just prior to the image, so we can put
fixup code fragments there. Used for doing R_ARM_PC24
relocations for jump distances > 64M. */
pagesize = getpagesize();
p = memalign(pagesize, N_FIXUP_PAGES * pagesize
+ oc->fileSize);
if (p == NULL) {
fprintf(stderr,"loadObj: failed to allocate space for `%s'\n", path);
exit(1);
}
oc->fixup = p;
oc->fixup_size = N_FIXUP_PAGES * pagesize;
oc->fixup_used = 0;
oc->image = &(p[ oc->fixup_size ]);
r = read(fd, oc->image, oc->fileSize);
if (r != oc->fileSize) {
fprintf(stderr,"loadObj: failed to read `%s'\n", path);
exit(1);
}
fprintf(stderr, "loaded %s at %p (fixup = %p)\n",
oc->fileName, oc->image, oc->fixup );
close(fd);
/* verify the in-memory image */
r = ocVerifyImage_ELF ( oc );
if (!r) { return r; }
/* build the symbol list for this image */
r = ocGetNames_ELF ( oc );
if (!r) { return r; }
/* loaded, but not resolved yet */
oc->status = OBJECT_LOADED;
return 1;
}
/* ---------------------------------------------------------------------------
* resolve all the currently unlinked objects in memory
*
* Returns: 1 if ok, 0 on error.
*/
static
int resolveObjs( void )
{
ObjectCode *oc;
int r;
initLinker();
for (oc = global_object_list; oc; oc = oc->next) {
if (oc->status != OBJECT_RESOLVED) {
r = ocResolve_ELF ( oc );
if (!r) { return r; }
oc->status = OBJECT_RESOLVED;
}
}
return 1;
}
/* ---------------------------------------------------------------------------
* Top-level linker.
*/
/* Load and link a bunch of .o's, and return the address of
'main'. Or NULL if something borks.
*/
void* linker_top_level_LINK ( int n_object_names, char** object_names )
{
int r, i;
void* mainp;
initLinker();
for (i = 0; i < n_object_names; i++) {
//fprintf(stderr, "linkloop %d %s\n", i, object_names[i] );
r = loadObj( object_names[i] );
if (r != 1) return NULL;
}
r = resolveObjs();
if (r != 1) return NULL;
mainp = search_StringMap ( global_symbol_table, "main" );
if (mainp == NULL) return NULL;
printf("Linker: success!\n");
return mainp;
}
#if 1
int main ( int argc, char** argv )
{
void* mainp;
linker_top_level_LINK( argc - 1 , &argv[1]);
/* find and run "main" */
mainp = search_StringMap ( global_symbol_table, "main" );
if (mainp == NULL) {
fprintf(stderr, "no binding for main\n");
exit(1);
}
printf("\nSTARTING PROGRAM\n");
( (int(*)(int,char**)) mainp ) (argc,argv);
printf("FINISHED\n");
return 0;
}
#endif
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
//
// VIRTUAL MACHINE ...
/* --------------------------------------------------------- */
/* SIMULATED STATE */
/* --------------------------------------------------------- */
typedef unsigned int Word;
/* Stack for the simulation */
Word* sim_stack;
/* Stop when we get a jump to here. */
char* stop_at;
/* ARM state */
/* r0 .. r15, flags */
Word regs_arm[16+1];
#define REG_PC 15
#define REG_SP 14
//---------------------------------------------
/* Calling convention: enter the translation with r0 pointing at
regs_arm. Translation may trash r1 .. r12 inclusive. Translation
should update all regs in regs_arm, and put the next pc value
in regs_arm[REG_PC]. */
static
void run_translation ( char* trans, char* baseblock )
{
/* r0 holds trans */
__asm __volatile
("stmfd sp!, {r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13}\n\t"
"mov r12, %0\n\t"
"mov r0, %1\n\t"
"bl r12\n\t"
"ldmea sp!, {r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13}\n\t"
:
: "ir" (trans), "ir" (baseblock) );
}
/* Called by Haskell to initialise the simulated machine. The
supplied address is the entry point of some procedure to call. */
/* EXPORTED */
void initialise_machine ( char* first_pc )
{
static char start[12];
Word w = (Word)first_pc;
n_transtab_used = 0;
sim_stack = malloc(10000 * sizeof(Word));
regs_arm[REG_SP] = (Word)(&sim_stack[9999]);
regs_arm[REG_PC] = (Word)first_pc;
/* Generate this. Note, we'll be returning directly to the
data, so the JIT must stop at this point! */
/*
3 0000 00C09FE5 ldr ip, value
4 0004 FEFFFFEB bl ip
5 value:
6 0008 44332211 .word 0x11223344
*/
start[0] = 0x00; start[1] = 0xC0; start[2] = 0x9F; start[3] = 0xE5;
start[4] = 0xFE; start[5] = 0xFF; start[6] = 0xFF; start[7] = 0xEB;
start[8] = w & 0xFF; w >>= 8;
start[9] = w & 0xFF; w >>= 8;
start[10] = w & 0xFF; w >>= 8;
start[11] = w & 0xFF; w >>= 8;
stop_at = &start[8];
arm_notify_new_code(stop_at, 12);
}