WebSVN – Kolibri OS – Diff – /programs/develop/metcc/trunk/source/tccelf.c


/*
 *  ELF file handling for TCC
 * 
 *  Copyright (c) 2001-2004 Fabrice Bellard
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
 
static int put_elf_str(Section *s, const char *sym)
{
    int offset, len;
    char *ptr;
 
    len = strlen(sym) + 1;
    offset = s->data_offset;
    ptr = section_ptr_add(s, len);
    memcpy(ptr, sym, len);
    return offset;
}
 
/* elf symbol hashing function */
static unsigned long elf_hash(const unsigned char *name)
{
    unsigned long h = 0, g;
    
    while (*name) {
        h = (h << 4) + *name++;
        g = h & 0xf0000000;
        if (g)
            h ^= g >> 24;
        h &= ~g;
    }
    return h;
}
 
/* rebuild hash table of section s */
/* NOTE: we do factorize the hash table code to go faster */
static void rebuild_hash(Section *s, unsigned int nb_buckets)
{
    Elf32_Sym *sym;
    int *ptr, *hash, nb_syms, sym_index, h;
    char *strtab;
 
    strtab = s->link->data;
    nb_syms = s->data_offset / sizeof(Elf32_Sym);
 
    s->hash->data_offset = 0;
    ptr = section_ptr_add(s->hash, (2 + nb_buckets + nb_syms) * sizeof(int));
    ptr[0] = nb_buckets;
    ptr[1] = nb_syms;
    ptr += 2;
    hash = ptr;
    memset(hash, 0, (nb_buckets + 1) * sizeof(int));
    ptr += nb_buckets + 1;
 
    sym = (Elf32_Sym *)s->data + 1;
    for(sym_index = 1; sym_index < nb_syms; sym_index++) {
        if (ELF32_ST_BIND(sym->st_info) != STB_LOCAL) {
            h = elf_hash(strtab + sym->st_name) % nb_buckets;
            *ptr = hash[h];
            hash[h] = sym_index;
        } else {
            *ptr = 0;
        }
        ptr++;
        sym++;
    }
}
 
/* return the symbol number */
static int put_elf_sym(Section *s, 
                       unsigned long value, unsigned long size,
                       int info, int other, int shndx, const char *name)
{
    int name_offset, sym_index;
    int nbuckets, h;
    Elf32_Sym *sym;
    Section *hs;
    
    sym = section_ptr_add(s, sizeof(Elf32_Sym));
    if (name)
        name_offset = put_elf_str(s->link, name);
    else
        name_offset = 0;
    /* XXX: endianness */
    sym->st_name = name_offset;
    sym->st_value = value;
    sym->st_size = size;
    sym->st_info = info;
    sym->st_other = other;
    sym->st_shndx = shndx;
    sym_index = sym - (Elf32_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) {
            /* add another hashing entry */
            nbuckets = base[0];
            h = elf_hash(name) % nbuckets;
            *ptr = base[2 + h];
            base[2 + h] = sym_index;
            base[1]++;
            /* we resize the hash table */
            hs->nb_hashed_syms++;
            if (hs->nb_hashed_syms > 2 * nbuckets) {
                rebuild_hash(s, 2 * nbuckets);
            }
        } else {
            *ptr = 0;
            base[1]++;
        }
    }
    return sym_index;
}
 
/* find global ELF symbol 'name' and return its index. Return 0 if not
   found. */
static int find_elf_sym(Section *s, const char *name)
{
    Elf32_Sym *sym;
    Section *hs;
    int nbuckets, sym_index, h;
    const char *name1;
    
    hs = s->hash;
    if (!hs)
        return 0;
    nbuckets = ((int *)hs->data)[0];
    h = elf_hash(name) % nbuckets;
    sym_index = ((int *)hs->data)[2 + h];
    while (sym_index != 0) {
        sym = &((Elf32_Sym *)s->data)[sym_index];
        name1 = s->link->data + sym->st_name;
        if (!strcmp(name, name1))
            return sym_index;
        sym_index = ((int *)hs->data)[2 + nbuckets + sym_index];
    }
    return 0;
}
 
/* return elf symbol value or error */
int tcc_get_symbol(TCCState *s, unsigned long *pval, const char *name)
{
    int sym_index;
    Elf32_Sym *sym;
    
    sym_index = find_elf_sym(symtab_section, name);
    if (!sym_index)
        return -1;
    sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
    *pval = sym->st_value;
    return 0;
}
 
void *tcc_get_symbol_err(TCCState *s, const char *name)
{
    unsigned long val;
    if (tcc_get_symbol(s, &val, name) < 0)
        error("%s not defined", name);
    return (void *)val;
}
 
/* add an elf symbol : check if it is already defined and patch
   it. Return symbol index. NOTE that sh_num can be SHN_UNDEF. */
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;
    int sym_bind, sym_index, sym_type, esym_bind;
 
    sym_bind = ELF32_ST_BIND(info);
    sym_type = ELF32_ST_TYPE(info);
        
    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];
        if (esym->st_shndx != SHN_UNDEF) {
            esym_bind = ELF32_ST_BIND(esym->st_info);
            if (sh_num == SHN_UNDEF) {
                /* ignore adding of undefined symbol if the
                   corresponding symbol is already defined */
            } else if (sym_bind == STB_GLOBAL && esym_bind == STB_WEAK) {
                /* global overrides weak, so patch */
                goto do_patch;
            } else if (sym_bind == STB_WEAK && esym_bind == STB_GLOBAL) {
                /* weak is ignored if already global */
            } else {
#if 0
                printf("new_bind=%d new_shndx=%d last_bind=%d old_shndx=%d\n",
                       sym_bind, sh_num, esym_bind, esym->st_shndx);
#endif
                /* NOTE: we accept that two DLL define the same symbol */
                if (s != tcc_state->dynsymtab_section)
                    error_noabort("'%s' defined twice", name);
            }
        } else {
        do_patch:
            esym->st_info = ELF32_ST_INFO(sym_bind, sym_type);
            esym->st_shndx = sh_num;
            esym->st_value = value;
            esym->st_size = size;
            esym->st_other = other;
        }
    } else {
    do_def:
        sym_index = put_elf_sym(s, value, size, 
                                ELF32_ST_INFO(sym_bind, sym_type), other, 
                                sh_num, name);
    }
    return sym_index;
}
 
/* put relocation */
static void put_elf_reloc(Section *symtab, Section *s, unsigned long offset,
                          int type, int symbol)
{
    char buf[256];
    Section *sr;
    Elf32_Rel *rel;
 
    sr = s->reloc;
    if (!sr) {
        /* if no relocation section, create it */
        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->link = symtab;
        sr->sh_info = s->sh_num;
        s->reloc = sr;
    }
    rel = section_ptr_add(sr, sizeof(Elf32_Rel));
    rel->r_offset = offset;
    rel->r_info = ELF32_R_INFO(symbol, type);
}
 
/* put stab debug information */
 
typedef struct {
    unsigned long n_strx;         /* index into string table of name */
    unsigned char n_type;         /* type of symbol */
    unsigned char n_other;        /* misc info (usually empty) */
    unsigned short n_desc;        /* description field */
    unsigned long n_value;        /* value of symbol */
} Stab_Sym;
 
static void put_stabs(const char *str, int type, int other, int desc, 
                      unsigned long value)
{
    Stab_Sym *sym;
 
    sym = section_ptr_add(stab_section, sizeof(Stab_Sym));
    if (str) {
        sym->n_strx = put_elf_str(stabstr_section, str);
    } else {
        sym->n_strx = 0;
    }
    sym->n_type = type;
    sym->n_other = other;
    sym->n_desc = desc;
    sym->n_value = value;
}
 
static void put_stabs_r(const char *str, int type, int other, int desc, 
                        unsigned long value, Section *sec, int sym_index)
{
    put_stabs(str, type, other, desc, value);
    put_elf_reloc(symtab_section, stab_section, 
                  stab_section->data_offset - sizeof(unsigned long),
                  R_DATA_32, sym_index);
}
 
static void put_stabn(int type, int other, int desc, int value)
{
    put_stabs(NULL, type, other, desc, value);
}
 
static void put_stabd(int type, int other, int desc)
{
    put_stabs(NULL, type, other, desc, 0);
}
 
/* In an ELF file symbol table, the local symbols must appear below
   the global and weak ones. Since TCC cannot sort it while generating
   the code, we must do it after. All the relocation tables are also
   modified to take into account the symbol table sorting */
static void sort_syms(TCCState *s1, Section *s)
{
    int *old_to_new_syms;
    Elf32_Sym *new_syms;
    int nb_syms, i;
    Elf32_Sym *p, *q;
    Elf32_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));
    old_to_new_syms = tcc_malloc(nb_syms * sizeof(int));
 
    /* first pass for local symbols */
    p = (Elf32_Sym *)s->data;
    q = new_syms;
    for(i = 0; i < nb_syms; i++) {
        if (ELF32_ST_BIND(p->st_info) == STB_LOCAL) {
            old_to_new_syms[i] = q - new_syms;
            *q++ = *p;
        }
        p++;
    }
    /* save the number of local symbols in section header */
    s->sh_info = q - new_syms;
 
    /* then second pass for non local symbols */
    p = (Elf32_Sym *)s->data;
    for(i = 0; i < nb_syms; i++) {
        if (ELF32_ST_BIND(p->st_info) != STB_LOCAL) {
            old_to_new_syms[i] = q - new_syms;
            *q++ = *p;
        }
        p++;
    }
    
    /* we copy the new symbols to the old */
    memcpy(s->data, new_syms, nb_syms * sizeof(Elf32_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;
                rel < rel_end;
                rel++) {
                sym_index = ELF32_R_SYM(rel->r_info);
                type = ELF32_R_TYPE(rel->r_info);
                sym_index = old_to_new_syms[sym_index];
                rel->r_info = ELF32_R_INFO(sym_index, type);
            }
        }
    }
    
    tcc_free(old_to_new_syms);
}
 
/* relocate common symbols in the .bss section */
static void relocate_common_syms(void)
{
    Elf32_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 < sym_end;
        sym++) {
        if (sym->st_shndx == SHN_COMMON) {
            /* align symbol */
            align = sym->st_value;
            offset = bss_section->data_offset;
            offset = (offset + align - 1) & -align;
            sym->st_value = offset;
            sym->st_shndx = bss_section->sh_num;
            offset += sym->st_size;
            bss_section->data_offset = offset;
        }
    }
}
 
/* relocate symbol table, resolve undefined symbols if do_resolve is
   true and output error if undefined symbol. */
static void relocate_syms(TCCState *s1, int do_resolve)
{
    Elf32_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 < sym_end;
        sym++) {
        sh_num = sym->st_shndx;
        if (sh_num == SHN_UNDEF) {
            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));
                if (addr) {
                    sym->st_value = addr;
                    goto found;
                }
            } else if (s1->dynsym) {
                /* 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];
                    sym->st_value = esym->st_value;
                    goto found;
                }
            }
            /* XXX: _fp_hw seems to be part of the ABI, so we ignore
               it */
            if (!strcmp(name, "_fp_hw"))
                goto found;
            /* only weak symbols are accepted to be undefined. Their
               value is zero */
            sym_bind = ELF32_ST_BIND(sym->st_info);
            if (sym_bind == STB_WEAK) {
                sym->st_value = 0;
            } else {
                error_noabort("undefined symbol '%s'", name);
            }
        } else if (sh_num < SHN_LORESERVE) {
            /* add section base */
            sym->st_value += s1->sections[sym->st_shndx]->sh_addr;
        }
    found: ;
    }
}
 
/* relocate a given section (CPU dependent) */
static void relocate_section(TCCState *s1, Section *s)
{
    Section *sr;
    Elf32_Rel *rel, *rel_end, *qrel;
    Elf32_Sym *sym;
    int type, sym_index;
    unsigned char *ptr;
    unsigned long val, addr;
#if defined(TCC_TARGET_I386)
    int esym_index;
#endif
 
    sr = s->reloc;
    rel_end = (Elf32_Rel *)(sr->data + sr->data_offset);
    qrel = (Elf32_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];
        val = sym->st_value;
        type = ELF32_R_TYPE(rel->r_info);
        addr = s->sh_addr + rel->r_offset;
 
        /* CPU specific */
        switch(type) {
#if defined(TCC_TARGET_I386)
        case R_386_32:
            if (s1->output_type == TCC_OUTPUT_DLL) {
                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++;
                    break;
                } else {
                    qrel->r_info = ELF32_R_INFO(0, R_386_RELATIVE);
                    qrel++;
                }
            }
            *(int *)ptr += val;
            break;
        case R_386_PC32:
            if (s1->output_type == TCC_OUTPUT_DLL) {
                /* DLL relocation */
                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++;
                    break;
                }
            }
            *(int *)ptr += val - addr;
            break;
        case R_386_PLT32:
            *(int *)ptr += val - addr;
            break;
        case R_386_GLOB_DAT:
        case R_386_JMP_SLOT:
            *(int *)ptr = val;
            break;
        case R_386_GOTPC:
            *(int *)ptr += s1->got->sh_addr - addr;
            break;
        case R_386_GOTOFF:
            *(int *)ptr += val - s1->got->sh_addr;
            break;
        case R_386_GOT32:
            /* we load the got offset */
            *(int *)ptr += s1->got_offsets[sym_index];
            break;
