andrius
/
tinycc
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Introduce ElfW macro and ELFW to encapsulate the difference between Elf32_* and Elf64_*. Also, introduce ElfW_Rel and SHT_RELX for difference between REL and RELA.

This commit is contained in:
Shinichiro Hamaji 2008-11-30 08:14:07 +09:00 committed by grischka
parent 76b02c2a03
commit 7dd792ef51
3 changed files with 198 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
elf.h
View File

@ -1630,4 +1630,14 @@ typedef Elf32_Addr Elf32_Conflict;
#define R_C60HI16 0x55 // high 16 bit MVKH embedded
#define R_C60LO16 0x54 // low 16 bit MVKL embedded
#ifdef TCC_TARGET_X86_64
#define TCC_ELFCLASS ELFCLASS64
#define ElfW(type) Elf##64##_##type
#define ELFW(type) ELF##64##_##type
#else
#define TCC_ELFCLASS ELFCLASS32
#define ElfW(type) Elf##32##_##type
#define ELFW(type) ELF##32##_##type
#endif
#endif /* elf.h */

29
tcc.c
View File

@ -1261,6 +1261,7 @@ Section *new_section(TCCState *s1, const char *name, int sh_type, int sh_flags)
switch(sh_type) {
case SHT_HASH:
case SHT_REL:
case SHT_RELA:
case SHT_DYNSYM:
case SHT_SYMTAB:
case SHT_DYNAMIC:
@ -1349,7 +1350,7 @@ static void put_extern_sym2(Sym *sym, Section *section,
int can_add_underscore)
{
int sym_type, sym_bind, sh_num, info, other, attr;
Elf32_Sym *esym;
ElfW(Sym) *esym;
const char *name;
char buf1[256];
@ -1424,10 +1425,10 @@ static void put_extern_sym2(Sym *sym, Section *section,
pstrcpy(buf1 + 1, sizeof(buf1) - 1, name);
name = buf1;
}
info = ELF32_ST_INFO(sym_bind, sym_type);
info = ELFW(ST_INFO)(sym_bind, sym_type);
sym->c = add_elf_sym(symtab_section, value, size, info, other, sh_num, name);
} else {
esym = &((Elf32_Sym *)symtab_section->data)[sym->c];
esym = &((ElfW(Sym) *)symtab_section->data)[sym->c];
esym->st_value = value;
esym->st_size = size;
esym->st_shndx = sh_num;
@ -9140,11 +9141,11 @@ static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r,
if (sec) {
put_extern_sym(sym, sec, addr, size);
} else {
Elf32_Sym *esym;
ElfW(Sym) *esym;
/* put a common area */
put_extern_sym(sym, NULL, align, size);
/* XXX: find a nicer way */
esym = &((Elf32_Sym *)symtab_section->data)[sym->c];
esym = &((ElfW(Sym) *)symtab_section->data)[sym->c];
esym->st_shndx = SHN_COMMON;
}
} else {
@ -9270,7 +9271,7 @@ static void gen_function(Sym *sym)
sym_pop(&local_stack, NULL); /* reset local stack */
/* end of function */
/* patch symbol size */
((Elf32_Sym *)symtab_section->data)[sym->c].st_size =
((ElfW(Sym) *)symtab_section->data)[sym->c].st_size =
ind - func_ind;
if (do_debug) {
put_stabn(N_FUN, 0, 0, ind - func_ind);
@ -9552,7 +9553,7 @@ static int tcc_compile(TCCState *s1)
section_sym = 0; /* avoid warning */
if (do_debug) {
section_sym = put_elf_sym(symtab_section, 0, 0,
ELF32_ST_INFO(STB_LOCAL, STT_SECTION), 0,
ELFW(ST_INFO)(STB_LOCAL, STT_SECTION), 0,
text_section->sh_num, NULL);
getcwd(buf, sizeof(buf));
#ifdef _WIN32
@ -9567,7 +9568,7 @@ static int tcc_compile(TCCState *s1)
/* an elf symbol of type STT_FILE must be put so that STB_LOCAL
symbols can be safely used */
put_elf_sym(symtab_section, 0, 0,
ELF32_ST_INFO(STB_LOCAL, STT_FILE), 0,
ELFW(ST_INFO)(STB_LOCAL, STT_FILE), 0,
SHN_ABS, file->filename);
/* define some often used types */
@ -9872,14 +9873,14 @@ static void rt_printline(unsigned long wanted_pc)
/* second pass: we try symtab symbols (no line number info) */
incl_index = 0;
{
Elf32_Sym *sym, *sym_end;
ElfW(Sym) *sym, *sym_end;
int type;
sym_end = (Elf32_Sym *)(symtab_section->data + symtab_section->data_offset);
for(sym = (Elf32_Sym *)symtab_section->data + 1;
sym_end = (ElfW(Sym) *)(symtab_section->data + symtab_section->data_offset);
for(sym = (ElfW(Sym) *)symtab_section->data + 1;
sym < sym_end;
sym++) {
type = ELF32_ST_TYPE(sym->st_info);
type = ELFW(ST_TYPE)(sym->st_info);
if (type == STT_FUNC) {
if (wanted_pc >= sym->st_value &&
wanted_pc < sym->st_value + sym->st_size) {
@ -10329,7 +10330,7 @@ int tcc_add_sysinclude_path(TCCState *s1, const char *pathname)
static int tcc_add_file_internal(TCCState *s1, const char *filename, int flags)
{
const char *ext;
Elf32_Ehdr ehdr;
ElfW(Ehdr) ehdr;
int fd, ret;
BufferedFile *saved_file;
@ -10502,7 +10503,7 @@ int tcc_add_library(TCCState *s, const char *libraryname)
int tcc_add_symbol(TCCState *s, const char *name, unsigned long val)
{
add_elf_sym(symtab_section, val, 0,
ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0,
ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
SHN_ABS, name);
return 0;
}

336
tccelf.c
View File

@ -18,6 +18,16 @@
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifdef TCC_TARGET_X86_64
#define ElfW_Rel ElfW(Rela)
#define SHT_RELX SHT_RELA
#define REL_SECTION_FMT ".rela%s"
#else
#define ElfW_Rel ElfW(Rel)
#define SHT_RELX SHT_REL
#define REL_SECTION_FMT ".rel%s"
#endif
static int put_elf_str(Section *s, const char *sym)
{
int offset, len;
@ -49,12 +59,12 @@ static unsigned long elf_hash(const unsigned char *name)
/* NOTE: we do factorize the hash table code to go faster */
static void rebuild_hash(Section *s, unsigned int nb_buckets)
{
Elf32_Sym *sym;
ElfW(Sym) *sym;
int *ptr, *hash, nb_syms, sym_index, h;
char *strtab;
strtab = s->link->data;
nb_syms = s->data_offset / sizeof(Elf32_Sym);
nb_syms = s->data_offset / sizeof(ElfW(Sym));
s->hash->data_offset = 0;
ptr = section_ptr_add(s->hash, (2 + nb_buckets + nb_syms) * sizeof(int));
@ -65,9 +75,9 @@ static void rebuild_hash(Section *s, unsigned int nb_buckets)
memset(hash, 0, (nb_buckets + 1) * sizeof(int));
ptr += nb_buckets + 1;
sym = (Elf32_Sym *)s->data + 1;
sym = (ElfW(Sym) *)s->data + 1;
for(sym_index = 1; sym_index < nb_syms; sym_index++) {
if (ELF32_ST_BIND(sym->st_info) != STB_LOCAL) {
if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
h = elf_hash(strtab + sym->st_name) % nb_buckets;
*ptr = hash[h];
hash[h] = sym_index;
@ -86,10 +96,10 @@ static int put_elf_sym(Section *s,
{
int name_offset, sym_index;
int nbuckets, h;
Elf32_Sym *sym;
ElfW(Sym) *sym;
Section *hs;
sym = section_ptr_add(s, sizeof(Elf32_Sym));
sym = section_ptr_add(s, sizeof(ElfW(Sym)));
if (name)
name_offset = put_elf_str(s->link, name);
else
@ -101,14 +111,14 @@ static int put_elf_sym(Section *s,
sym->st_info = info;
sym->st_other = other;
sym->st_shndx = shndx;
sym_index = sym - (Elf32_Sym *)s->data;
sym_index = sym - (ElfW(Sym) *)s->data;
hs = s->hash;
if (hs) {
int *ptr, *base;
ptr = section_ptr_add(hs, sizeof(int));
base = (int *)hs->data;
/* only add global or weak symbols */
if (ELF32_ST_BIND(info) != STB_LOCAL) {
if (ELFW(ST_BIND)(info) != STB_LOCAL) {
/* add another hashing entry */
nbuckets = base[0];
h = elf_hash(name) % nbuckets;
@ -132,7 +142,7 @@ static int put_elf_sym(Section *s,
found. */
static int find_elf_sym(Section *s, const char *name)
{
Elf32_Sym *sym;
ElfW(Sym) *sym;
Section *hs;
int nbuckets, sym_index, h;
const char *name1;
@ -144,7 +154,7 @@ static int find_elf_sym(Section *s, const char *name)
h = elf_hash(name) % nbuckets;
sym_index = ((int *)hs->data)[2 + h];
while (sym_index != 0) {
sym = &((Elf32_Sym *)s->data)[sym_index];
sym = &((ElfW(Sym) *)s->data)[sym_index];
name1 = s->link->data + sym->st_name;
if (!strcmp(name, name1))
return sym_index;
@ -157,12 +167,12 @@ static int find_elf_sym(Section *s, const char *name)
int tcc_get_symbol(TCCState *s, unsigned long *pval, const char *name)
{
int sym_index;
Elf32_Sym *sym;
ElfW(Sym) *sym;
sym_index = find_elf_sym(symtab_section, name);
if (!sym_index)
return -1;
sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
*pval = sym->st_value;
return 0;
}
@ -180,25 +190,25 @@ void *tcc_get_symbol_err(TCCState *s, const char *name)
static int add_elf_sym(Section *s, unsigned long value, unsigned long size,
int info, int other, int sh_num, const char *name)
{
Elf32_Sym *esym;
ElfW(Sym) *esym;
int sym_bind, sym_index, sym_type, esym_bind;
unsigned char sym_vis, esym_vis, new_vis;
sym_bind = ELF32_ST_BIND(info);
sym_type = ELF32_ST_TYPE(info);
sym_vis = ELF32_ST_VISIBILITY(other);
sym_bind = ELFW(ST_BIND)(info);
sym_type = ELFW(ST_TYPE)(info);
sym_vis = ELFW(ST_VISIBILITY)(other);
if (sym_bind != STB_LOCAL) {
/* we search global or weak symbols */
sym_index = find_elf_sym(s, name);
if (!sym_index)
goto do_def;
esym = &((Elf32_Sym *)s->data)[sym_index];
esym = &((ElfW(Sym) *)s->data)[sym_index];
if (esym->st_shndx != SHN_UNDEF) {
esym_bind = ELF32_ST_BIND(esym->st_info);
esym_bind = ELFW(ST_BIND)(esym->st_info);
/* propagate the most constraining visibility */
/* STV_DEFAULT(0)<STV_PROTECTED(3)<STV_HIDDEN(2)<STV_INTERNAL(1) */
esym_vis = ELF32_ST_VISIBILITY(esym->st_other);
esym_vis = ELFW(ST_VISIBILITY)(esym->st_other);
if (esym_vis == STV_DEFAULT) {
new_vis = sym_vis;
} else if (sym_vis == STV_DEFAULT) {
@ -206,7 +216,7 @@ static int add_elf_sym(Section *s, unsigned long value, unsigned long size,
} else {
new_vis = (esym_vis < sym_vis) ? esym_vis : sym_vis;
}
esym->st_other = (esym->st_other & ~ELF32_ST_VISIBILITY(-1))
esym->st_other = (esym->st_other & ~ELFW(ST_VISIBILITY)(-1))
| new_vis;
other = esym->st_other; /* in case we have to patch esym */
if (sh_num == SHN_UNDEF) {
@ -234,7 +244,7 @@ static int add_elf_sym(Section *s, unsigned long value, unsigned long size,
}
} else {
do_patch:
esym->st_info = ELF32_ST_INFO(sym_bind, sym_type);
esym->st_info = ELFW(ST_INFO)(sym_bind, sym_type);
esym->st_shndx = sh_num;
esym->st_value = value;
esym->st_size = size;
@ -243,7 +253,7 @@ static int add_elf_sym(Section *s, unsigned long value, unsigned long size,
} else {
do_def:
sym_index = put_elf_sym(s, value, size,
ELF32_ST_INFO(sym_bind, sym_type), other,
ELFW(ST_INFO)(sym_bind, sym_type), other,
sh_num, name);
}
return sym_index;
@ -255,7 +265,7 @@ static void put_elf_reloc(Section *symtab, Section *s, unsigned long offset,
{
char buf[256];
Section *sr;
Elf32_Rel *rel;
ElfW_Rel *rel;
sr = s->reloc;
if (!sr) {
@ -263,15 +273,15 @@ static void put_elf_reloc(Section *symtab, Section *s, unsigned long offset,
snprintf(buf, sizeof(buf), ".rel%s", s->name);
/* if the symtab is allocated, then we consider the relocation
are also */
sr = new_section(tcc_state, buf, SHT_REL, symtab->sh_flags);
sr->sh_entsize = sizeof(Elf32_Rel);
sr = new_section(tcc_state, buf, SHT_RELX, symtab->sh_flags);
sr->sh_entsize = sizeof(ElfW_Rel);
sr->link = symtab;
sr->sh_info = s->sh_num;
s->reloc = sr;
}
rel = section_ptr_add(sr, sizeof(Elf32_Rel));
rel = section_ptr_add(sr, sizeof(ElfW_Rel));
rel->r_offset = offset;
rel->r_info = ELF32_R_INFO(symbol, type);
rel->r_info = ELFW(R_INFO)(symbol, type);
}
/* put stab debug information */
@ -327,22 +337,22 @@ static void put_stabd(int type, int other, int desc)
static void sort_syms(TCCState *s1, Section *s)
{
int *old_to_new_syms;
Elf32_Sym *new_syms;
ElfW(Sym) *new_syms;
int nb_syms, i;
Elf32_Sym *p, *q;
Elf32_Rel *rel, *rel_end;
ElfW(Sym) *p, *q;
ElfW_Rel *rel, *rel_end;
Section *sr;
int type, sym_index;
nb_syms = s->data_offset / sizeof(Elf32_Sym);
new_syms = tcc_malloc(nb_syms * sizeof(Elf32_Sym));
nb_syms = s->data_offset / sizeof(ElfW(Sym));
new_syms = tcc_malloc(nb_syms * sizeof(ElfW(Sym)));
old_to_new_syms = tcc_malloc(nb_syms * sizeof(int));
/* first pass for local symbols */
p = (Elf32_Sym *)s->data;
p = (ElfW(Sym) *)s->data;
q = new_syms;
for(i = 0; i < nb_syms; i++) {
if (ELF32_ST_BIND(p->st_info) == STB_LOCAL) {
if (ELFW(ST_BIND)(p->st_info) == STB_LOCAL) {
old_to_new_syms[i] = q - new_syms;
*q++ = *p;
}
@ -352,9 +362,9 @@ static void sort_syms(TCCState *s1, Section *s)
s->sh_info = q - new_syms;
/* then second pass for non local symbols */
p = (Elf32_Sym *)s->data;
p = (ElfW(Sym) *)s->data;
for(i = 0; i < nb_syms; i++) {
if (ELF32_ST_BIND(p->st_info) != STB_LOCAL) {
if (ELFW(ST_BIND)(p->st_info) != STB_LOCAL) {
old_to_new_syms[i] = q - new_syms;
*q++ = *p;
}
@ -362,21 +372,21 @@ static void sort_syms(TCCState *s1, Section *s)
}
/* we copy the new symbols to the old */
memcpy(s->data, new_syms, nb_syms * sizeof(Elf32_Sym));
memcpy(s->data, new_syms, nb_syms * sizeof(ElfW(Sym)));
tcc_free(new_syms);
/* now we modify all the relocations */
for(i = 1; i < s1->nb_sections; i++) {
sr = s1->sections[i];
if (sr->sh_type == SHT_REL && sr->link == s) {
rel_end = (Elf32_Rel *)(sr->data + sr->data_offset);
for(rel = (Elf32_Rel *)sr->data;
if (sr->sh_type == SHT_RELX && sr->link == s) {
rel_end = (ElfW_Rel *)(sr->data + sr->data_offset);
for(rel = (ElfW_Rel *)sr->data;
rel < rel_end;
rel++) {
sym_index = ELF32_R_SYM(rel->r_info);
type = ELF32_R_TYPE(rel->r_info);
sym_index = ELFW(R_SYM)(rel->r_info);
type = ELFW(R_TYPE)(rel->r_info);
sym_index = old_to_new_syms[sym_index];
rel->r_info = ELF32_R_INFO(sym_index, type);
rel->r_info = ELFW(R_INFO)(sym_index, type);
}
}
}
@ -387,11 +397,11 @@ static void sort_syms(TCCState *s1, Section *s)
/* relocate common symbols in the .bss section */
static void relocate_common_syms(void)
{
Elf32_Sym *sym, *sym_end;
ElfW(Sym) *sym, *sym_end;
unsigned long offset, align;
sym_end = (Elf32_Sym *)(symtab_section->data + symtab_section->data_offset);
for(sym = (Elf32_Sym *)symtab_section->data + 1;
sym_end = (ElfW(Sym) *)(symtab_section->data + symtab_section->data_offset);
for(sym = (ElfW(Sym) *)symtab_section->data + 1;
sym < sym_end;
sym++) {
if (sym->st_shndx == SHN_COMMON) {
@ -411,13 +421,13 @@ static void relocate_common_syms(void)
true and output error if undefined symbol. */
static void relocate_syms(TCCState *s1, int do_resolve)
{
Elf32_Sym *sym, *esym, *sym_end;
ElfW(Sym) *sym, *esym, *sym_end;
int sym_bind, sh_num, sym_index;
const char *name;
unsigned long addr;
sym_end = (Elf32_Sym *)(symtab_section->data + symtab_section->data_offset);
for(sym = (Elf32_Sym *)symtab_section->data + 1;
sym_end = (ElfW(Sym) *)(symtab_section->data + symtab_section->data_offset);
for(sym = (ElfW(Sym) *)symtab_section->data + 1;
sym < sym_end;
sym++) {
sh_num = sym->st_shndx;
@ -425,7 +435,7 @@ static void relocate_syms(TCCState *s1, int do_resolve)
name = strtab_section->data + sym->st_name;
if (do_resolve) {
name = symtab_section->link->data + sym->st_name;
addr = (unsigned long)resolve_sym(s1, name, ELF32_ST_TYPE(sym->st_info));
addr = (unsigned long)resolve_sym(s1, name, ELFW(ST_TYPE)(sym->st_info));
if (addr) {
sym->st_value = addr;
goto found;
@ -434,7 +444,7 @@ static void relocate_syms(TCCState *s1, int do_resolve)
/* if dynamic symbol exist, then use it */
sym_index = find_elf_sym(s1->dynsym, name);
if (sym_index) {
esym = &((Elf32_Sym *)s1->dynsym->data)[sym_index];
esym = &((ElfW(Sym) *)s1->dynsym->data)[sym_index];
sym->st_value = esym->st_value;
goto found;
}
@ -445,7 +455,7 @@ static void relocate_syms(TCCState *s1, int do_resolve)
goto found;
/* only weak symbols are accepted to be undefined. Their
value is zero */
sym_bind = ELF32_ST_BIND(sym->st_info);
sym_bind = ELFW(ST_BIND)(sym->st_info);
if (sym_bind == STB_WEAK) {
sym->st_value = 0;
} else {
@ -463,8 +473,8 @@ static void relocate_syms(TCCState *s1, int do_resolve)
static void relocate_section(TCCState *s1, Section *s)
{
Section *sr;
Elf32_Rel *rel, *rel_end, *qrel;
Elf32_Sym *sym;
ElfW_Rel *rel, *rel_end, *qrel;
ElfW(Sym) *sym;
int type, sym_index;
unsigned char *ptr;
unsigned long val, addr;
@ -473,17 +483,17 @@ static void relocate_section(TCCState *s1, Section *s)
#endif
sr = s->reloc;
rel_end = (Elf32_Rel *)(sr->data + sr->data_offset);
qrel = (Elf32_Rel *)sr->data;
rel_end = (ElfW_Rel *)(sr->data + sr->data_offset);
qrel = (ElfW_Rel *)sr->data;
for(rel = qrel;
rel < rel_end;
rel++) {
ptr = s->data + rel->r_offset;
sym_index = ELF32_R_SYM(rel->r_info);
sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
sym_index = ELFW(R_SYM)(rel->r_info);
sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
val = sym->st_value;
type = ELF32_R_TYPE(rel->r_info);
type = ELFW(R_TYPE)(rel->r_info);
addr = s->sh_addr + rel->r_offset;
/* CPU specific */
@ -494,11 +504,11 @@ static void relocate_section(TCCState *s1, Section *s)
esym_index = s1->symtab_to_dynsym[sym_index];
qrel->r_offset = rel->r_offset;
if (esym_index) {
qrel->r_info = ELF32_R_INFO(esym_index, R_386_32);
qrel->r_info = ELFW(R_INFO)(esym_index, R_386_32);
qrel++;
break;
} else {
qrel->r_info = ELF32_R_INFO(0, R_386_RELATIVE);
qrel->r_info = ELFW(R_INFO)(0, R_386_RELATIVE);
qrel++;
}
}
@ -510,7 +520,7 @@ static void relocate_section(TCCState *s1, Section *s)
esym_index = s1->symtab_to_dynsym[sym_index];
if (esym_index) {
qrel->r_offset = rel->r_offset;
qrel->r_info = ELF32_R_INFO(esym_index, R_386_PC32);
qrel->r_info = ELFW(R_INFO)(esym_index, R_386_PC32);
qrel++;
break;
}
@ -624,11 +634,11 @@ static void relocate_section(TCCState *s1, Section *s)
static void relocate_rel(TCCState *s1, Section *sr)
{
Section *s;
Elf32_Rel *rel, *rel_end;
ElfW_Rel *rel, *rel_end;
s = s1->sections[sr->sh_info];
rel_end = (Elf32_Rel *)(sr->data + sr->data_offset);
for(rel = (Elf32_Rel *)sr->data;
rel_end = (ElfW_Rel *)(sr->data + sr->data_offset);
for(rel = (ElfW_Rel *)sr->data;
rel < rel_end;
rel++) {
rel->r_offset += s->sh_addr;
@ -639,14 +649,14 @@ static void relocate_rel(TCCState *s1, Section *sr)
their space */
static int prepare_dynamic_rel(TCCState *s1, Section *sr)
{
Elf32_Rel *rel, *rel_end;
ElfW_Rel *rel, *rel_end;
int sym_index, esym_index, type, count;
count = 0;
rel_end = (Elf32_Rel *)(sr->data + sr->data_offset);
for(rel = (Elf32_Rel *)sr->data; rel < rel_end; rel++) {
sym_index = ELF32_R_SYM(rel->r_info);
type = ELF32_R_TYPE(rel->r_info);
rel_end = (ElfW_Rel *)(sr->data + sr->data_offset);
for(rel = (ElfW_Rel *)sr->data; rel < rel_end; rel++) {
sym_index = ELFW(R_SYM)(rel->r_info);
type = ELFW(R_TYPE)(rel->r_info);
switch(type) {
case R_386_32:
count++;
@ -663,7 +673,7 @@ static int prepare_dynamic_rel(TCCState *s1, Section *sr)
if (count) {
/* allocate the section */
sr->sh_flags |= SHF_ALLOC;
sr->sh_size = count * sizeof(Elf32_Rel);
sr->sh_size = count * sizeof(ElfW_Rel);
}
return count;
}
@ -712,7 +722,7 @@ static void build_got(TCCState *s1)
/* if no got, then create it */
s1->got = new_section(s1, ".got", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE);
s1->got->sh_entsize = 4;
add_elf_sym(symtab_section, 0, 4, ELF32_ST_INFO(STB_GLOBAL, STT_OBJECT),
add_elf_sym(symtab_section, 0, 4, ELFW(ST_INFO)(STB_GLOBAL, STT_OBJECT),
0, s1->got->sh_num, "_GLOBAL_OFFSET_TABLE_");
ptr = section_ptr_add(s1->got, 3 * sizeof(int));
/* keep space for _DYNAMIC pointer, if present */
@ -730,7 +740,7 @@ static void put_got_entry(TCCState *s1,
{
int index;
const char *name;
Elf32_Sym *sym;
ElfW(Sym) *sym;
unsigned long offset;
int *ptr;
@ -745,7 +755,7 @@ static void put_got_entry(TCCState *s1,
put_got_offset(s1, sym_index, s1->got->data_offset);
if (s1->dynsym) {
sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
name = symtab_section->link->data + sym->st_name;
offset = sym->st_value;
#ifdef TCC_TARGET_I386
@ -838,23 +848,23 @@ static void put_got_entry(TCCState *s1,
static void build_got_entries(TCCState *s1)
{
Section *s, *symtab;
Elf32_Rel *rel, *rel_end;
Elf32_Sym *sym;
ElfW_Rel *rel, *rel_end;
ElfW(Sym) *sym;
int i, type, reloc_type, sym_index;
for(i = 1; i < s1->nb_sections; i++) {
s = s1->sections[i];
if (s->sh_type != SHT_REL)
if (s->sh_type != SHT_RELX)
continue;
/* no need to handle got relocations */
if (s->link != symtab_section)
continue;
symtab = s->link;
rel_end = (Elf32_Rel *)(s->data + s->data_offset);
for(rel = (Elf32_Rel *)s->data;
rel_end = (ElfW_Rel *)(s->data + s->data_offset);
for(rel = (ElfW_Rel *)s->data;
rel < rel_end;
rel++) {
type = ELF32_R_TYPE(rel->r_info);
type = ELFW(R_TYPE)(rel->r_info);
switch(type) {
#if defined(TCC_TARGET_I386)
case R_386_GOT32:
@ -864,8 +874,8 @@ static void build_got_entries(TCCState *s1)
if (!s1->got)
build_got(s1);
if (type == R_386_GOT32 || type == R_386_PLT32) {
sym_index = ELF32_R_SYM(rel->r_info);
sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
sym_index = ELFW(R_SYM)(rel->r_info);
sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
/* look at the symbol got offset. If none, then add one */
if (type == R_386_GOT32)
reloc_type = R_386_GLOB_DAT;
@ -883,8 +893,8 @@ static void build_got_entries(TCCState *s1)
if (!s1->got)
build_got(s1);
if (type == R_ARM_GOT_BREL || type == R_ARM_PLT32) {
sym_index = ELF32_R_SYM(rel->r_info);
sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
sym_index = ELFW(R_SYM)(rel->r_info);
sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
/* look at the symbol got offset. If none, then add one */
if (type == R_ARM_GOT_BREL)
reloc_type = R_ARM_GLOB_DAT;
@ -902,8 +912,8 @@ static void build_got_entries(TCCState *s1)
if (!s1->got)
build_got(s1);
if (type == R_C60_GOT32 || type == R_C60_PLT32) {
sym_index = ELF32_R_SYM(rel->r_info);
sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
sym_index = ELFW(R_SYM)(rel->r_info);
sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
/* look at the symbol got offset. If none, then add one */
if (type == R_C60_GOT32)
reloc_type = R_C60_GLOB_DAT;
@ -932,7 +942,7 @@ static Section *new_symtab(TCCState *s1,
int *ptr, nb_buckets;
symtab = new_section(s1, symtab_name, sh_type, sh_flags);
symtab->sh_entsize = sizeof(Elf32_Sym);
symtab->sh_entsize = sizeof(ElfW(Sym));
strtab = new_section(s1, strtab_name, SHT_STRTAB, sh_flags);
put_elf_str(strtab, "");
symtab->link = strtab;
@ -955,8 +965,8 @@ static Section *new_symtab(TCCState *s1,
/* put dynamic tag */
static void put_dt(Section *dynamic, int dt, unsigned long val)
{
Elf32_Dyn *dyn;
dyn = section_ptr_add(dynamic, sizeof(Elf32_Dyn));
ElfW(Dyn) *dyn;
dyn = section_ptr_add(dynamic, sizeof(ElfW(Dyn)));
dyn->d_tag = dt;
dyn->d_un.d_val = val;
}
@ -981,11 +991,11 @@ static void add_init_array_defines(TCCState *s1, const char *section_name)
add_elf_sym(symtab_section,
0, 0,
ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0,
ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
s->sh_num, sym_start);
add_elf_sym(symtab_section,
end_offset, 0,
ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0,
ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
s->sh_num, sym_end);
}
@ -1007,7 +1017,7 @@ static void tcc_add_runtime(TCCState *s1)
ptr = section_ptr_add(bounds_section, sizeof(unsigned long));
*ptr = 0;
add_elf_sym(symtab_section, 0, 0,
ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0,
ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
bounds_section->sh_num, "__bounds_start");
/* add bound check code */
snprintf(buf, sizeof(buf), "%s/%s", tcc_lib_path, "bcheck.o");
@ -1054,15 +1064,15 @@ static void tcc_add_linker_symbols(TCCState *s1)
add_elf_sym(symtab_section,
text_section->data_offset, 0,
ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0,
ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
text_section->sh_num, "_etext");
add_elf_sym(symtab_section,
data_section->data_offset, 0,
ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0,
ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
data_section->sh_num, "_edata");
add_elf_sym(symtab_section,
bss_section->data_offset, 0,
ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0,
ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
bss_section->sh_num, "_end");
/* horrible new standard ldscript defines */
add_init_array_defines(s1, ".preinit_array");
@ -1091,12 +1101,12 @@ static void tcc_add_linker_symbols(TCCState *s1)
snprintf(buf, sizeof(buf), "__start_%s", s->name);
add_elf_sym(symtab_section,
0, 0,
ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0,
ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
s->sh_num, buf);
snprintf(buf, sizeof(buf), "__stop_%s", s->name);
add_elf_sym(symtab_section,
s->data_offset, 0,
ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0,
ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
s->sh_num, buf);
}
next_sec: ;
@ -1140,18 +1150,18 @@ static void tcc_output_binary(TCCState *s1, FILE *f,
/* XXX: suppress unneeded sections */
int elf_output_file(TCCState *s1, const char *filename)
{
Elf32_Ehdr ehdr;
ElfW(Ehdr) ehdr;
FILE *f;
int fd, mode, ret;
int *section_order;
int shnum, i, phnum, file_offset, offset, size, j, tmp, sh_order_index, k;
unsigned long addr;
Section *strsec, *s;
Elf32_Shdr shdr, *sh;
Elf32_Phdr *phdr, *ph;
ElfW(Shdr) shdr, *sh;
ElfW(Phdr) *phdr, *ph;
Section *interp, *dynamic, *dynstr;
unsigned long saved_dynamic_data_offset;
Elf32_Sym *sym;
ElfW(Sym) *sym;
int type, file_type;
unsigned long rel_addr, rel_size;
@ -1177,7 +1187,7 @@ int elf_output_file(TCCState *s1, const char *filename)
if (!s1->static_link) {
const char *name;
int sym_index, index;
Elf32_Sym *esym, *sym_end;
ElfW(Sym) *esym, *sym_end;
if (file_type == TCC_OUTPUT_EXE) {
char *ptr;
@ -1198,7 +1208,7 @@ int elf_output_file(TCCState *s1, const char *filename)
dynamic = new_section(s1, ".dynamic", SHT_DYNAMIC,
SHF_ALLOC | SHF_WRITE);
dynamic->link = dynstr;
dynamic->sh_entsize = sizeof(Elf32_Dyn);
dynamic->sh_entsize = sizeof(ElfW(Dyn));
/* add PLT */
s1->plt = new_section(s1, ".plt", SHT_PROGBITS,
@ -1211,22 +1221,22 @@ int elf_output_file(TCCState *s1, const char *filename)
dynamic symbols. If a symbol STT_FUNC is found, then we
add it in the PLT. If a symbol STT_OBJECT is found, we
add it in the .bss section with a suitable relocation */
sym_end = (Elf32_Sym *)(symtab_section->data +
sym_end = (ElfW(Sym) *)(symtab_section->data +
symtab_section->data_offset);
if (file_type == TCC_OUTPUT_EXE) {
for(sym = (Elf32_Sym *)symtab_section->data + 1;
for(sym = (ElfW(Sym) *)symtab_section->data + 1;
sym < sym_end;
sym++) {
if (sym->st_shndx == SHN_UNDEF) {
name = symtab_section->link->data + sym->st_name;
sym_index = find_elf_sym(s1->dynsymtab_section, name);
if (sym_index) {
esym = &((Elf32_Sym *)s1->dynsymtab_section->data)[sym_index];
type = ELF32_ST_TYPE(esym->st_info);
esym = &((ElfW(Sym) *)s1->dynsymtab_section->data)[sym_index];
type = ELFW(ST_TYPE)(esym->st_info);
if (type == STT_FUNC) {
put_got_entry(s1, R_JMP_SLOT, esym->st_size,
esym->st_info,
sym - (Elf32_Sym *)symtab_section->data);
sym - (ElfW(Sym) *)symtab_section->data);
} else if (type == STT_OBJECT) {
unsigned long offset;
offset = bss_section->data_offset;
@ -1244,14 +1254,14 @@ int elf_output_file(TCCState *s1, const char *filename)
/* STB_WEAK undefined symbols are accepted */
/* XXX: _fp_hw seems to be part of the ABI, so we ignore
it */
if (ELF32_ST_BIND(sym->st_info) == STB_WEAK ||
if (ELFW(ST_BIND)(sym->st_info) == STB_WEAK ||
!strcmp(name, "_fp_hw")) {
} else {
error_noabort("undefined symbol '%s'", name);
}
}
} else if (s1->rdynamic &&
ELF32_ST_BIND(sym->st_info) != STB_LOCAL) {
ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
/* if -rdynamic option, then export all non
local symbols */
name = symtab_section->link->data + sym->st_name;
@ -1266,9 +1276,9 @@ int elf_output_file(TCCState *s1, const char *filename)
/* now look at unresolved dynamic symbols and export
corresponding symbol */
sym_end = (Elf32_Sym *)(s1->dynsymtab_section->data +
sym_end = (ElfW(Sym) *)(s1->dynsymtab_section->data +
s1->dynsymtab_section->data_offset);
for(esym = (Elf32_Sym *)s1->dynsymtab_section->data + 1;
for(esym = (ElfW(Sym) *)s1->dynsymtab_section->data + 1;
esym < sym_end;
esym++) {
if (esym->st_shndx == SHN_UNDEF) {
@ -1277,12 +1287,12 @@ int elf_output_file(TCCState *s1, const char *filename)
if (sym_index) {
/* XXX: avoid adding a symbol if already
present because of -rdynamic ? */
sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
put_elf_sym(s1->dynsym, sym->st_value, sym->st_size,
sym->st_info, 0,
sym->st_shndx, name);
} else {
if (ELF32_ST_BIND(esym->st_info) == STB_WEAK) {
if (ELFW(ST_BIND)(esym->st_info) == STB_WEAK) {
/* weak symbols can stay undefined */
} else {
warning("undefined dynamic symbol '%s'", name);
@ -1293,18 +1303,18 @@ int elf_output_file(TCCState *s1, const char *filename)
} else {
int nb_syms;
/* shared library case : we simply export all the global symbols */
nb_syms = symtab_section->data_offset / sizeof(Elf32_Sym);
nb_syms = symtab_section->data_offset / sizeof(ElfW(Sym));
s1->symtab_to_dynsym = tcc_mallocz(sizeof(int) * nb_syms);
for(sym = (Elf32_Sym *)symtab_section->data + 1;
for(sym = (ElfW(Sym) *)symtab_section->data + 1;
sym < sym_end;
sym++) {
if (ELF32_ST_BIND(sym->st_info) != STB_LOCAL) {
if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
name = symtab_section->link->data + sym->st_name;
index = put_elf_sym(s1->dynsym, sym->st_value, sym->st_size,
sym->st_info, 0,
sym->st_shndx, name);
s1->symtab_to_dynsym[sym -
(Elf32_Sym *)symtab_section->data] =
(ElfW(Sym) *)symtab_section->data] =
index;
}
}
@ -1385,7 +1395,7 @@ int elf_output_file(TCCState *s1, const char *filename)
/* when generating a DLL, we include relocations but we may
patch them */
if (file_type == TCC_OUTPUT_DLL &&
s->sh_type == SHT_REL &&
s->sh_type == SHT_RELX &&
!(s->sh_flags & SHF_ALLOC)) {
/* //gr: avoid bogus relocs for empty (debug) sections */
if (s1->sections[s->sh_info]->sh_flags & SHF_ALLOC)
@ -1402,10 +1412,10 @@ int elf_output_file(TCCState *s1, const char *filename)
}
/* allocate program segment headers */
phdr = tcc_mallocz(phnum * sizeof(Elf32_Phdr));
phdr = tcc_mallocz(phnum * sizeof(ElfW(Phdr)));
if (s1->output_format == TCC_OUTPUT_FORMAT_ELF) {
file_offset = sizeof(Elf32_Ehdr) + phnum * sizeof(Elf32_Phdr);
file_offset = sizeof(ElfW(Ehdr)) + phnum * sizeof(ElfW(Phdr));
} else {
file_offset = 0;
}
@ -1471,7 +1481,7 @@ int elf_output_file(TCCState *s1, const char *filename)
s->sh_type == SHT_HASH) {
if (k != 1)
continue;
} else if (s->sh_type == SHT_REL) {
} else if (s->sh_type == SHT_RELX) {
if (k != 2)
continue;
} else if (s->sh_type == SHT_NOBITS) {
@ -1498,7 +1508,7 @@ int elf_output_file(TCCState *s1, const char *filename)
ph->p_paddr = ph->p_vaddr;
}
/* update dynamic relocation infos */
if (s->sh_type == SHT_REL) {
if (s->sh_type == SHT_RELX) {
if (rel_size == 0)
rel_addr = addr;
rel_size += s->sh_size;
@ -1541,7 +1551,7 @@ int elf_output_file(TCCState *s1, const char *filename)
/* if dynamic section, then add corresponing program header */
if (dynamic) {
Elf32_Sym *sym_end;
ElfW(Sym) *sym_end;
ph = &phdr[phnum - 1];
@ -1589,8 +1599,8 @@ int elf_output_file(TCCState *s1, const char *filename)
}
/* relocate symbols in .dynsym */
sym_end = (Elf32_Sym *)(s1->dynsym->data + s1->dynsym->data_offset);
for(sym = (Elf32_Sym *)s1->dynsym->data + 1;
sym_end = (ElfW(Sym) *)(s1->dynsym->data + s1->dynsym->data_offset);
for(sym = (ElfW(Sym) *)s1->dynsym->data + 1;
sym < sym_end;
sym++) {
if (sym->st_shndx == SHN_UNDEF) {
@ -1610,18 +1620,18 @@ int elf_output_file(TCCState *s1, const char *filename)
put_dt(dynamic, DT_STRTAB, dynstr->sh_addr);
put_dt(dynamic, DT_SYMTAB, s1->dynsym->sh_addr);
put_dt(dynamic, DT_STRSZ, dynstr->data_offset);
put_dt(dynamic, DT_SYMENT, sizeof(Elf32_Sym));
put_dt(dynamic, DT_SYMENT, sizeof(ElfW(Sym)));
put_dt(dynamic, DT_REL, rel_addr);
put_dt(dynamic, DT_RELSZ, rel_size);
put_dt(dynamic, DT_RELENT, sizeof(Elf32_Rel));
put_dt(dynamic, DT_RELENT, sizeof(ElfW_Rel));
if (do_debug)
put_dt(dynamic, DT_DEBUG, 0);
put_dt(dynamic, DT_NULL, 0);
}
ehdr.e_phentsize = sizeof(Elf32_Phdr);
ehdr.e_phentsize = sizeof(ElfW(Phdr));
ehdr.e_phnum = phnum;
ehdr.e_phoff = sizeof(Elf32_Ehdr);
ehdr.e_phoff = sizeof(ElfW(Ehdr));
}
/* all other sections come after */
@ -1662,7 +1672,7 @@ int elf_output_file(TCCState *s1, const char *filename)
for(i = 1; i < s1->nb_sections; i++) {
s = s1->sections[i];
if ((s->sh_flags & SHF_ALLOC) &&
s->sh_type == SHT_REL) {
s->sh_type == SHT_RELX) {
relocate_rel(s1, s);
}
}
@ -1733,14 +1743,14 @@ int elf_output_file(TCCState *s1, const char *filename)
ehdr.e_machine = EM_TCC_TARGET;
ehdr.e_version = EV_CURRENT;
ehdr.e_shoff = file_offset;
ehdr.e_ehsize = sizeof(Elf32_Ehdr);
ehdr.e_shentsize = sizeof(Elf32_Shdr);
ehdr.e_ehsize = sizeof(ElfW(Ehdr));
ehdr.e_shentsize = sizeof(ElfW(Shdr));
ehdr.e_shnum = shnum;
ehdr.e_shstrndx = shnum - 1;
fwrite(&ehdr, 1, sizeof(Elf32_Ehdr), f);
fwrite(phdr, 1, phnum * sizeof(Elf32_Phdr), f);
offset = sizeof(Elf32_Ehdr) + phnum * sizeof(Elf32_Phdr);
fwrite(&ehdr, 1, sizeof(ElfW(Ehdr)), f);
fwrite(phdr, 1, phnum * sizeof(ElfW(Phdr)), f);
offset = sizeof(ElfW(Ehdr)) + phnum * sizeof(ElfW(Phdr));
for(i=1;i<s1->nb_sections;i++) {
s = s1->sections[section_order[i]];
@ -1763,7 +1773,7 @@ int elf_output_file(TCCState *s1, const char *filename)
for(i=0;i<s1->nb_sections;i++) {
sh = &shdr;
memset(sh, 0, sizeof(Elf32_Shdr));
memset(sh, 0, sizeof(ElfW(Shdr)));
s = s1->sections[i];
if (s) {
sh->sh_name = s->sh_name;
@ -1778,7 +1788,7 @@ int elf_output_file(TCCState *s1, const char *filename)
sh->sh_offset = s->sh_offset;
sh->sh_size = s->sh_size;
}
fwrite(sh, 1, sizeof(Elf32_Shdr), f);
fwrite(sh, 1, sizeof(ElfW(Shdr)), f);
}
} else {
tcc_output_binary(s1, f, section_order);
@ -1830,15 +1840,15 @@ typedef struct SectionMergeInfo {
static int tcc_load_object_file(TCCState *s1,
int fd, unsigned long file_offset)
{
Elf32_Ehdr ehdr;
Elf32_Shdr *shdr, *sh;
ElfW(Ehdr) ehdr;
ElfW(Shdr) *shdr, *sh;
int size, i, j, offset, offseti, nb_syms, sym_index, ret;
unsigned char *strsec, *strtab;
int *old_to_new_syms;
char *sh_name, *name;
SectionMergeInfo *sm_table, *sm;
Elf32_Sym *sym, *symtab;
Elf32_Rel *rel, *rel_end;
ElfW(Sym) *sym, *symtab;
ElfW_Rel *rel, *rel_end;
Section *s;
int stab_index;
@ -1865,7 +1875,7 @@ static int tcc_load_object_file(TCCState *s1,
}
/* read sections */
shdr = load_data(fd, file_offset + ehdr.e_shoff,
sizeof(Elf32_Shdr) * ehdr.e_shnum);
sizeof(ElfW(Shdr)) * ehdr.e_shnum);
sm_table = tcc_mallocz(sizeof(SectionMergeInfo) * ehdr.e_shnum);
/* load section names */
@ -1886,7 +1896,7 @@ static int tcc_load_object_file(TCCState *s1,
ret = -1;
goto the_end;
}
nb_syms = sh->sh_size / sizeof(Elf32_Sym);
nb_syms = sh->sh_size / sizeof(ElfW(Sym));
symtab = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
sm_table[i].s = symtab_section;
@ -1906,7 +1916,7 @@ static int tcc_load_object_file(TCCState *s1,
sh_name = strsec + sh->sh_name;
/* ignore sections types we do not handle */
if (sh->sh_type != SHT_PROGBITS &&
sh->sh_type != SHT_REL &&
sh->sh_type != SHT_RELX &&
#ifdef TCC_ARM_EABI
sh->sh_type != SHT_ARM_EXIDX &&
#endif
@ -2000,7 +2010,7 @@ static int tcc_load_object_file(TCCState *s1,
sh = &shdr[i];
if (sh->sh_link > 0)
s->link = sm_table[sh->sh_link].s;
if (sh->sh_type == SHT_REL) {
if (sh->sh_type == SHT_RELX) {
s->sh_info = sm_table[sh->sh_info].s->sh_num;
/* update backward link */
s1->sections[s->sh_info]->reloc = s;
@ -2020,7 +2030,7 @@ static int tcc_load_object_file(TCCState *s1,
/* if a symbol is in a link once section, we use the
already defined symbol. It is very important to get
correct relocations */
if (ELF32_ST_BIND(sym->st_info) != STB_LOCAL) {
if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
name = strtab + sym->st_name;
sym_index = find_elf_sym(symtab_section, name);
if (sym_index)
@ -2052,18 +2062,18 @@ static int tcc_load_object_file(TCCState *s1,
sh = &shdr[i];
offset = sm_table[i].offset;
switch(s->sh_type) {
case SHT_REL:
case SHT_RELX:
/* take relocation offset information */
offseti = sm_table[sh->sh_info].offset;
rel_end = (Elf32_Rel *)(s->data + s->data_offset);
for(rel = (Elf32_Rel *)(s->data + offset);
rel_end = (ElfW_Rel *)(s->data + s->data_offset);
for(rel = (ElfW_Rel *)(s->data + offset);
rel < rel_end;
rel++) {
int type;
unsigned sym_index;
/* convert symbol index */
type = ELF32_R_TYPE(rel->r_info);
sym_index = ELF32_R_SYM(rel->r_info);
type = ELFW(R_TYPE)(rel->r_info);
sym_index = ELFW(R_SYM)(rel->r_info);
/* NOTE: only one symtab assumed */
if (sym_index >= nb_syms)
goto invalid_reloc;
@ -2075,7 +2085,7 @@ static int tcc_load_object_file(TCCState *s1,
i, strsec + sh->sh_name, rel->r_offset);
goto fail;
}
rel->r_info = ELF32_R_INFO(sym_index, type);
rel->r_info = ELFW(R_INFO)(sym_index, type);
/* offset the relocation offset */
rel->r_offset += offseti;
}
@ -2120,7 +2130,7 @@ static int tcc_load_alacarte(TCCState *s1, int fd, int size)
uint8_t *data;
const char *ar_names, *p;
const uint8_t *ar_index;
Elf32_Sym *sym;
ElfW(Sym) *sym;
data = tcc_malloc(size);
if (read(fd, data, size) != size)
@ -2134,7 +2144,7 @@ static int tcc_load_alacarte(TCCState *s1, int fd, int size)
for(p = ar_names, i = 0; i < nsyms; i++, p += strlen(p)+1) {
sym_index = find_elf_sym(symtab_section, p);
if(sym_index) {
sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
if(sym->st_shndx == SHN_UNDEF) {
off = get_be32(ar_index + i * 4) + sizeof(ArchiveHeader);
#if 0
@ -2214,11 +2224,11 @@ static int tcc_load_archive(TCCState *s1, int fd)
the generated ELF file) */
static int tcc_load_dll(TCCState *s1, int fd, const char *filename, int level)
{
Elf32_Ehdr ehdr;
Elf32_Shdr *shdr, *sh, *sh1;
ElfW(Ehdr) ehdr;
ElfW(Shdr) *shdr, *sh, *sh1;
int i, j, nb_syms, nb_dts, sym_bind, ret;
Elf32_Sym *sym, *dynsym;
Elf32_Dyn *dt, *dynamic;
ElfW(Sym) *sym, *dynsym;
ElfW(Dyn) *dt, *dynamic;
unsigned char *dynstr;
const char *name, *soname;
DLLReference *dllref;
@ -2233,7 +2243,7 @@ static int tcc_load_dll(TCCState *s1, int fd, const char *filename, int level)
}
/* read sections */
shdr = load_data(fd, ehdr.e_shoff, sizeof(Elf32_Shdr) * ehdr.e_shnum);
shdr = load_data(fd, ehdr.e_shoff, sizeof(ElfW(Shdr)) * ehdr.e_shnum);
/* load dynamic section and dynamic symbols */
nb_syms = 0;
@ -2244,11 +2254,11 @@ static int tcc_load_dll(TCCState *s1, int fd, const char *filename, int level)
for(i = 0, sh = shdr; i < ehdr.e_shnum; i++, sh++) {
switch(sh->sh_type) {
case SHT_DYNAMIC:
nb_dts = sh->sh_size / sizeof(Elf32_Dyn);
nb_dts = sh->sh_size / sizeof(ElfW(Dyn));
dynamic = load_data(fd, sh->sh_offset, sh->sh_size);
break;
case SHT_DYNSYM:
nb_syms = sh->sh_size / sizeof(Elf32_Sym);
nb_syms = sh->sh_size / sizeof(ElfW(Sym));
dynsym = load_data(fd, sh->sh_offset, sh->sh_size);
sh1 = &shdr[sh->sh_link];
dynstr = load_data(fd, sh1->sh_offset, sh1->sh_size);
@ -2289,7 +2299,7 @@ static int tcc_load_dll(TCCState *s1, int fd, const char *filename, int level)
/* add dynamic symbols in dynsym_section */
for(i = 1, sym = dynsym + 1; i < nb_syms; i++, sym++) {
sym_bind = ELF32_ST_BIND(sym->st_info);
sym_bind = ELFW(ST_BIND)(sym->st_info);
if (sym_bind == STB_LOCAL)
continue;
name = dynstr + sym->st_name;