#elif defined(TCC_TARGET_ARM)
	case R_ARM_PC24:
	case R_ARM_PLT32:
	    {
                int x;
                x = (*(int *)ptr)&0xffffff;
                (*(int *)ptr) &= 0xff000000;
                if (x & 0x800000)
                    x -= 0x1000000;
                x *= 4;
                x += val - addr;
                if((x & 3) != 0 || x >= 0x4000000 || x < -0x4000000)
                    error("can't relocate value at %x",addr);
                x >>= 2;
                x &= 0xffffff;
                (*(int *)ptr) |= x;
	    }
	    break;
	case R_ARM_ABS32:
	    *(int *)ptr += val;
	    break;
	case R_ARM_GOTPC:
	    *(int *)ptr += s1->got->sh_addr - addr;
	    break;
        case R_ARM_GOT32:
            /* we load the got offset */
            *(int *)ptr += s1->got_offsets[sym_index];
            break;
	case R_ARM_COPY:
            break;
	default:
	    fprintf(stderr,"FIXME: handle reloc type %x at %lx [%.8x] to %lx\n",
                    type,addr,(unsigned int )ptr,val);
            break;
#elif defined(TCC_TARGET_C67)
	case R_C60_32:
	    *(int *)ptr += val;
	    break;
        case R_C60LO16:
            {
                uint32_t orig;
                
                /* put the low 16 bits of the absolute address */
                // add to what is already there
                
                orig  =   ((*(int *)(ptr  )) >> 7) & 0xffff;
                orig |=  (((*(int *)(ptr+4)) >> 7) & 0xffff) << 16;
                
                //patch both at once - assumes always in pairs Low - High
                
                *(int *) ptr    = (*(int *) ptr    & (~(0xffff << 7)) ) |  (((val+orig)      & 0xffff) << 7);
                *(int *)(ptr+4) = (*(int *)(ptr+4) & (~(0xffff << 7)) ) | ((((val+orig)>>16) & 0xffff) << 7);
            }
            break;
        case R_C60HI16:
            break;
        default:
	    fprintf(stderr,"FIXME: handle reloc type %x at %lx [%.8x] to %lx\n",
                    type,addr,(unsigned int )ptr,val);
            break;
#else
#error unsupported processor
#endif
        }
    }
    /* if the relocation is allocated, we change its symbol table */
    if (sr->sh_flags & SHF_ALLOC)
        sr->link = s1->dynsym;
}
 
/* relocate relocation table in 'sr' */
static void relocate_rel(TCCState *s1, Section *sr)
{
    Section *s;
    Elf32_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 < rel_end;
        rel++) {
        rel->r_offset += s->sh_addr;
    }
}
 
/* count the number of dynamic relocations so that we can reserve
   their space */
static int prepare_dynamic_rel(TCCState *s1, Section *sr)
{
    Elf32_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);
        switch(type) {
        case R_386_32:
            count++;
            break;
        case R_386_PC32:
            esym_index = s1->symtab_to_dynsym[sym_index];
            if (esym_index)
                count++;
            break;
        default:
            break;
        }
    }
    if (count) {
        /* allocate the section */
        sr->sh_flags |= SHF_ALLOC;
        sr->sh_size = count * sizeof(Elf32_Rel);
    }
    return count;
}
 
static void put_got_offset(TCCState *s1, int index, unsigned long val)
{
    int n;
    unsigned long *tab;
 
    if (index >= s1->nb_got_offsets) {
        /* find immediately bigger power of 2 and reallocate array */
        n = 1;
        while (index >= n)
            n *= 2;
        tab = tcc_realloc(s1->got_offsets, n * sizeof(unsigned long));
        if (!tab)
            error("memory full");
        s1->got_offsets = tab;
        memset(s1->got_offsets + s1->nb_got_offsets, 0,
               (n - s1->nb_got_offsets) * sizeof(unsigned long));
        s1->nb_got_offsets = n;
    }
    s1->got_offsets[index] = val;
}
 
/* XXX: suppress that */
static void put32(unsigned char *p, uint32_t val)
{
    p[0] = val;
    p[1] = val >> 8;
    p[2] = val >> 16;
    p[3] = val >> 24;
}
 
#if defined(TCC_TARGET_I386) || defined(TCC_TARGET_ARM)
static uint32_t get32(unsigned char *p)
{
    return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
}
#endif
 
static void build_got(TCCState *s1)
{
    unsigned char *ptr;
 
    /* 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), 
                0, s1->got->sh_num, "_GLOBAL_OFFSET_TABLE_");
    ptr = section_ptr_add(s1->got, 3 * sizeof(int));
    /* keep space for _DYNAMIC pointer, if present */
    put32(ptr, 0);
    /* two dummy got entries */
    put32(ptr + 4, 0);
    put32(ptr + 8, 0);
}
 
/* put a got entry corresponding to a symbol in symtab_section. 'size'
   and 'info' can be modifed if more precise info comes from the DLL */
static void put_got_entry(TCCState *s1,
                          int reloc_type, unsigned long size, int info, 
                          int sym_index)
{
    int index;
    const char *name;
    Elf32_Sym *sym;
    unsigned long offset;
    int *ptr;
 
    if (!s1->got)
        build_got(s1);
 
    /* if a got entry already exists for that symbol, no need to add one */
    if (sym_index < s1->nb_got_offsets &&
        s1->got_offsets[sym_index] != 0)
        return;
    
    put_got_offset(s1, sym_index, s1->got->data_offset);
 
    if (s1->dynsym) {
        sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
        name = symtab_section->link->data + sym->st_name;
        offset = sym->st_value;
#ifdef TCC_TARGET_I386
        if (reloc_type == R_386_JMP_SLOT) {
            Section *plt;
            uint8_t *p;
            int modrm;
 
            /* if we build a DLL, we add a %ebx offset */
            if (s1->output_type == TCC_OUTPUT_DLL)
                modrm = 0xa3;
            else
                modrm = 0x25;
 
            /* add a PLT entry */
            plt = s1->plt;
            if (plt->data_offset == 0) {
                /* first plt entry */
                p = section_ptr_add(plt, 16);
                p[0] = 0xff; /* pushl got + 4 */
                p[1] = modrm + 0x10;
                put32(p + 2, 4);
                p[6] = 0xff; /* jmp *(got + 8) */
                p[7] = modrm;
                put32(p + 8, 8);
            }
 
            p = section_ptr_add(plt, 16);
            p[0] = 0xff; /* jmp *(got + x) */
            p[1] = modrm;
            put32(p + 2, s1->got->data_offset);
            p[6] = 0x68; /* push $xxx */
            put32(p + 7, (plt->data_offset - 32) >> 1);
            p[11] = 0xe9; /* jmp plt_start */
            put32(p + 12, -(plt->data_offset));
 
            /* the symbol is modified so that it will be relocated to
               the PLT */
            if (s1->output_type == TCC_OUTPUT_EXE)
                offset = plt->data_offset - 16;
        }
#elif defined(TCC_TARGET_ARM)
	if (reloc_type == R_ARM_JUMP_SLOT) {
            Section *plt;
            uint8_t *p;
            
            /* if we build a DLL, we add a %ebx offset */
            if (s1->output_type == TCC_OUTPUT_DLL)
                error("DLLs unimplemented!");
 
            /* add a PLT entry */
            plt = s1->plt;
            if (plt->data_offset == 0) {
                /* first plt entry */
                p = section_ptr_add(plt, 16);
		put32(p     , 0xe52de004);
		put32(p +  4, 0xe59fe010);
		put32(p +  8, 0xe08fe00e);
		put32(p + 12, 0xe5bef008);
            }
 
            p = section_ptr_add(plt, 16);
	    put32(p  , 0xe59fc004);
	    put32(p+4, 0xe08fc00c);
	    put32(p+8, 0xe59cf000);
	    put32(p+12, s1->got->data_offset);
 
            /* the symbol is modified so that it will be relocated to
               the PLT */
            if (s1->output_type == TCC_OUTPUT_EXE)
                offset = plt->data_offset - 16;
        }
#elif defined(TCC_TARGET_C67)
        error("C67 got not implemented");
#else
#error unsupported CPU
#endif
        index = put_elf_sym(s1->dynsym, offset, 
                            size, info, 0, sym->st_shndx, name);
        /* put a got entry */
        put_elf_reloc(s1->dynsym, s1->got, 
                      s1->got->data_offset, 
                      reloc_type, index);
    }
    ptr = section_ptr_add(s1->got, sizeof(int));
    *ptr = 0;
}
 
/* build GOT and PLT entries */
static void build_got_entries(TCCState *s1)
{
    Section *s, *symtab;
    Elf32_Rel *rel, *rel_end;
    Elf32_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)
            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 < rel_end;
            rel++) {
            type = ELF32_R_TYPE(rel->r_info);
            switch(type) {
#if defined(TCC_TARGET_I386)
            case R_386_GOT32:
            case R_386_GOTOFF:
            case R_386_GOTPC:
            case R_386_PLT32:
                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];
                    /* look at the symbol got offset. If none, then add one */
                    if (type == R_386_GOT32)
                        reloc_type = R_386_GLOB_DAT;
                    else
                        reloc_type = R_386_JMP_SLOT;
                    put_got_entry(s1, reloc_type, sym->st_size, sym->st_info, 
                                  sym_index);
                }
                break;
#elif defined(TCC_TARGET_ARM)
	    case R_ARM_GOT32:
            case R_ARM_GOTOFF:
            case R_ARM_GOTPC:
            case R_ARM_PLT32:
                if (!s1->got)
                    build_got(s1);
                if (type == R_ARM_GOT32 || type == R_ARM_PLT32) {
                    sym_index = ELF32_R_SYM(rel->r_info);
                    sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
                    /* look at the symbol got offset. If none, then add one */
                    if (type == R_ARM_GOT32)
                        reloc_type = R_ARM_GLOB_DAT;
                    else
                        reloc_type = R_ARM_JUMP_SLOT;
                    put_got_entry(s1, reloc_type, sym->st_size, sym->st_info, 
                                  sym_index);
                }
                break;
#elif defined(TCC_TARGET_C67)
	    case R_C60_GOT32:
            case R_C60_GOTOFF:
            case R_C60_GOTPC:
            case R_C60_PLT32:
                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];
                    /* look at the symbol got offset. If none, then add one */
                    if (type == R_C60_GOT32)
                        reloc_type = R_C60_GLOB_DAT;
                    else
                        reloc_type = R_C60_JMP_SLOT;
                    put_got_entry(s1, reloc_type, sym->st_size, sym->st_info, 
                                  sym_index);
                }
                break;
#else
#error unsupported CPU
#endif
            default:
                break;
            }
        }
    }
}
 
static Section *new_symtab(TCCState *s1,
                           const char *symtab_name, int sh_type, int sh_flags,
                           const char *strtab_name, 
                           const char *hash_name, int hash_sh_flags)
{
    Section *symtab, *strtab, *hash;
    int *ptr, nb_buckets;
 
    symtab = new_section(s1, symtab_name, sh_type, sh_flags);
    symtab->sh_entsize = sizeof(Elf32_Sym);
    strtab = new_section(s1, strtab_name, SHT_STRTAB, sh_flags);
    put_elf_str(strtab, "");
    symtab->link = strtab;
    put_elf_sym(symtab, 0, 0, 0, 0, 0, NULL);
    
    nb_buckets = 1;
 
    hash = new_section(s1, hash_name, SHT_HASH, hash_sh_flags);
    hash->sh_entsize = sizeof(int);
    symtab->hash = hash;
    hash->link = symtab;
 
    ptr = section_ptr_add(hash, (2 + nb_buckets + 1) * sizeof(int));
    ptr[0] = nb_buckets;
    ptr[1] = 1;
    memset(ptr + 2, 0, (nb_buckets + 1) * sizeof(int));
    return symtab;
}
 
/* 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));
    dyn->d_tag = dt;
    dyn->d_un.d_val = val;
}
 
static void add_init_array_defines(TCCState *s1, const char *section_name)
{
    Section *s;
    long end_offset;
    char sym_start[1024];
    char sym_end[1024];
    
    snprintf(sym_start, sizeof(sym_start), "__%s_start", section_name + 1);
    snprintf(sym_end, sizeof(sym_end), "__%s_end", section_name + 1);
 
    s = find_section(s1, section_name);
    if (!s) {
        end_offset = 0;
        s = data_section;
    } else {
        end_offset = s->data_offset;
    }
 
    add_elf_sym(symtab_section, 
                0, 0,
                ELF32_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,
                s->sh_num, sym_end);
}
 
/* add tcc runtime libraries */
static void tcc_add_runtime(TCCState *s1)
{
    char buf[1024];
 
#ifdef CONFIG_TCC_BCHECK
    if (do_bounds_check) {
        unsigned long *ptr;
        Section *init_section;
        unsigned char *pinit;
        int sym_index;
 
        /* XXX: add an object file to do that */
        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,
                    bounds_section->sh_num, "__bounds_start");
        /* add bound check code */
        snprintf(buf, sizeof(buf), "%s/%s", tcc_lib_path, "bcheck.o");
        tcc_add_file(s1, buf);
#ifdef TCC_TARGET_I386
        if (s1->output_type != TCC_OUTPUT_MEMORY) {
            /* add 'call __bound_init()' in .init section */
            init_section = find_section(s1, ".init");
            pinit = section_ptr_add(init_section, 5);
            pinit[0] = 0xe8;
            put32(pinit + 1, -4);
            sym_index = find_elf_sym(symtab_section, "__bound_init");
            put_elf_reloc(symtab_section, init_section, 
                          init_section->data_offset - 4, R_386_PC32, sym_index);
        }
#endif
    }
#endif
    /* add libc */
    if (!s1->nostdlib) {
        tcc_add_library(s1, "c");
 
        snprintf(buf, sizeof(buf), "%s/%s", tcc_lib_path, "libtcc1.a");
        tcc_add_file(s1, buf);
    }
    /* add crt end if not memory output */
    if (s1->output_type != TCC_OUTPUT_MEMORY && !s1->nostdlib) {
        tcc_add_file(s1, CONFIG_TCC_CRT_PREFIX "/crtn.o");
    }
}
 
/* add various standard linker symbols (must be done after the
   sections are filled (for example after allocating common
   symbols)) */
static void tcc_add_linker_symbols(TCCState *s1)
{
    char buf[1024];
    int i;
    Section *s;
 
    add_elf_sym(symtab_section, 
                text_section->data_offset, 0,
                ELF32_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,
                data_section->sh_num, "_edata");
    add_elf_sym(symtab_section, 
                bss_section->data_offset, 0,
                ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0,
                bss_section->sh_num, "_end");
    /* horrible new standard ldscript defines */
    add_init_array_defines(s1, ".preinit_array");
    add_init_array_defines(s1, ".init_array");
    add_init_array_defines(s1, ".fini_array");
    
    /* add start and stop symbols for sections whose name can be
       expressed in C */
    for(i = 1; i < s1->nb_sections; i++) {
        s = s1->sections[i];
        if (s->sh_type == SHT_PROGBITS &&
            (s->sh_flags & SHF_ALLOC)) {
            const char *p;
            int ch;
 
            /* check if section name can be expressed in C */
            p = s->name;
            for(;;) {
                ch = *p;
                if (!ch)
                    break;
                if (!isid(ch) && !isnum(ch))
                    goto next_sec;
                p++;
            }
            snprintf(buf, sizeof(buf), "__start_%s", s->name);
            add_elf_sym(symtab_section, 
                        0, 0,
                        ELF32_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,
                        s->sh_num, buf);
        }
    next_sec: ;
    }
}
 
/* name of ELF interpreter */
#ifdef __FreeBSD__
static char elf_interp[] = "/usr/libexec/ld-elf.so.1";
#else
static char elf_interp[] = "/lib/ld-linux.so.2";
#endif
 
static void tcc_output_binary(TCCState *s1, FILE *f,
                              const int *section_order)
{
    Section *s;
    int i, offset, size;
 
    offset = 0;
    for(i=1;inb_sections;i++) {
        s = s1->sections[section_order[i]];
        if (s->sh_type != SHT_NOBITS &&
            (s->sh_flags & SHF_ALLOC)) {
            while (offset < s->sh_offset) {
                fputc(0, f);
                offset++;
            }
            size = s->sh_size;
            fwrite(s->data, 1, size, f);
            offset += size;
        }
    }
}
 
/* output an ELF file */
/* XXX: suppress unneeded sections */
int tcc_output_file(TCCState *s1, const char *filename)
{
    Elf32_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;
    Section *interp, *dynamic, *dynstr;
    unsigned long saved_dynamic_data_offset;
    Elf32_Sym *sym;
    int type, file_type;
    unsigned long rel_addr, rel_size;
    
    file_type = s1->output_type;
    s1->nb_errors = 0;
 
    if (file_type != TCC_OUTPUT_OBJ) {
        tcc_add_runtime(s1);
    }
 
    phdr = NULL;
    section_order = NULL;
    interp = NULL;
    dynamic = NULL;
    dynstr = NULL; /* avoid warning */
    saved_dynamic_data_offset = 0; /* avoid warning */
    
    if (file_type != TCC_OUTPUT_OBJ) {
        relocate_common_syms();
 
        tcc_add_linker_symbols(s1);
 
        if (!s1->static_link) {
            const char *name;
            int sym_index, index;
            Elf32_Sym *esym, *sym_end;
            
            if (file_type == TCC_OUTPUT_EXE) {
                char *ptr;
                /* add interpreter section only if executable */
                interp = new_section(s1, ".interp", SHT_PROGBITS, SHF_ALLOC);
                interp->sh_addralign = 1;
                ptr = section_ptr_add(interp, sizeof(elf_interp));
                strcpy(ptr, elf_interp);
            }
        
            /* add dynamic symbol table */
            s1->dynsym = new_symtab(s1, ".dynsym", SHT_DYNSYM, SHF_ALLOC,
                                    ".dynstr", 
                                    ".hash", SHF_ALLOC);
            dynstr = s1->dynsym->link;
            
            /* add dynamic section */
            dynamic = new_section(s1, ".dynamic", SHT_DYNAMIC, 
                                  SHF_ALLOC | SHF_WRITE);
            dynamic->link = dynstr;
            dynamic->sh_entsize = sizeof(Elf32_Dyn);
        
            /* add PLT */
            s1->plt = new_section(s1, ".plt", SHT_PROGBITS, 
                                  SHF_ALLOC | SHF_EXECINSTR);
            s1->plt->sh_entsize = 4;
 
            build_got(s1);
 
            /* scan for undefined symbols and see if they are in the
               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 + 
                                    symtab_section->data_offset);
            if (file_type == TCC_OUTPUT_EXE) {
                for(sym = (Elf32_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);
                            if (type == STT_FUNC) {
                                put_got_entry(s1, R_JMP_SLOT, esym->st_size, 
                                              esym->st_info, 
                                              sym - (Elf32_Sym *)symtab_section->data);
                            } else if (type == STT_OBJECT) {
                                unsigned long offset;
                                offset = bss_section->data_offset;
                                /* XXX: which alignment ? */
                                offset = (offset + 16 - 1) & -16;
                                index = put_elf_sym(s1->dynsym, offset, esym->st_size, 
                                                    esym->st_info, 0, 
                                                    bss_section->sh_num, name);
                                put_elf_reloc(s1->dynsym, bss_section, 
                                              offset, R_COPY, index);
                                offset += esym->st_size;
                                bss_section->data_offset = offset;
                            }
                        } else {
                                /* 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 ||
                                !strcmp(name, "_fp_hw")) {
                            } else {
                                error_noabort("undefined symbol '%s'", name);
                            }
                        }
                    } else if (s1->rdynamic && 
                               ELF32_ST_BIND(sym->st_info) != STB_LOCAL) {
                        /* if -rdynamic option, then export all non
                           local symbols */
                        name = symtab_section->link->data + sym->st_name;
                        put_elf_sym(s1->dynsym, sym->st_value, sym->st_size, 
                                    sym->st_info, 0, 
                                    sym->st_shndx, name);
                    }
                }
            
                if (s1->nb_errors)
                    goto fail;
 
                /* now look at unresolved dynamic symbols and export
                   corresponding symbol */
                sym_end = (Elf32_Sym *)(s1->dynsymtab_section->data + 
                                        s1->dynsymtab_section->data_offset);
                for(esym = (Elf32_Sym *)s1->dynsymtab_section->data + 1; 
                    esym < sym_end;
                    esym++) {
                    if (esym->st_shndx == SHN_UNDEF) {
                        name = s1->dynsymtab_section->link->data + esym->st_name;
                        sym_index = find_elf_sym(symtab_section, name);
                        if (sym_index) {
                            /* XXX: avoid adding a symbol if already
                               present because of -rdynamic ? */
                            sym = &((Elf32_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) {
                                /* weak symbols can stay undefined */
                            } else {
                                warning("undefined dynamic symbol '%s'", name);
                            }
                        }
                    }
                }
            } else {
                int nb_syms;
                /* shared library case : we simply export all the global symbols */
                nb_syms = symtab_section->data_offset / sizeof(Elf32_Sym);
                s1->symtab_to_dynsym = tcc_mallocz(sizeof(int) * nb_syms);
                for(sym = (Elf32_Sym *)symtab_section->data + 1; 
                    sym < sym_end;
                    sym++) {
                    if (ELF32_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] = 
                            index;
                    }
                }
            }
 
            build_got_entries(s1);
        
            /* add a list of needed dlls */
            for(i = 0; i < s1->nb_loaded_dlls; i++) {
                DLLReference *dllref = s1->loaded_dlls[i];
                if (dllref->level == 0)
                    put_dt(dynamic, DT_NEEDED, put_elf_str(dynstr, dllref->name));
            }
            /* XXX: currently, since we do not handle PIC code, we
               must relocate the readonly segments */
            if (file_type == TCC_OUTPUT_DLL)
                put_dt(dynamic, DT_TEXTREL, 0);
 
            /* add necessary space for other entries */
            saved_dynamic_data_offset = dynamic->data_offset;
            dynamic->data_offset += 8 * 9;
        } else {
            /* still need to build got entries in case of static link */
            build_got_entries(s1);
        }
    }
 
    memset(&ehdr, 0, sizeof(ehdr));
 
    /* we add a section for symbols */
    strsec = new_section(s1, ".shstrtab", SHT_STRTAB, 0);
    put_elf_str(strsec, "");
    
    /* compute number of sections */
    shnum = s1->nb_sections;
 
    /* this array is used to reorder sections in the output file */
    section_order = tcc_malloc(sizeof(int) * shnum);
    section_order[0] = 0;
    sh_order_index = 1;
    
    /* compute number of program headers */
    switch(file_type) {
    default:
    case TCC_OUTPUT_OBJ:
        phnum = 0;
        break;
    case TCC_OUTPUT_EXE:
        if (!s1->static_link)
            phnum = 4;
        else
            phnum = 2;
        break;
    case TCC_OUTPUT_DLL:
        phnum = 3;
        break;
    }
 
    /* allocate strings for section names and decide if an unallocated
       section should be output */
    /* NOTE: the strsec section comes last, so its size is also
       correct ! */
    for(i = 1; i < s1->nb_sections; i++) {
        s = s1->sections[i];
        s->sh_name = put_elf_str(strsec, s->name);
        /* 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_flags & SHF_ALLOC)) {
            prepare_dynamic_rel(s1, s);
        } else if (do_debug || 
            file_type == TCC_OUTPUT_OBJ || 
            (s->sh_flags & SHF_ALLOC) ||
            i == (s1->nb_sections - 1)) {
            /* we output all sections if debug or object file */
            s->sh_size = s->data_offset;
        }
    }
 
    /* allocate program segment headers */
    phdr = tcc_mallocz(phnum * sizeof(Elf32_Phdr));
        
    if (s1->output_format == TCC_OUTPUT_FORMAT_ELF) {
        file_offset = sizeof(Elf32_Ehdr) + phnum * sizeof(Elf32_Phdr);
    } else {
        file_offset = 0;
    }
    if (phnum > 0) {
        /* compute section to program header mapping */
        if (s1->has_text_addr) { 
            int a_offset, p_offset;
            addr = s1->text_addr;
            /* we ensure that (addr % ELF_PAGE_SIZE) == file_offset %
               ELF_PAGE_SIZE */
            a_offset = addr & (ELF_PAGE_SIZE - 1);
            p_offset = file_offset & (ELF_PAGE_SIZE - 1);
            if (a_offset < p_offset) 
                a_offset += ELF_PAGE_SIZE;
            file_offset += (a_offset - p_offset);
        } else {
            if (file_type == TCC_OUTPUT_DLL)
                addr = 0;
            else
                addr = ELF_START_ADDR;
            /* compute address after headers */
            addr += (file_offset & (ELF_PAGE_SIZE - 1));
        }
        
        /* dynamic relocation table information, for .dynamic section */
        rel_size = 0;
        rel_addr = 0;
 
        /* leave one program header for the program interpreter */
        ph = &phdr[0];
        if (interp)
            ph++;
 
        for(j = 0; j < 2; j++) {
            ph->p_type = PT_LOAD;
            if (j == 0)
                ph->p_flags = PF_R | PF_X;
            else
                ph->p_flags = PF_R | PF_W;
            ph->p_align = ELF_PAGE_SIZE;
            
            /* we do the following ordering: interp, symbol tables,
               relocations, progbits, nobits */
            /* XXX: do faster and simpler sorting */
            for(k = 0; k < 5; k++) {
                for(i = 1; i < s1->nb_sections; i++) {
                    s = s1->sections[i];
                    /* compute if section should be included */
                    if (j == 0) {
                        if ((s->sh_flags & (SHF_ALLOC | SHF_WRITE)) != 
                            SHF_ALLOC)
                            continue;
                    } else {
                        if ((s->sh_flags & (SHF_ALLOC | SHF_WRITE)) != 
                            (SHF_ALLOC | SHF_WRITE))
                            continue;
                    }
                    if (s == interp) {
                        if (k != 0)
                            continue;
                    } else if (s->sh_type == SHT_DYNSYM ||
                               s->sh_type == SHT_STRTAB ||
                               s->sh_type == SHT_HASH) {
                        if (k != 1)
                            continue;
                    } else if (s->sh_type == SHT_REL) {
                        if (k != 2)
                            continue;
                    } else if (s->sh_type == SHT_NOBITS) {
                        if (k != 4)
                            continue;
                    } else {
                        if (k != 3)
                            continue;
                    }
                    section_order[sh_order_index++] = i;
 
                    /* section matches: we align it and add its size */
                    tmp = addr;
                    addr = (addr + s->sh_addralign - 1) & 
                        ~(s->sh_addralign - 1);
                    file_offset += addr - tmp;
                    s->sh_offset = file_offset;
                    s->sh_addr = addr;
                    
                    /* update program header infos */
                    if (ph->p_offset == 0) {
                        ph->p_offset = file_offset;
                        ph->p_vaddr = addr;
                        ph->p_paddr = ph->p_vaddr;
                    }
                    /* update dynamic relocation infos */
                    if (s->sh_type == SHT_REL) {
                        if (rel_size == 0)
                            rel_addr = addr;
                        rel_size += s->sh_size;
                    }
                    addr += s->sh_size;
                    if (s->sh_type != SHT_NOBITS)
                        file_offset += s->sh_size;
                }
            }
            ph->p_filesz = file_offset - ph->p_offset;
            ph->p_memsz = addr - ph->p_vaddr;
            ph++;
            if (j == 0) {
                if (s1->output_format == TCC_OUTPUT_FORMAT_ELF) {
                    /* if in the middle of a page, we duplicate the page in
                       memory so that one copy is RX and the other is RW */
                    if ((addr & (ELF_PAGE_SIZE - 1)) != 0)
                        addr += ELF_PAGE_SIZE;
                } else {
                    addr = (addr + ELF_PAGE_SIZE - 1) & ~(ELF_PAGE_SIZE - 1);
                    file_offset = (file_offset + ELF_PAGE_SIZE - 1) & 
                        ~(ELF_PAGE_SIZE - 1);
                }
            }
        }
 
        /* if interpreter, then add corresponing program header */
        if (interp) {
            ph = &phdr[0];
            
            ph->p_type = PT_INTERP;
            ph->p_offset = interp->sh_offset;
            ph->p_vaddr = interp->sh_addr;
            ph->p_paddr = ph->p_vaddr;
            ph->p_filesz = interp->sh_size;
            ph->p_memsz = interp->sh_size;
            ph->p_flags = PF_R;
            ph->p_align = interp->sh_addralign;
        }
        
        /* if dynamic section, then add corresponing program header */
        if (dynamic) {
            Elf32_Sym *sym_end;
 
            ph = &phdr[phnum - 1];
            
            ph->p_type = PT_DYNAMIC;
            ph->p_offset = dynamic->sh_offset;
            ph->p_vaddr = dynamic->sh_addr;
            ph->p_paddr = ph->p_vaddr;
            ph->p_filesz = dynamic->sh_size;
            ph->p_memsz = dynamic->sh_size;
            ph->p_flags = PF_R | PF_W;
            ph->p_align = dynamic->sh_addralign;
 
            /* put GOT dynamic section address */
            put32(s1->got->data, dynamic->sh_addr);
 
            /* relocate the PLT */
            if (file_type == TCC_OUTPUT_EXE) {
                uint8_t *p, *p_end;
 
                p = s1->plt->data;
                p_end = p + s1->plt->data_offset;
                if (p < p_end) {
#if defined(TCC_TARGET_I386)
                    put32(p + 2, get32(p + 2) + s1->got->sh_addr);
                    put32(p + 8, get32(p + 8) + s1->got->sh_addr);
                    p += 16;
                    while (p < p_end) {
                        put32(p + 2, get32(p + 2) + s1->got->sh_addr);
                        p += 16;
                    }
#elif defined(TCC_TARGET_ARM)
		    int x;
		    x=s1->got->sh_addr - s1->plt->sh_addr - 12;
		    p +=16;
		    while (p < p_end) {
		        put32(p + 12, x + get32(p + 12) + s1->plt->data - p);
			p += 16;
		    }
#elif defined(TCC_TARGET_C67)
                    /* XXX: TODO */
#else
#error unsupported CPU
#endif
                }
            }
 
            /* relocate symbols in .dynsym */
            sym_end = (Elf32_Sym *)(s1->dynsym->data + s1->dynsym->data_offset);
            for(sym = (Elf32_Sym *)s1->dynsym->data + 1; 
                sym < sym_end;
                sym++) {
                if (sym->st_shndx == SHN_UNDEF) {
                    /* relocate to the PLT if the symbol corresponds
                       to a PLT entry */
                    if (sym->st_value)
                        sym->st_value += s1->plt->sh_addr;
                } else if (sym->st_shndx < SHN_LORESERVE) {
                    /* do symbol relocation */
                    sym->st_value += s1->sections[sym->st_shndx]->sh_addr;
                }
            }
 
            /* put dynamic section entries */
            dynamic->data_offset = saved_dynamic_data_offset;
            put_dt(dynamic, DT_HASH, s1->dynsym->hash->sh_addr);
            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_REL, rel_addr);
            put_dt(dynamic, DT_RELSZ, rel_size);
            put_dt(dynamic, DT_RELENT, sizeof(Elf32_Rel));
            put_dt(dynamic, DT_NULL, 0);
        }
 
        ehdr.e_phentsize = sizeof(Elf32_Phdr);
        ehdr.e_phnum = phnum;
        ehdr.e_phoff = sizeof(Elf32_Ehdr);
    }
 
    /* all other sections come after */
    for(i = 1; i < s1->nb_sections; i++) {
        s = s1->sections[i];
        if (phnum > 0 && (s->sh_flags & SHF_ALLOC))
            continue;
        section_order[sh_order_index++] = i;
        
        file_offset = (file_offset + s->sh_addralign - 1) & 
            ~(s->sh_addralign - 1);
        s->sh_offset = file_offset;
        if (s->sh_type != SHT_NOBITS)
            file_offset += s->sh_size;
    }
    
    /* if building executable or DLL, then relocate each section
       except the GOT which is already relocated */
    if (file_type != TCC_OUTPUT_OBJ) {
        relocate_syms(s1, 0);
 
        if (s1->nb_errors != 0) {
        fail:
            ret = -1;
            goto the_end;
        }
 
        /* relocate sections */
        /* XXX: ignore sections with allocated relocations ? */
        for(i = 1; i < s1->nb_sections; i++) {
            s = s1->sections[i];
            if (s->reloc && s != s1->got)
                relocate_section(s1, s);
        }
 
        /* relocate relocation entries if the relocation tables are
           allocated in the executable */
        for(i = 1; i < s1->nb_sections; i++) {
            s = s1->sections[i];
            if ((s->sh_flags & SHF_ALLOC) &&
                s->sh_type == SHT_REL) {
                relocate_rel(s1, s);
            }
        }
 
        /* get entry point address */
        if (file_type == TCC_OUTPUT_EXE)
            ehdr.e_entry = (unsigned long)tcc_get_symbol_err(s1, "_start");
        else
            ehdr.e_entry = text_section->sh_addr; /* XXX: is it correct ? */
    }
 
    /* write elf file */
    if (file_type == TCC_OUTPUT_OBJ)
        mode = 0666;
    else
        mode = 0777;
    fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, mode); 
    if (fd < 0) {
        error_noabort("could not write '%s'", filename);
        goto fail;
    }
    f = fdopen(fd, "wb");
 
#ifdef TCC_TARGET_COFF
    if (s1->output_format == TCC_OUTPUT_FORMAT_COFF) {
        tcc_output_coff(s1, f);
    } else
#endif
    if (s1->output_format == TCC_OUTPUT_FORMAT_ELF) {
        sort_syms(s1, symtab_section);
        
        /* align to 4 */
        file_offset = (file_offset + 3) & -4;
    
        /* fill header */
        ehdr.e_ident[0] = ELFMAG0;
        ehdr.e_ident[1] = ELFMAG1;
        ehdr.e_ident[2] = ELFMAG2;
        ehdr.e_ident[3] = ELFMAG3;
        ehdr.e_ident[4] = ELFCLASS32;
        ehdr.e_ident[5] = ELFDATA2LSB;
        ehdr.e_ident[6] = EV_CURRENT;
#ifdef __FreeBSD__
        ehdr.e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
#endif
#ifdef TCC_TARGET_ARM
        ehdr.e_ident[EI_OSABI] = ELFOSABI_ARM;
#endif
        switch(file_type) {
        default:
        case TCC_OUTPUT_EXE:
            ehdr.e_type = ET_EXEC;
            break;
        case TCC_OUTPUT_DLL:
            ehdr.e_type = ET_DYN;
            break;
        case TCC_OUTPUT_OBJ:
            ehdr.e_type = ET_REL;
            break;
        }
        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_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);
 
        for(i=1;inb_sections;i++) {
            s = s1->sections[section_order[i]];
            if (s->sh_type != SHT_NOBITS) {
                while (offset < s->sh_offset) {
                    fputc(0, f);
                    offset++;
                }
                size = s->sh_size;
                fwrite(s->data, 1, size, f);
                offset += size;
            }
        }
 
        /* output section headers */
        while (offset < ehdr.e_shoff) {
            fputc(0, f);
            offset++;
        }
    
        for(i=0;inb_sections;i++) {
            sh = &shdr;
            memset(sh, 0, sizeof(Elf32_Shdr));
            s = s1->sections[i];
            if (s) {
                sh->sh_name = s->sh_name;
                sh->sh_type = s->sh_type;
                sh->sh_flags = s->sh_flags;
                sh->sh_entsize = s->sh_entsize;
                sh->sh_info = s->sh_info;
                if (s->link)
                    sh->sh_link = s->link->sh_num;
                sh->sh_addralign = s->sh_addralign;
                sh->sh_addr = s->sh_addr;
                sh->sh_offset = s->sh_offset;
                sh->sh_size = s->sh_size;
            }
            fwrite(sh, 1, sizeof(Elf32_Shdr), f);
        }
    } else {
        tcc_output_binary(s1, f, section_order);
    }
    fclose(f);
 
    ret = 0;
 the_end:
    tcc_free(s1->symtab_to_dynsym);
    tcc_free(section_order);
    tcc_free(phdr);
    tcc_free(s1->got_offsets);
    return ret;
}
 
static void *load_data(int fd, unsigned long file_offset, unsigned long size)
{
    void *data;
 
    data = tcc_malloc(size);
    lseek(fd, file_offset, SEEK_SET);
    read(fd, data, size);
    return data;
}
 
typedef struct SectionMergeInfo {
    Section *s;            /* corresponding existing section */
    unsigned long offset;  /* offset of the new section in the existing section */
    uint8_t new_section;       /* true if section 's' was added */
    uint8_t link_once;         /* true if link once section */
} SectionMergeInfo;
 
/* load an object file and merge it with current files */
/* XXX: handle correctly stab (debug) info */
static int tcc_load_object_file(TCCState *s1, 
                                int fd, unsigned long file_offset)
{ 
    Elf32_Ehdr ehdr;
    Elf32_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;
    Section *s;
 
    if (read(fd, &ehdr, sizeof(ehdr)) != sizeof(ehdr))
        goto fail1;
    if (ehdr.e_ident[0] != ELFMAG0 ||
        ehdr.e_ident[1] != ELFMAG1 ||
        ehdr.e_ident[2] != ELFMAG2 ||
        ehdr.e_ident[3] != ELFMAG3)
        goto fail1;
    /* test if object file */
    if (ehdr.e_type != ET_REL)
        goto fail1;
    /* test CPU specific stuff */
    if (ehdr.e_ident[5] != ELFDATA2LSB ||
        ehdr.e_machine != EM_TCC_TARGET) {
    fail1:
        error_noabort("invalid object file");
        return -1;
    }
    /* read sections */
    shdr = load_data(fd, file_offset + ehdr.e_shoff, 
                     sizeof(Elf32_Shdr) * ehdr.e_shnum);
    sm_table = tcc_mallocz(sizeof(SectionMergeInfo) * ehdr.e_shnum);
    
    /* load section names */
    sh = &shdr[ehdr.e_shstrndx];
    strsec = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
 
    /* load symtab and strtab */
    old_to_new_syms = NULL;
    symtab = NULL;
    strtab = NULL;
    nb_syms = 0;
    for(i = 1; i < ehdr.e_shnum; i++) {
        sh = &shdr[i];
        if (sh->sh_type == SHT_SYMTAB) {
            if (symtab) {
                error_noabort("object must contain only one symtab");
            fail:
                ret = -1;
                goto the_end;
            }
            nb_syms = sh->sh_size / sizeof(Elf32_Sym);
            symtab = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
            sm_table[i].s = symtab_section;
 
            /* now load strtab */
            sh = &shdr[sh->sh_link];
            strtab = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
        }
    }
        
    /* now examine each section and try to merge its content with the
       ones in memory */
    for(i = 1; i < ehdr.e_shnum; i++) {
        /* no need to examine section name strtab */
        if (i == ehdr.e_shstrndx)
            continue;
        sh = &shdr[i];
        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_NOBITS)
            continue;
        if (sh->sh_addralign < 1)
            sh->sh_addralign = 1;
        /* find corresponding section, if any */
        for(j = 1; j < s1->nb_sections;j++) {
            s = s1->sections[j];
            if (!strcmp(s->name, sh_name)) {
                if (!strncmp(sh_name, ".gnu.linkonce", 
                             sizeof(".gnu.linkonce") - 1)) {
                    /* if a 'linkonce' section is already present, we
                       do not add it again. It is a little tricky as
                       symbols can still be defined in
                       it. */
                    sm_table[i].link_once = 1;
                    goto next;
                } else {
                    goto found;
                }
            }
        }
        /* not found: create new section */
        s = new_section(s1, sh_name, sh->sh_type, sh->sh_flags);
        /* take as much info as possible from the section. sh_link and
           sh_info will be updated later */
        s->sh_addralign = sh->sh_addralign;
        s->sh_entsize = sh->sh_entsize;
        sm_table[i].new_section = 1;
    found:
        if (sh->sh_type != s->sh_type) {
            error_noabort("invalid section type");
            goto fail;
        }
 
        /* align start of section */
        offset = s->data_offset;
        size = sh->sh_addralign - 1;
        offset = (offset + size) & ~size;
        if (sh->sh_addralign > s->sh_addralign)
            s->sh_addralign = sh->sh_addralign;
        s->data_offset = offset;
        sm_table[i].offset = offset;
        sm_table[i].s = s;
        /* concatenate sections */
        size = sh->sh_size;
        if (sh->sh_type != SHT_NOBITS) {
            unsigned char *ptr;
            lseek(fd, file_offset + sh->sh_offset, SEEK_SET);
            ptr = section_ptr_add(s, size);
            read(fd, ptr, size);
        } else {
            s->data_offset += size;
        }
    next: ;
    }
 
    /* second short pass to update sh_link and sh_info fields of new
       sections */
    sm = sm_table;
    for(i = 1; i < ehdr.e_shnum; i++) {
        s = sm_table[i].s;
        if (!s || !sm_table[i].new_section)
            continue;
        sh = &shdr[i];
        if (sh->sh_link > 0)
            s->link = sm_table[sh->sh_link].s;
        if (sh->sh_type == SHT_REL) {
            s->sh_info = sm_table[sh->sh_info].s->sh_num;
            /* update backward link */
            s1->sections[s->sh_info]->reloc = s;
        }
    }
 
    /* resolve symbols */
    old_to_new_syms = tcc_mallocz(nb_syms * sizeof(int));
 
    sym = symtab + 1;
    for(i = 1; i < nb_syms; i++, sym++) {
        if (sym->st_shndx != SHN_UNDEF &&
            sym->st_shndx < SHN_LORESERVE) {
            sm = &sm_table[sym->st_shndx];
            if (sm->link_once) {
                /* 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) {
                    name = strtab + sym->st_name;
                    sym_index = find_elf_sym(symtab_section, name);
                    if (sym_index)
                        old_to_new_syms[i] = sym_index;
                }
                continue;
            }
            /* if no corresponding section added, no need to add symbol */
            if (!sm->s)
                continue;
            /* convert section number */
            sym->st_shndx = sm->s->sh_num;
            /* offset value */
            sym->st_value += sm->offset;
        }
        /* add symbol */
        name = strtab + sym->st_name;
        sym_index = add_elf_sym(symtab_section, sym->st_value, sym->st_size, 
                                sym->st_info, sym->st_other, 
                                sym->st_shndx, name);
        old_to_new_syms[i] = sym_index;
    }
 
    /* third pass to patch relocation entries */
    for(i = 1; i < ehdr.e_shnum; i++) {
        s = sm_table[i].s;
        if (!s)
            continue;
        sh = &shdr[i];
        offset = sm_table[i].offset;
        switch(s->sh_type) {
        case SHT_REL:
            /* 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 < 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);
                /* NOTE: only one symtab assumed */
                if (sym_index >= nb_syms)
                    goto invalid_reloc;
                sym_index = old_to_new_syms[sym_index];
                if (!sym_index) {
                invalid_reloc:
                    error_noabort("Invalid relocation entry");
                    goto fail;
                }
                rel->r_info = ELF32_R_INFO(sym_index, type);
                /* offset the relocation offset */
                rel->r_offset += offseti;
            }
            break;
        default:
            break;
        }
    }
    
    ret = 0;
 the_end:
    tcc_free(symtab);
    tcc_free(strtab);
    tcc_free(old_to_new_syms);
    tcc_free(sm_table);
    tcc_free(strsec);
    tcc_free(shdr);
    return ret;
}
 
#define ARMAG  "!\012"	/* For COFF and a.out archives */
 
typedef struct ArchiveHeader {
    char ar_name[16];		/* name of this member */
    char ar_date[12];		/* file mtime */
    char ar_uid[6];		/* owner uid; printed as decimal */
    char ar_gid[6];		/* owner gid; printed as decimal */
    char ar_mode[8];		/* file mode, printed as octal   */
    char ar_size[10];		/* file size, printed as decimal */
    char ar_fmag[2];		/* should contain ARFMAG */
} ArchiveHeader;
 
static int get_be32(const uint8_t *b)
{
    return b[3] | (b[2] << 8) | (b[1] << 16) | (b[0] << 24);
}
 
/* load only the objects which resolve undefined symbols */
static int tcc_load_alacarte(TCCState *s1, int fd, int size)
{
    int i, bound, nsyms, sym_index, off, ret;
    uint8_t *data;
    const char *ar_names, *p;
    const uint8_t *ar_index;
    Elf32_Sym *sym;
 
    data = tcc_malloc(size);
    if (read(fd, data, size) != size)
        goto fail;
    nsyms = get_be32(data);
    ar_index = data + 4;
    ar_names = ar_index + nsyms * 4;
 
    do {
	bound = 0;
	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];
		if(sym->st_shndx == SHN_UNDEF) {
		    off = get_be32(ar_index + i * 4) + sizeof(ArchiveHeader);
#if 0
		    printf("%5d\t%s\t%08x\n", i, p, sym->st_shndx);
#endif
		    ++bound;
		    lseek(fd, off, SEEK_SET);
		    if(tcc_load_object_file(s1, fd, off) < 0) {
                    fail:
                        ret = -1;
                        goto the_end;
                    }
		}
	    }
	}
    } while(bound);
    ret = 0;
 the_end:
    tcc_free(data);
    return ret;
}
 
/* load a '.a' file */
static int tcc_load_archive(TCCState *s1, int fd)
{
    ArchiveHeader hdr;
    char ar_size[11];
    char ar_name[17];
    char magic[8];
    int size, len, i;
    unsigned long file_offset;
 
    /* skip magic which was already checked */
    read(fd, magic, sizeof(magic));
    
    for(;;) {
        len = read(fd, &hdr, sizeof(hdr));
        if (len == 0)
            break;
        if (len != sizeof(hdr)) {
            error_noabort("invalid archive");
            return -1;
        }
        memcpy(ar_size, hdr.ar_size, sizeof(hdr.ar_size));
        ar_size[sizeof(hdr.ar_size)] = '\0';
        size = strtol(ar_size, NULL, 0);
        memcpy(ar_name, hdr.ar_name, sizeof(hdr.ar_name));
        for(i = sizeof(hdr.ar_name) - 1; i >= 0; i--) {
            if (ar_name[i] != ' ')
                break;
        }
        ar_name[i + 1] = '\0';
        //        printf("name='%s' size=%d %s\n", ar_name, size, ar_size);
        file_offset = lseek(fd, 0, SEEK_CUR);
        /* align to even */
        size = (size + 1) & ~1;
        if (!strcmp(ar_name, "/")) {
            /* coff symbol table : we handle it */
	    if(s1->alacarte_link)
		return tcc_load_alacarte(s1, fd, size);
        } else if (!strcmp(ar_name, "//") ||
                   !strcmp(ar_name, "__.SYMDEF") ||
                   !strcmp(ar_name, "__.SYMDEF/") ||
                   !strcmp(ar_name, "ARFILENAMES/")) {
            /* skip symbol table or archive names */
        } else {
            if (tcc_load_object_file(s1, fd, file_offset) < 0)
                return -1;
        }
        lseek(fd, file_offset + size, SEEK_SET);
    }
    return 0;
}
 
/* load a DLL and all referenced DLLs. 'level = 0' means that the DLL
   is referenced by the user (so it should be added as DT_NEEDED in
   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;
    int i, nb_syms, nb_dts, sym_bind, ret;
    Elf32_Sym *sym, *dynsym;
    Elf32_Dyn *dt, *dynamic;
    unsigned char *dynstr;
    const char *name, *soname, *p;
    DLLReference *dllref;
    
    read(fd, &ehdr, sizeof(ehdr));
 
    /* test CPU specific stuff */
    if (ehdr.e_ident[5] != ELFDATA2LSB ||
        ehdr.e_machine != EM_TCC_TARGET) {
        error_noabort("bad architecture");
        return -1;
    }
 
    /* read sections */
    shdr = load_data(fd, ehdr.e_shoff, sizeof(Elf32_Shdr) * ehdr.e_shnum);
 
    /* load dynamic section and dynamic symbols */
    nb_syms = 0;
    nb_dts = 0;
    dynamic = NULL;
    dynsym = NULL; /* avoid warning */
    dynstr = NULL; /* avoid warning */
    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);
            dynamic = load_data(fd, sh->sh_offset, sh->sh_size);
            break;
        case SHT_DYNSYM:
            nb_syms = sh->sh_size / sizeof(Elf32_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);
            break;
        default:
            break;
        }
    }
    
    /* compute the real library name */
    soname = filename;
    p = strrchr(soname, '/');
    if (p)
        soname = p + 1;
        
    for(i = 0, dt = dynamic; i < nb_dts; i++, dt++) {
        if (dt->d_tag == DT_SONAME) {
            soname = dynstr + dt->d_un.d_val;
        }
    }
 
    /* if the dll is already loaded, do not load it */
    for(i = 0; i < s1->nb_loaded_dlls; i++) {
        dllref = s1->loaded_dlls[i];
        if (!strcmp(soname, dllref->name)) {
            /* but update level if needed */
            if (level < dllref->level)
                dllref->level = level;
            ret = 0;
            goto the_end;
        }
    }
    
    //    printf("loading dll '%s'\n", soname);
 
    /* add the dll and its level */
    dllref = tcc_malloc(sizeof(DLLReference) + strlen(soname));
    dllref->level = level;
    strcpy(dllref->name, soname);
    dynarray_add((void ***)&s1->loaded_dlls, &s1->nb_loaded_dlls, dllref);
 
    /* 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);
        if (sym_bind == STB_LOCAL)
            continue;
        name = dynstr + sym->st_name;
        add_elf_sym(s1->dynsymtab_section, sym->st_value, sym->st_size,
                    sym->st_info, sym->st_other, sym->st_shndx, name);
    }
 
    /* load all referenced DLLs */
    for(i = 0, dt = dynamic; i < nb_dts; i++, dt++) {
        switch(dt->d_tag) {
        case DT_NEEDED:
            name = dynstr + dt->d_un.d_val;
            for(i = 0; i < s1->nb_loaded_dlls; i++) {
                dllref = s1->loaded_dlls[i];
                if (!strcmp(name, dllref->name))
                    goto already_loaded;
            }
            if (tcc_add_dll(s1, name, AFF_REFERENCED_DLL) < 0) {
                error_noabort("referenced dll '%s' not found", name);
                ret = -1;
                goto the_end;
            }
        already_loaded:
            break;
        }
    }
    ret = 0;
 the_end:
    tcc_free(dynstr);
    tcc_free(dynsym);
    tcc_free(dynamic);
    tcc_free(shdr);
    return ret;
}
 
#define LD_TOK_NAME 256
#define LD_TOK_EOF  (-1)
 
/* return next ld script token */
static int ld_next(TCCState *s1, char *name, int name_size)
{
    int c;
    char *q;
 
 redo:
    switch(ch) {
    case ' ':
    case '\t':
    case '\f':
    case '\v':
    case '\r':
    case '\n':
        input();
        goto redo;
    case '/':
        minp();
        if (ch == '*') {
            file->buf_ptr = parse_comment(file->buf_ptr);
            ch = file->buf_ptr[0];
            goto redo;
        } else {
            q = name;
            *q++ = '/';
            goto parse_name;
        }
        break;
    case 'a' ... 'z':
    case 'A' ... 'Z':
    case '_':
    case '\\':
    case '.':
    case '$':
    case '~':
        q = name;
    parse_name:
        for(;;) {
            if (!((ch >= 'a' && ch <= 'z') ||
                  (ch >= 'A' && ch <= 'Z') ||
                  (ch >= '0' && ch <= '9') ||
                  strchr("/.-_+=$:\\,~", ch)))
                break;
            if ((q - name) < name_size - 1) {
                *q++ = ch;
            }
            minp();
        }
        *q = '\0';
        c = LD_TOK_NAME;
        break;
    case CH_EOF:
        c = LD_TOK_EOF;
        break;
    default:
        c = ch;
        input();
        break;
    }
#if 0
    printf("tok=%c %d\n", c, c);
    if (c == LD_TOK_NAME)
        printf("  name=%s\n", name);
#endif
    return c;
}
 
/* interpret a subset of GNU ldscripts to handle the dummy libc.so
   files */
static int tcc_load_ldscript(TCCState *s1)
{
    char cmd[64];
    char filename[1024];
    int t;
    
    ch = file->buf_ptr[0];
    ch = handle_eob();
    for(;;) {
        t = ld_next(s1, cmd, sizeof(cmd));
        if (t == LD_TOK_EOF)
            return 0;
        else if (t != LD_TOK_NAME)
            return -1;
        if (!strcmp(cmd, "INPUT") ||
            !strcmp(cmd, "GROUP")) {
            t = ld_next(s1, cmd, sizeof(cmd));
            if (t != '(')
                expect("(");
            t = ld_next(s1, filename, sizeof(filename));
            for(;;) {
                if (t == LD_TOK_EOF) {
                    error_noabort("unexpected end of file");
                    return -1;
                } else if (t == ')') {
                    break;
                } else if (t != LD_TOK_NAME) {
                    error_noabort("filename expected");
                    return -1;
                } 
                tcc_add_file(s1, filename);
                t = ld_next(s1, filename, sizeof(filename));
                if (t == ',') {
                    t = ld_next(s1, filename, sizeof(filename));
                }
            }
        } else if (!strcmp(cmd, "OUTPUT_FORMAT") ||
                   !strcmp(cmd, "TARGET")) {
            /* ignore some commands */
            t = ld_next(s1, cmd, sizeof(cmd));
            if (t != '(')
                expect("(");
            for(;;) {
                t = ld_next(s1, filename, sizeof(filename));
                if (t == LD_TOK_EOF) {
                    error_noabort("unexpected end of file");
                    return -1;
                } else if (t == ')') {
                    break;
                }
            }
        } else {
            return -1;
        }
    }
    return 0;
}

Rev 145	Rev 609
1	/*	1	/*
2	* ELF file handling for TCC	2	* ELF file handling for TCC
3	*	3	*
4	* Copyright (c) 2001-2004 Fabrice Bellard	4	* Copyright (c) 2001-2004 Fabrice Bellard
5	*	5	*
6	* This library is free software; you can redistribute it and/or	6	* This library is free software; you can redistribute it and/or
7	* modify it under the terms of the GNU Lesser General Public	7	* modify it under the terms of the GNU Lesser General Public
8	* License as published by the Free Software Foundation; either	8	* License as published by the Free Software Foundation; either
9	* version 2 of the License, or (at your option) any later version.	9	* version 2 of the License, or (at your option) any later version.
10	*	10	*
11	* This library is distributed in the hope that it will be useful,	11	* This library is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14	* Lesser General Public License for more details.	14	* Lesser General Public License for more details.
15	*	15	*
16	* You should have received a copy of the GNU Lesser General Public	16	* You should have received a copy of the GNU Lesser General Public
17	* License along with this library; if not, write to the Free Software	17	* License along with this library; if not, write to the Free Software
18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19	*/	19	*/
20		20
21	static int put_elf_str(Section s, const char sym)	21	static int put_elf_str(Section s, const char sym)
22	{	22	{
23	int offset, len;	23	int offset, len;
24	char *ptr;	24	char *ptr;
25		25
26	len = strlen(sym) + 1;	26	len = strlen(sym) + 1;
27	offset = s->data_offset;	27	offset = s->data_offset;
28	ptr = section_ptr_add(s, len);	28	ptr = section_ptr_add(s, len);
29	memcpy(ptr, sym, len);	29	memcpy(ptr, sym, len);
30	return offset;	30	return offset;
31	}	31	}
32		32
33	/* elf symbol hashing function */	33	/* elf symbol hashing function */
34	static unsigned long elf_hash(const unsigned char *name)	34	static unsigned long elf_hash(const unsigned char *name)
35	{	35	{
36	unsigned long h = 0, g;	36	unsigned long h = 0, g;
37		37
38	while (*name) {	38	while (*name) {
39	h = (h << 4) + *name++;	39	h = (h << 4) + *name++;
40	g = h & 0xf0000000;	40	g = h & 0xf0000000;
41	if (g)	41	if (g)
42	h ^= g >> 24;	42	h ^= g >> 24;
43	h &= ~g;	43	h &= ~g;
44	}	44	}
45	return h;	45	return h;
46	}	46	}
47		47
48	/* rebuild hash table of section s */	48	/* rebuild hash table of section s */
49	/* NOTE: we do factorize the hash table code to go faster */	49	/* NOTE: we do factorize the hash table code to go faster */
50	static void rebuild_hash(Section *s, unsigned int nb_buckets)	50	static void rebuild_hash(Section *s, unsigned int nb_buckets)
51	{	51	{
52	Elf32_Sym *sym;	52	Elf32_Sym *sym;
53	int ptr, hash, nb_syms, sym_index, h;	53	int ptr, hash, nb_syms, sym_index, h;
54	char *strtab;	54	char *strtab;
55		55
56	strtab = s->link->data;	56	strtab = s->link->data;
57	nb_syms = s->data_offset / sizeof(Elf32_Sym);	57	nb_syms = s->data_offset / sizeof(Elf32_Sym);
58		58
59	s->hash->data_offset = 0;	59	s->hash->data_offset = 0;
60	ptr = section_ptr_add(s->hash, (2 + nb_buckets + nb_syms) * sizeof(int));	60	ptr = section_ptr_add(s->hash, (2 + nb_buckets + nb_syms) * sizeof(int));
61	ptr[0] = nb_buckets;	61	ptr[0] = nb_buckets;
62	ptr[1] = nb_syms;	62	ptr[1] = nb_syms;
63	ptr += 2;	63	ptr += 2;
64	hash = ptr;	64	hash = ptr;
65	memset(hash, 0, (nb_buckets + 1) * sizeof(int));	65	memset(hash, 0, (nb_buckets + 1) * sizeof(int));
66	ptr += nb_buckets + 1;	66	ptr += nb_buckets + 1;
67		67
68	sym = (Elf32_Sym *)s->data + 1;	68	sym = (Elf32_Sym *)s->data + 1;
69	for(sym_index = 1; sym_index < nb_syms; sym_index++) {	69	for(sym_index = 1; sym_index < nb_syms; sym_index++) {
70	if (ELF32_ST_BIND(sym->st_info) != STB_LOCAL) {	70	if (ELF32_ST_BIND(sym->st_info) != STB_LOCAL) {
71	h = elf_hash(strtab + sym->st_name) % nb_buckets;	71	h = elf_hash(strtab + sym->st_name) % nb_buckets;
72	*ptr = hash[h];	72	*ptr = hash[h];
73	hash[h] = sym_index;	73	hash[h] = sym_index;
74	} else {	74	} else {
75	*ptr = 0;	75	*ptr = 0;
76	}	76	}
77	ptr++;	77	ptr++;
78	sym++;	78	sym++;
79	}	79	}
80	}	80	}
81		81
82	/* return the symbol number */	82	/* return the symbol number */
83	static int put_elf_sym(Section *s,	83	static int put_elf_sym(Section *s,
84	unsigned long value, unsigned long size,	84	unsigned long value, unsigned long size,
85	int info, int other, int shndx, const char *name)	85	int info, int other, int shndx, const char *name)
86	{	86	{
87	int name_offset, sym_index;	87	int name_offset, sym_index;
88	int nbuckets, h;	88	int nbuckets, h;
89	Elf32_Sym *sym;	89	Elf32_Sym *sym;
90	Section *hs;	90	Section *hs;
91		91
92	sym = section_ptr_add(s, sizeof(Elf32_Sym));	92	sym = section_ptr_add(s, sizeof(Elf32_Sym));
93	if (name)	93	if (name)
94	name_offset = put_elf_str(s->link, name);	94	name_offset = put_elf_str(s->link, name);
95	else	95	else
96	name_offset = 0;	96	name_offset = 0;
97	/* XXX: endianness */	97	/* XXX: endianness */
98	sym->st_name = name_offset;	98	sym->st_name = name_offset;
99	sym->st_value = value;	99	sym->st_value = value;
100	sym->st_size = size;	100	sym->st_size = size;
101	sym->st_info = info;	101	sym->st_info = info;
102	sym->st_other = other;	102	sym->st_other = other;
103	sym->st_shndx = shndx;	103	sym->st_shndx = shndx;
104	sym_index = sym - (Elf32_Sym *)s->data;	104	sym_index = sym - (Elf32_Sym *)s->data;
105	hs = s->hash;	105	hs = s->hash;
106	if (hs) {	106	if (hs) {
107	int ptr, base;	107	int ptr, base;
108	ptr = section_ptr_add(hs, sizeof(int));	108	ptr = section_ptr_add(hs, sizeof(int));
109	base = (int *)hs->data;	109	base = (int *)hs->data;
110	/* only add global or weak symbols */	110	/* only add global or weak symbols */
111	if (ELF32_ST_BIND(info) != STB_LOCAL) {	111	if (ELF32_ST_BIND(info) != STB_LOCAL) {
112	/* add another hashing entry */	112	/* add another hashing entry */
113	nbuckets = base[0];	113	nbuckets = base[0];
114	h = elf_hash(name) % nbuckets;	114	h = elf_hash(name) % nbuckets;
115	*ptr = base[2 + h];	115	*ptr = base[2 + h];
116	base[2 + h] = sym_index;	116	base[2 + h] = sym_index;
117	base[1]++;	117	base[1]++;
118	/* we resize the hash table */	118	/* we resize the hash table */
119	hs->nb_hashed_syms++;	119	hs->nb_hashed_syms++;
120	if (hs->nb_hashed_syms > 2 * nbuckets) {	120	if (hs->nb_hashed_syms > 2 * nbuckets) {
121	rebuild_hash(s, 2 * nbuckets);	121	rebuild_hash(s, 2 * nbuckets);
122	}	122	}
123	} else {	123	} else {
124	*ptr = 0;	124	*ptr = 0;
125	base[1]++;	125	base[1]++;
126	}	126	}
127	}	127	}
128	return sym_index;	128	return sym_index;
129	}	129	}
130		130
131	/* find global ELF symbol 'name' and return its index. Return 0 if not	131	/* find global ELF symbol 'name' and return its index. Return 0 if not
132	found. */	132	found. */
133	static int find_elf_sym(Section s, const char name)	133	static int find_elf_sym(Section s, const char name)
134	{	134	{
135	Elf32_Sym *sym;	135	Elf32_Sym *sym;
136	Section *hs;	136	Section *hs;
137	int nbuckets, sym_index, h;	137	int nbuckets, sym_index, h;
138	const char *name1;	138	const char *name1;
139		139
140	hs = s->hash;	140	hs = s->hash;
141	if (!hs)	141	if (!hs)
142	return 0;	142	return 0;
143	nbuckets = ((int *)hs->data)[0];	143	nbuckets = ((int *)hs->data)[0];
144	h = elf_hash(name) % nbuckets;	144	h = elf_hash(name) % nbuckets;
145	sym_index = ((int *)hs->data)[2 + h];	145	sym_index = ((int *)hs->data)[2 + h];
146	while (sym_index != 0) {	146	while (sym_index != 0) {
147	sym = &((Elf32_Sym *)s->data)[sym_index];	147	sym = &((Elf32_Sym *)s->data)[sym_index];
148	name1 = s->link->data + sym->st_name;	148	name1 = s->link->data + sym->st_name;
149	if (!strcmp(name, name1))	149	if (!strcmp(name, name1))
150	return sym_index;	150	return sym_index;
151	sym_index = ((int *)hs->data)[2 + nbuckets + sym_index];	151	sym_index = ((int *)hs->data)[2 + nbuckets + sym_index];
152	}	152	}
153	return 0;	153	return 0;
154	}	154	}
155		155
156	/* return elf symbol value or error */	156	/* return elf symbol value or error */
157	int tcc_get_symbol(TCCState s, unsigned long pval, const char *name)	157	int tcc_get_symbol(TCCState s, unsigned long pval, const char *name)
158	{	158	{
159	int sym_index;	159	int sym_index;
160	Elf32_Sym *sym;	160	Elf32_Sym *sym;
161		161
162	sym_index = find_elf_sym(symtab_section, name);	162	sym_index = find_elf_sym(symtab_section, name);
163	if (!sym_index)	163	if (!sym_index)
164	return -1;	164	return -1;
165	sym = &((Elf32_Sym *)symtab_section->data)[sym_index];	165	sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
166	*pval = sym->st_value;	166	*pval = sym->st_value;
167	return 0;	167	return 0;
168	}	168	}
169		169
170	void tcc_get_symbol_err(TCCState s, const char *name)	170	void tcc_get_symbol_err(TCCState s, const char *name)
171	{	171	{
172	unsigned long val;	172	unsigned long val;
173	if (tcc_get_symbol(s, &val, name) < 0)	173	if (tcc_get_symbol(s, &val, name) < 0)
174	error("%s not defined", name);	174	error("%s not defined", name);
175	return (void *)val;	175	return (void *)val;
176	}	176	}
177		177
178	/* add an elf symbol : check if it is already defined and patch	178	/* add an elf symbol : check if it is already defined and patch
179	it. Return symbol index. NOTE that sh_num can be SHN_UNDEF. */	179	it. Return symbol index. NOTE that sh_num can be SHN_UNDEF. */
180	static int add_elf_sym(Section *s, unsigned long value, unsigned long size,	180	static int add_elf_sym(Section *s, unsigned long value, unsigned long size,
181	int info, int other, int sh_num, const char *name)	181	int info, int other, int sh_num, const char *name)
182	{	182	{
183	Elf32_Sym *esym;	183	Elf32_Sym *esym;
184	int sym_bind, sym_index, sym_type, esym_bind;	184	int sym_bind, sym_index, sym_type, esym_bind;
185		185
186	sym_bind = ELF32_ST_BIND(info);	186	sym_bind = ELF32_ST_BIND(info);
187	sym_type = ELF32_ST_TYPE(info);	187	sym_type = ELF32_ST_TYPE(info);
188		188
189	if (sym_bind != STB_LOCAL) {	189	if (sym_bind != STB_LOCAL) {
190	/* we search global or weak symbols */	190	/* we search global or weak symbols */
191	sym_index = find_elf_sym(s, name);	191	sym_index = find_elf_sym(s, name);
192	if (!sym_index)	192	if (!sym_index)
193	goto do_def;	193	goto do_def;
194	esym = &((Elf32_Sym *)s->data)[sym_index];	194	esym = &((Elf32_Sym *)s->data)[sym_index];
195	if (esym->st_shndx != SHN_UNDEF) {	195	if (esym->st_shndx != SHN_UNDEF) {
196	esym_bind = ELF32_ST_BIND(esym->st_info);	196	esym_bind = ELF32_ST_BIND(esym->st_info);
197	if (sh_num == SHN_UNDEF) {	197	if (sh_num == SHN_UNDEF) {
198	/* ignore adding of undefined symbol if the	198	/* ignore adding of undefined symbol if the
199	corresponding symbol is already defined */	199	corresponding symbol is already defined */
200	} else if (sym_bind == STB_GLOBAL && esym_bind == STB_WEAK) {	200	} else if (sym_bind == STB_GLOBAL && esym_bind == STB_WEAK) {
201	/* global overrides weak, so patch */	201	/* global overrides weak, so patch */
202	goto do_patch;	202	goto do_patch;
203	} else if (sym_bind == STB_WEAK && esym_bind == STB_GLOBAL) {	203	} else if (sym_bind == STB_WEAK && esym_bind == STB_GLOBAL) {
204	/* weak is ignored if already global */	204	/* weak is ignored if already global */
205	} else {	205	} else {
206	#if 0	206	#if 0
207	printf("new_bind=%d new_shndx=%d last_bind=%d old_shndx=%d\n",	207	printf("new_bind=%d new_shndx=%d last_bind=%d old_shndx=%d\n",
208	sym_bind, sh_num, esym_bind, esym->st_shndx);	208	sym_bind, sh_num, esym_bind, esym->st_shndx);
209	#endif	209	#endif
210	/* NOTE: we accept that two DLL define the same symbol */	210	/* NOTE: we accept that two DLL define the same symbol */
211	if (s != tcc_state->dynsymtab_section)	211	if (s != tcc_state->dynsymtab_section)
212	error_noabort("'%s' defined twice", name);	212	error_noabort("'%s' defined twice", name);
213	}	213	}
214	} else {	214	} else {
215	do_patch:	215	do_patch:
216	esym->st_info = ELF32_ST_INFO(sym_bind, sym_type);	216	esym->st_info = ELF32_ST_INFO(sym_bind, sym_type);
217	esym->st_shndx = sh_num;	217	esym->st_shndx = sh_num;
218	esym->st_value = value;	218	esym->st_value = value;
219	esym->st_size = size;	219	esym->st_size = size;
220	esym->st_other = other;	220	esym->st_other = other;
221	}	221	}
222	} else {	222	} else {
223	do_def:	223	do_def:
224	sym_index = put_elf_sym(s, value, size,	224	sym_index = put_elf_sym(s, value, size,
225	ELF32_ST_INFO(sym_bind, sym_type), other,	225	ELF32_ST_INFO(sym_bind, sym_type), other,
226	sh_num, name);	226	sh_num, name);
227	}	227	}
228	return sym_index;	228	return sym_index;
229	}	229	}
230		230
231	/* put relocation */	231	/* put relocation */
232	static void put_elf_reloc(Section symtab, Section s, unsigned long offset,	232	static void put_elf_reloc(Section symtab, Section s, unsigned long offset,
233	int type, int symbol)	233	int type, int symbol)
234	{	234	{
235	char buf[256];	235	char buf[256];
236	Section *sr;	236	Section *sr;
237	Elf32_Rel *rel;	237	Elf32_Rel *rel;
238		238
239	sr = s->reloc;	239	sr = s->reloc;
240	if (!sr) {	240	if (!sr) {
241	/* if no relocation section, create it */	241	/* if no relocation section, create it */
242	snprintf(buf, sizeof(buf), ".rel%s", s->name);	242	snprintf(buf, sizeof(buf), ".rel%s", s->name);
243	/* if the symtab is allocated, then we consider the relocation	243	/* if the symtab is allocated, then we consider the relocation
244	are also */	244	are also */
245	sr = new_section(tcc_state, buf, SHT_REL, symtab->sh_flags);	245	sr = new_section(tcc_state, buf, SHT_REL, symtab->sh_flags);
246	sr->sh_entsize = sizeof(Elf32_Rel);	246	sr->sh_entsize = sizeof(Elf32_Rel);
247	sr->link = symtab;	247	sr->link = symtab;
248	sr->sh_info = s->sh_num;	248	sr->sh_info = s->sh_num;
249	s->reloc = sr;	249	s->reloc = sr;
250	}	250	}
251	rel = section_ptr_add(sr, sizeof(Elf32_Rel));	251	rel = section_ptr_add(sr, sizeof(Elf32_Rel));
252	rel->r_offset = offset;	252	rel->r_offset = offset;
253	rel->r_info = ELF32_R_INFO(symbol, type);	253	rel->r_info = ELF32_R_INFO(symbol, type);
254	}	254	}
255		255
256	/* put stab debug information */	256	/* put stab debug information */
257		257
258	typedef struct {	258	typedef struct {
259	unsigned long n_strx; /* index into string table of name */	259	unsigned long n_strx; /* index into string table of name */
260	unsigned char n_type; /* type of symbol */	260	unsigned char n_type; /* type of symbol */
261	unsigned char n_other; /* misc info (usually empty) */	261	unsigned char n_other; /* misc info (usually empty) */
262	unsigned short n_desc; /* description field */	262	unsigned short n_desc; /* description field */
263	unsigned long n_value; /* value of symbol */	263	unsigned long n_value; /* value of symbol */
264	} Stab_Sym;	264	} Stab_Sym;
265		265
266	static void put_stabs(const char *str, int type, int other, int desc,	266	static void put_stabs(const char *str, int type, int other, int desc,
267	unsigned long value)	267	unsigned long value)
268	{	268	{
269	Stab_Sym *sym;	269	Stab_Sym *sym;
270		270
271	sym = section_ptr_add(stab_section, sizeof(Stab_Sym));	271	sym = section_ptr_add(stab_section, sizeof(Stab_Sym));
272	if (str) {	272	if (str) {
273	sym->n_strx = put_elf_str(stabstr_section, str);	273	sym->n_strx = put_elf_str(stabstr_section, str);
274	} else {	274	} else {
275	sym->n_strx = 0;	275	sym->n_strx = 0;
276	}	276	}
277	sym->n_type = type;	277	sym->n_type = type;
278	sym->n_other = other;	278	sym->n_other = other;
279	sym->n_desc = desc;	279	sym->n_desc = desc;
280	sym->n_value = value;	280	sym->n_value = value;
281	}	281	}
282		282
283	static void put_stabs_r(const char *str, int type, int other, int desc,	283	static void put_stabs_r(const char *str, int type, int other, int desc,
284	unsigned long value, Section *sec, int sym_index)	284	unsigned long value, Section *sec, int sym_index)
285	{	285	{
286	put_stabs(str, type, other, desc, value);	286	put_stabs(str, type, other, desc, value);
287	put_elf_reloc(symtab_section, stab_section,	287	put_elf_reloc(symtab_section, stab_section,
288	stab_section->data_offset - sizeof(unsigned long),	288	stab_section->data_offset - sizeof(unsigned long),
289	R_DATA_32, sym_index);	289	R_DATA_32, sym_index);
290	}	290	}
291		291
292	static void put_stabn(int type, int other, int desc, int value)	292	static void put_stabn(int type, int other, int desc, int value)
293	{	293	{
294	put_stabs(NULL, type, other, desc, value);	294	put_stabs(NULL, type, other, desc, value);
295	}	295	}
296		296
297	static void put_stabd(int type, int other, int desc)	297	static void put_stabd(int type, int other, int desc)
298	{	298	{
299	put_stabs(NULL, type, other, desc, 0);	299	put_stabs(NULL, type, other, desc, 0);
300	}	300	}
301		301
302	/* In an ELF file symbol table, the local symbols must appear below	302	/* In an ELF file symbol table, the local symbols must appear below
303	the global and weak ones. Since TCC cannot sort it while generating	303	the global and weak ones. Since TCC cannot sort it while generating
304	the code, we must do it after. All the relocation tables are also	304	the code, we must do it after. All the relocation tables are also
305	modified to take into account the symbol table sorting */	305	modified to take into account the symbol table sorting */
306	static void sort_syms(TCCState s1, Section s)	306	static void sort_syms(TCCState s1, Section s)
307	{	307	{
308	int *old_to_new_syms;	308	int *old_to_new_syms;
309	Elf32_Sym *new_syms;	309	Elf32_Sym *new_syms;
310	int nb_syms, i;	310	int nb_syms, i;
311	Elf32_Sym p, q;	311	Elf32_Sym p, q;
312	Elf32_Rel rel, rel_end;	312	Elf32_Rel rel, rel_end;
313	Section *sr;	313	Section *sr;
314	int type, sym_index;	314	int type, sym_index;
315		315
316	nb_syms = s->data_offset / sizeof(Elf32_Sym);	316	nb_syms = s->data_offset / sizeof(Elf32_Sym);
317	new_syms = tcc_malloc(nb_syms * sizeof(Elf32_Sym));	317	new_syms = tcc_malloc(nb_syms * sizeof(Elf32_Sym));
318	old_to_new_syms = tcc_malloc(nb_syms * sizeof(int));	318	old_to_new_syms = tcc_malloc(nb_syms * sizeof(int));
319		319
320	/* first pass for local symbols */	320	/* first pass for local symbols */
321	p = (Elf32_Sym *)s->data;	321	p = (Elf32_Sym *)s->data;
322	q = new_syms;	322	q = new_syms;
323	for(i = 0; i < nb_syms; i++) {	323	for(i = 0; i < nb_syms; i++) {
324	if (ELF32_ST_BIND(p->st_info) == STB_LOCAL) {	324	if (ELF32_ST_BIND(p->st_info) == STB_LOCAL) {
325	old_to_new_syms[i] = q - new_syms;	325	old_to_new_syms[i] = q - new_syms;
326	q++ = p;	326	q++ = p;
327	}	327	}
328	p++;	328	p++;
329	}	329	}
330	/* save the number of local symbols in section header */	330	/* save the number of local symbols in section header */
331	s->sh_info = q - new_syms;	331	s->sh_info = q - new_syms;
332		332
333	/* then second pass for non local symbols */	333	/* then second pass for non local symbols */
334	p = (Elf32_Sym *)s->data;	334	p = (Elf32_Sym *)s->data;
335	for(i = 0; i < nb_syms; i++) {	335	for(i = 0; i < nb_syms; i++) {
336	if (ELF32_ST_BIND(p->st_info) != STB_LOCAL) {	336	if (ELF32_ST_BIND(p->st_info) != STB_LOCAL) {
337	old_to_new_syms[i] = q - new_syms;	337	old_to_new_syms[i] = q - new_syms;
338	q++ = p;	338	q++ = p;
339	}	339	}
340	p++;	340	p++;
341	}	341	}
342		342
343	/* we copy the new symbols to the old */	343	/* we copy the new symbols to the old */
344	memcpy(s->data, new_syms, nb_syms * sizeof(Elf32_Sym));	344	memcpy(s->data, new_syms, nb_syms * sizeof(Elf32_Sym));
345	tcc_free(new_syms);	345	tcc_free(new_syms);
346		346
347	/* now we modify all the relocations */	347	/* now we modify all the relocations */
348	for(i = 1; i < s1->nb_sections; i++) {	348	for(i = 1; i < s1->nb_sections; i++) {
349	sr = s1->sections[i];	349	sr = s1->sections[i];
350	if (sr->sh_type == SHT_REL && sr->link == s) {	350	if (sr->sh_type == SHT_REL && sr->link == s) {
351	rel_end = (Elf32_Rel *)(sr->data + sr->data_offset);	351	rel_end = (Elf32_Rel *)(sr->data + sr->data_offset);
352	for(rel = (Elf32_Rel *)sr->data;	352	for(rel = (Elf32_Rel *)sr->data;
353	rel < rel_end;	353	rel < rel_end;
354	rel++) {	354	rel++) {
355	sym_index = ELF32_R_SYM(rel->r_info);	355	sym_index = ELF32_R_SYM(rel->r_info);
356	type = ELF32_R_TYPE(rel->r_info);	356	type = ELF32_R_TYPE(rel->r_info);
357	sym_index = old_to_new_syms[sym_index];	357	sym_index = old_to_new_syms[sym_index];
358	rel->r_info = ELF32_R_INFO(sym_index, type);	358	rel->r_info = ELF32_R_INFO(sym_index, type);
359	}	359	}
360	}	360	}
361	}	361	}
362		362
363	tcc_free(old_to_new_syms);	363	tcc_free(old_to_new_syms);
364	}	364	}
365		365
366	/* relocate common symbols in the .bss section */	366	/* relocate common symbols in the .bss section */
367	static void relocate_common_syms(void)	367	static void relocate_common_syms(void)
368	{	368	{
369	Elf32_Sym sym, sym_end;	369	Elf32_Sym sym, sym_end;
370	unsigned long offset, align;	370	unsigned long offset, align;
371		371
372	sym_end = (Elf32_Sym *)(symtab_section->data + symtab_section->data_offset);	372	sym_end = (Elf32_Sym *)(symtab_section->data + symtab_section->data_offset);
373	for(sym = (Elf32_Sym *)symtab_section->data + 1;	373	for(sym = (Elf32_Sym *)symtab_section->data + 1;
374	sym < sym_end;	374	sym < sym_end;
375	sym++) {	375	sym++) {
376	if (sym->st_shndx == SHN_COMMON) {	376	if (sym->st_shndx == SHN_COMMON) {
377	/* align symbol */	377	/* align symbol */
378	align = sym->st_value;	378	align = sym->st_value;
379	offset = bss_section->data_offset;	379	offset = bss_section->data_offset;
380	offset = (offset + align - 1) & -align;	380	offset = (offset + align - 1) & -align;
381	sym->st_value = offset;	381	sym->st_value = offset;
382	sym->st_shndx = bss_section->sh_num;	382	sym->st_shndx = bss_section->sh_num;
383	offset += sym->st_size;	383	offset += sym->st_size;
384	bss_section->data_offset = offset;	384	bss_section->data_offset = offset;
385	}	385	}
386	}	386	}
387	}	387	}
388		388
389	/* relocate symbol table, resolve undefined symbols if do_resolve is	389	/* relocate symbol table, resolve undefined symbols if do_resolve is
390	true and output error if undefined symbol. */	390	true and output error if undefined symbol. */
391	static void relocate_syms(TCCState *s1, int do_resolve)	391	static void relocate_syms(TCCState *s1, int do_resolve)
392	{	392	{
393	Elf32_Sym sym, esym, *sym_end;	393	Elf32_Sym sym, esym, *sym_end;
394	int sym_bind, sh_num, sym_index;	394	int sym_bind, sh_num, sym_index;
395	const char *name;	395	const char *name;
396	unsigned long addr;	396	unsigned long addr;
397		397
398	sym_end = (Elf32_Sym *)(symtab_section->data + symtab_section->data_offset);	398	sym_end = (Elf32_Sym *)(symtab_section->data + symtab_section->data_offset);
399	for(sym = (Elf32_Sym *)symtab_section->data + 1;	399	for(sym = (Elf32_Sym *)symtab_section->data + 1;
400	sym < sym_end;	400	sym < sym_end;
401	sym++) {	401	sym++) {
402	sh_num = sym->st_shndx;	402	sh_num = sym->st_shndx;
403	if (sh_num == SHN_UNDEF) {	403	if (sh_num == SHN_UNDEF) {
404	name = strtab_section->data + sym->st_name;	404	name = strtab_section->data + sym->st_name;
405	if (do_resolve) {	405	if (do_resolve) {
406	name = symtab_section->link->data + sym->st_name;	406	name = symtab_section->link->data + sym->st_name;
407	addr = (unsigned long)resolve_sym(s1, name, ELF32_ST_TYPE(sym->st_info));	407	addr = (unsigned long)resolve_sym(s1, name, ELF32_ST_TYPE(sym->st_info));
408	if (addr) {	408	if (addr) {
409	sym->st_value = addr;	409	sym->st_value = addr;
410	goto found;	410	goto found;
411	}	411	}
412	} else if (s1->dynsym) {	412	} else if (s1->dynsym) {
413	/* if dynamic symbol exist, then use it */	413	/* if dynamic symbol exist, then use it */
414	sym_index = find_elf_sym(s1->dynsym, name);	414	sym_index = find_elf_sym(s1->dynsym, name);
415	if (sym_index) {	415	if (sym_index) {
416	esym = &((Elf32_Sym *)s1->dynsym->data)[sym_index];	416	esym = &((Elf32_Sym *)s1->dynsym->data)[sym_index];
417	sym->st_value = esym->st_value;	417	sym->st_value = esym->st_value;
418	goto found;	418	goto found;
419	}	419	}
420	}	420	}
421	/* XXX: _fp_hw seems to be part of the ABI, so we ignore	421	/* XXX: _fp_hw seems to be part of the ABI, so we ignore
422	it */	422	it */
423	if (!strcmp(name, "_fp_hw"))	423	if (!strcmp(name, "_fp_hw"))
424	goto found;	424	goto found;
425	/* only weak symbols are accepted to be undefined. Their	425	/* only weak symbols are accepted to be undefined. Their
426	value is zero */	426	value is zero */
427	sym_bind = ELF32_ST_BIND(sym->st_info);	427	sym_bind = ELF32_ST_BIND(sym->st_info);
428	if (sym_bind == STB_WEAK) {	428	if (sym_bind == STB_WEAK) {
429	sym->st_value = 0;	429	sym->st_value = 0;
430	} else {	430	} else {
431	error_noabort("undefined symbol '%s'", name);	431	error_noabort("undefined symbol '%s'", name);
432	}	432	}
433	} else if (sh_num < SHN_LORESERVE) {	433	} else if (sh_num < SHN_LORESERVE) {
434	/* add section base */	434	/* add section base */
435	sym->st_value += s1->sections[sym->st_shndx]->sh_addr;	435	sym->st_value += s1->sections[sym->st_shndx]->sh_addr;
436	}	436	}
437	found: ;	437	found: ;
438	}	438	}
439	}	439	}
440		440
441	/* relocate a given section (CPU dependent) */	441	/* relocate a given section (CPU dependent) */
442	static void relocate_section(TCCState s1, Section s)	442	static void relocate_section(TCCState s1, Section s)
443	{	443	{
444	Section *sr;	444	Section *sr;
445	Elf32_Rel rel, rel_end, *qrel;	445	Elf32_Rel rel, rel_end, *qrel;
446	Elf32_Sym *sym;	446	Elf32_Sym *sym;
447	int type, sym_index;	447	int type, sym_index;
448	unsigned char *ptr;	448	unsigned char *ptr;
449	unsigned long val, addr;	449	unsigned long val, addr;
450	#if defined(TCC_TARGET_I386)	450	#if defined(TCC_TARGET_I386)
451	int esym_index;	451	int esym_index;
452	#endif	452	#endif
453		453
454	sr = s->reloc;	454	sr = s->reloc;
455	rel_end = (Elf32_Rel *)(sr->data + sr->data_offset);	455	rel_end = (Elf32_Rel *)(sr->data + sr->data_offset);
456	qrel = (Elf32_Rel *)sr->data;	456	qrel = (Elf32_Rel *)sr->data;
457	for(rel = qrel;	457	for(rel = qrel;
458	rel < rel_end;	458	rel < rel_end;
459	rel++) {	459	rel++) {
460	ptr = s->data + rel->r_offset;	460	ptr = s->data + rel->r_offset;
461		461
462	sym_index = ELF32_R_SYM(rel->r_info);	462	sym_index = ELF32_R_SYM(rel->r_info);
463	sym = &((Elf32_Sym *)symtab_section->data)[sym_index];	463	sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
464	val = sym->st_value;	464	val = sym->st_value;
465	type = ELF32_R_TYPE(rel->r_info);	465	type = ELF32_R_TYPE(rel->r_info);
466	addr = s->sh_addr + rel->r_offset;	466	addr = s->sh_addr + rel->r_offset;
467		467
468	/* CPU specific */	468	/* CPU specific */
469	switch(type) {	469	switch(type) {
470	#if defined(TCC_TARGET_I386)	470	#if defined(TCC_TARGET_I386)
471	case R_386_32:	471	case R_386_32:
472	if (s1->output_type == TCC_OUTPUT_DLL) {	472	if (s1->output_type == TCC_OUTPUT_DLL) {
473	esym_index = s1->symtab_to_dynsym[sym_index];	473	esym_index = s1->symtab_to_dynsym[sym_index];
474	qrel->r_offset = rel->r_offset;	474	qrel->r_offset = rel->r_offset;
475	if (esym_index) {	475	if (esym_index) {
476	qrel->r_info = ELF32_R_INFO(esym_index, R_386_32);	476	qrel->r_info = ELF32_R_INFO(esym_index, R_386_32);
477	qrel++;	477	qrel++;
478	break;	478	break;
479	} else {	479	} else {
480	qrel->r_info = ELF32_R_INFO(0, R_386_RELATIVE);	480	qrel->r_info = ELF32_R_INFO(0, R_386_RELATIVE);
481	qrel++;	481	qrel++;
482	}	482	}
483	}	483	}
484	(int )ptr += val;	484	(int )ptr += val;
485	break;	485	break;
486	case R_386_PC32:	486	case R_386_PC32:
487	if (s1->output_type == TCC_OUTPUT_DLL) {	487	if (s1->output_type == TCC_OUTPUT_DLL) {
488	/* DLL relocation */	488	/* DLL relocation */
489	esym_index = s1->symtab_to_dynsym[sym_index];	489	esym_index = s1->symtab_to_dynsym[sym_index];
490	if (esym_index) {	490	if (esym_index) {
491	qrel->r_offset = rel->r_offset;	491	qrel->r_offset = rel->r_offset;
492	qrel->r_info = ELF32_R_INFO(esym_index, R_386_PC32);	492	qrel->r_info = ELF32_R_INFO(esym_index, R_386_PC32);
493	qrel++;	493	qrel++;
494	break;	494	break;
495	}	495	}
496	}	496	}
497	(int )ptr += val - addr;	497	(int )ptr += val - addr;
498	break;	498	break;
499	case R_386_PLT32:	499	case R_386_PLT32:
500	(int )ptr += val - addr;	500	(int )ptr += val - addr;

Subversion Repositories Kolibri OS

(root)/programs/develop/metcc/trunk/source/tccelf.c – Rev 145 → 609