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

  * 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
  */
+#include "tcc.h"
+/* Define this to get some debug output during relocation processing.  */
+#undef DEBUG_RELOC
+/* XXX: avoid static variable */
+static int new_undef_sym = 0; /* Is there a new undefined sym since last new_undef_sym() */
-static int put_elf_str(Section *s, const char *sym)
+ST_FUNC int put_elf_str(Section *s, const char *sym)
+{
     int offset, len;
     char *ptr;
 /* 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;
+    ElfW(Sym) *sym;
     int *ptr, *hash, nb_syms, sym_index, h;
-    char *strtab;
+    unsigned char *strtab;
     strtab = s->link->data;
-    nb_syms = s->data_offset / sizeof(Elf32_Sym);
+    nb_syms = s->data_offset / sizeof(ElfW(Sym));
     s->hash->data_offset = 0;
     ptr = section_ptr_add(s->hash, (2 + nb_buckets + nb_syms) * sizeof(int));
     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;
+    sym = (ElfW(Sym) *)s->data + 1;
     for(sym_index = 1; sym_index < nb_syms; sym_index++) {
-        if (ELF32_ST_BIND(sym->st_info) != STB_LOCAL) {
+        if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
             h = elf_hash(strtab + sym->st_name) % nb_buckets;
         sym++;
+    }
+}
-/* return the symbol number */
-static int put_elf_sym(Section *s,
+/* return the symbol number */
-                       unsigned long value, unsigned long size,
+ST_FUNC int put_elf_sym(Section *s, addr_t value, unsigned long size,
-                       int info, int other, int shndx, const char *name)
+    int info, int other, int shndx, const char *name)
+{
     int name_offset, sym_index;
     int nbuckets, h;
-    Elf32_Sym *sym;
+    ElfW(Sym) *sym;
     Section *hs;
-    sym = section_ptr_add(s, sizeof(Elf32_Sym));
+    sym = section_ptr_add(s, sizeof(ElfW(Sym)));
     if (name)
         name_offset = put_elf_str(s->link, name);
     else
     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;
+    sym_index = sym - (ElfW(Sym) *)s->data;
     hs = s->hash;
     if (hs) {
         int *ptr, *base;
         ptr = section_ptr_add(hs, sizeof(int));
         base = (int *)hs->data;
         /* only add global or weak symbols */
-        if (ELF32_ST_BIND(info) != STB_LOCAL) {
+        if (ELFW(ST_BIND)(info) != STB_LOCAL) {
             /* add another hashing entry */
             nbuckets = base[0];
-            h = elf_hash(name) % nbuckets;
+            h = elf_hash((unsigned char *) name) % nbuckets;
             *ptr = base[2 + h];
             base[2 + h] = sym_index;
             base[1]++;
             /* we resize the hash table */
             hs->nb_hashed_syms++;
     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)
+ST_FUNC int find_elf_sym(Section *s, const char *name)
 {
-    Elf32_Sym *sym;
+    ElfW(Sym) *sym;
     Section *hs;
     int nbuckets, sym_index, h;
     const char *name1;
     hs = s->hash;
     if (!hs)
         return 0;
     nbuckets = ((int *)hs->data)[0];
-    h = elf_hash(name) % nbuckets;
+    h = elf_hash((unsigned char *) name) % nbuckets;
     sym_index = ((int *)hs->data)[2 + h];
     while (sym_index != 0) {
-        sym = &((Elf32_Sym *)s->data)[sym_index];
+        sym = &((ElfW(Sym) *)s->data)[sym_index];
-        name1 = s->link->data + sym->st_name;
+        name1 = (char *) 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 */
+/* return elf symbol value, signal error if 'err' is nonzero */
-int tcc_get_symbol(TCCState *s, unsigned long *pval, const char *name)
+ST_FUNC addr_t get_elf_sym_addr(TCCState *s, const char *name, int err)
 {
+    int sym_index;
-    int sym_index;
+    ElfW(Sym) *sym;
-    Elf32_Sym *sym;
+    sym_index = find_elf_sym(s->symtab, name);
-    sym_index = find_elf_sym(symtab_section, name);
-    if (!sym_index)
+    sym = &((ElfW(Sym) *)s->symtab->data)[sym_index];
-        return -1;
+    if (!sym_index || sym->st_shndx == SHN_UNDEF) {
+        if (err)
+            tcc_error("%s not defined", name);
+        return 0;
+    }
+    return sym->st_value;
+}
+/* return elf symbol value */
+LIBTCCAPI void *tcc_get_symbol(TCCState *s, const char *name)
+{
-    sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
+    return (void*)(uintptr_t)get_elf_sym_addr(s, name, 0);
     *pval = sym->st_value;
-    return 0;
-}
-void *tcc_get_symbol_err(TCCState *s, const char *name)
 #if defined TCC_IS_NATIVE || defined TCC_TARGET_PE || defined TCC_TARGET_MEOS
+/* return elf symbol value or error */
-    unsigned long val;
+ST_FUNC void* tcc_get_symbol_err(TCCState *s, const char *name)
     if (tcc_get_symbol(s, &val, name) < 0)
-        error("%s not defined", name);
+    return (void*)(uintptr_t)get_elf_sym_addr(s, name, 1);
     return (void *)val;
 #endif
 /* add an elf symbol : check if it is already defined and patch
+   it. Return symbol index. NOTE that sh_num can be SHN_UNDEF. */
-   it. Return symbol index. NOTE that sh_num can be SHN_UNDEF. */
+ST_FUNC int add_elf_sym(Section *s, addr_t value, unsigned long size,
-static int add_elf_sym(Section *s, unsigned long value, unsigned long size,
+                       int info, int other, int sh_num, const char *name)
+{
-                       int info, int other, int sh_num, const char *name)
+    ElfW(Sym) *esym;
     int sym_bind, sym_index, sym_type, esym_bind;
-    Elf32_Sym *esym;
+    unsigned char sym_vis, esym_vis, new_vis;
     int sym_bind, sym_index, sym_type, esym_bind;
     sym_bind = ELFW(ST_BIND)(info);
-    sym_bind = ELF32_ST_BIND(info);
+    sym_type = ELFW(ST_TYPE)(info);
-    sym_type = ELF32_ST_TYPE(info);
+    sym_vis = ELFW(ST_VISIBILITY)(other);
+    if (sym_bind != STB_LOCAL) {
+        /* we search global or weak symbols */
+        sym_index = find_elf_sym(s, name);
+        if (!sym_index)
+            goto do_def;
+        esym = &((ElfW(Sym) *)s->data)[sym_index];
+        if (esym->st_shndx != SHN_UNDEF) {
+            esym_bind = ELFW(ST_BIND)(esym->st_info);
+            /* propagate the most constraining visibility */
+            /* STV_DEFAULT(0)
+            esym_vis = ELFW(ST_VISIBILITY)(esym->st_other);
+            if (esym_vis == STV_DEFAULT) {
+                new_vis = sym_vis;
-    if (sym_bind != STB_LOCAL) {
+            } else if (sym_vis == STV_DEFAULT) {
-        /* we search global or weak symbols */
+                new_vis = esym_vis;
-        sym_index = find_elf_sym(s, name);
+            } else {
-        if (!sym_index)
+                new_vis = (esym_vis < sym_vis) ? esym_vis : sym_vis;
             goto do_def;
-        esym = &((Elf32_Sym *)s->data)[sym_index];
+            esym->st_other = (esym->st_other & ~ELFW(ST_VISIBILITY)(-1))
-        if (esym->st_shndx != SHN_UNDEF) {
+                             | new_vis;
-            esym_bind = ELF32_ST_BIND(esym->st_info);
+            other = esym->st_other; /* in case we have to patch esym */
+            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 (sym_bind == STB_WEAK && esym_bind == STB_WEAK) {
+                /* keep first-found weak definition, ignore subsequents */
+            } else if (sym_vis == STV_HIDDEN || sym_vis == STV_INTERNAL) {
-            if (sh_num == SHN_UNDEF) {
+                /* ignore hidden symbols after */
-                /* ignore adding of undefined symbol if the
+            } else if (esym->st_shndx == SHN_COMMON
-                   corresponding symbol is already defined */
+                    && (sh_num < SHN_LORESERVE || sh_num == SHN_COMMON)) {
-            } else if (sym_bind == STB_GLOBAL && esym_bind == STB_WEAK) {
+                /* gr: Happens with 'tcc ... -static tcctest.c' on e.g. Ubuntu 6.01
-                /* global overrides weak, so patch */
+                   No idea if this is the correct solution ... */
-                goto do_patch;
-            } else if (sym_bind == STB_WEAK && esym_bind == STB_GLOBAL) {
-                /* weak is ignored if already global */
+                goto do_patch;
-            } else {
+            } else if (s == tcc_state->dynsymtab_section) {
-#if 0
+                /* we accept that two DLL define the same symbol */
-                printf("new_bind=%d new_shndx=%d last_bind=%d old_shndx=%d\n",
+            } else {
-                       sym_bind, sh_num, esym_bind, esym->st_shndx);
+#if 0
-#endif
+                printf("new_bind=%x new_shndx=%x new_vis=%x old_bind=%x old_shndx=%x old_vis=%x\n",
+                       sym_bind, sh_num, new_vis, esym_bind, esym->st_shndx, esym_vis);
-                /* NOTE: we accept that two DLL define the same symbol */
+#endif
-                if (s != tcc_state->dynsymtab_section)
+                tcc_error_noabort("'%s' defined twice... may be -fcommon is needed?", name);
                     error_noabort("'%s' defined twice", name);
         } else {
-        } else {
+        do_patch:
-        do_patch:
+            esym->st_info = ELFW(ST_INFO)(sym_bind, sym_type);
-            esym->st_info = ELF32_ST_INFO(sym_bind, sym_type);
+            esym->st_shndx = sh_num;
-            esym->st_shndx = sh_num;
+            new_undef_sym = 1;
             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,
+                                ELFW(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,
+ST_FUNC void put_elf_reloca(Section *symtab, Section *s, unsigned long offset,
-                          int type, int symbol)
+                            int type, int symbol, addr_t addend)
+{
     char buf[256];
     Section *sr;
-    Elf32_Rel *rel;
+    ElfW_Rel *rel;
     sr = s->reloc;
     if (!sr) {
         /* if no relocation section, create it */
-        snprintf(buf, sizeof(buf), ".rel%s", s->name);
+        snprintf(buf, sizeof(buf), REL_SECTION_FMT, s->name);
         /* if the symtab is allocated, then we consider the relocation
+           are also */
+        sr = new_section(tcc_state, buf, SHT_RELX, symtab->sh_flags);
+        sr->sh_entsize = sizeof(ElfW_Rel);
+        sr->link = symtab;
+        sr->sh_info = s->sh_num;
+        s->reloc = sr;
            are also */
+    rel = section_ptr_add(sr, sizeof(ElfW_Rel));
+    rel->r_offset = offset;
+    rel->r_info = ELFW(R_INFO)(symbol, type);
-        sr = new_section(tcc_state, buf, SHT_REL, symtab->sh_flags);
+#if defined(TCC_TARGET_ARM64) || defined(TCC_TARGET_X86_64)
+    rel->r_addend = addend;
-        sr->sh_entsize = sizeof(Elf32_Rel);
-        sr->link = symtab;
-        sr->sh_info = s->sh_num;
-        s->reloc = sr;
-    }
+#else
-    rel = section_ptr_add(sr, sizeof(Elf32_Rel));
-    rel->r_offset = offset;
-    rel->r_info = ELF32_R_INFO(symbol, type);
+    if (addend)
         tcc_error("non-zero addend on REL architecture");
 #endif
 /* put stab debug information */
     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,
+ST_FUNC 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),
+                  stab_section->data_offset - sizeof(unsigned int),
                   R_DATA_32, sym_index);
 }
-static void put_stabn(int type, int other, int desc, int value)
+ST_FUNC 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)
+ST_FUNC void put_stabd(int type, int other, int desc)
+{
+    put_stabs(NULL, type, other, desc, 0);
+}
+/* Browse each elem of type  in section  starting at elem
+   using variable  */
 #define for_each_elem(sec, startoff, elem, type) \
-    put_stabs(NULL, type, other, desc, 0);
+    for (elem = (type *) sec->data + startoff; \
          elem < (type *) (sec->data + sec->data_offset); elem++)
 /* 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;
+    ElfW(Sym) *new_syms;
     int nb_syms, i;
-    Elf32_Sym *p, *q;
+    ElfW(Sym) *p, *q;
-    Elf32_Rel *rel, *rel_end;
+    ElfW_Rel *rel;
     Section *sr;
     int type, sym_index;
-    nb_syms = s->data_offset / sizeof(Elf32_Sym);
+    nb_syms = s->data_offset / sizeof(ElfW(Sym));
-    new_syms = tcc_malloc(nb_syms * sizeof(Elf32_Sym));
+    new_syms = tcc_malloc(nb_syms * sizeof(ElfW(Sym)));
     old_to_new_syms = tcc_malloc(nb_syms * sizeof(int));
     /* first pass for local symbols */
-    p = (Elf32_Sym *)s->data;
+    p = (ElfW(Sym) *)s->data;
     q = new_syms;
     for(i = 0; i < nb_syms; i++) {
-        if (ELF32_ST_BIND(p->st_info) == STB_LOCAL) {
+        if (ELFW(ST_BIND)(p->st_info) == STB_LOCAL) {
             old_to_new_syms[i] = q - new_syms;
             *q++ = *p;
         }
         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;
+    p = (ElfW(Sym) *)s->data;
     for(i = 0; i < nb_syms; i++) {
-        if (ELF32_ST_BIND(p->st_info) != STB_LOCAL) {
+        if (ELFW(ST_BIND)(p->st_info) != STB_LOCAL) {
             old_to_new_syms[i] = q - new_syms;
             *q++ = *p;
+        }
         p++;
     }
-    /* we copy the new symbols to the old */
-    memcpy(s->data, new_syms, nb_syms * sizeof(Elf32_Sym));
-    tcc_free(new_syms);
+    /* we copy the new symbols to the old */
-    /* now we modify all the relocations */
+    memcpy(s->data, new_syms, nb_syms * sizeof(ElfW(Sym)));
-    for(i = 1; i < s1->nb_sections; i++) {
+    tcc_free(new_syms);
-        sr = s1->sections[i];
-        if (sr->sh_type == SHT_REL && sr->link == s) {
+    /* now we modify all the relocations */
-            rel_end = (Elf32_Rel *)(sr->data + sr->data_offset);
+    for(i = 1; i < s1->nb_sections; i++) {
-            for(rel = (Elf32_Rel *)sr->data;
+        sr = s1->sections[i];
-                rel < rel_end;
+        if (sr->sh_type == SHT_RELX && sr->link == s) {
-                rel++) {
+            for_each_elem(sr, 0, rel, ElfW_Rel) {
-                sym_index = ELF32_R_SYM(rel->r_info);
+                sym_index = ELFW(R_SYM)(rel->r_info);
-                type = ELF32_R_TYPE(rel->r_info);
+                type = ELFW(R_TYPE)(rel->r_info);
                 sym_index = old_to_new_syms[sym_index];
-                rel->r_info = ELF32_R_INFO(sym_index, type);
+                rel->r_info = ELFW(R_INFO)(sym_index, type);
+            }
-        }
-    }
+        }
-    tcc_free(old_to_new_syms);
+    }
-/* relocate common symbols in the .bss section */
+    tcc_free(old_to_new_syms);
 static void relocate_common_syms(void)
+    }
+}
 /* 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)
+ST_FUNC void relocate_syms(TCCState *s1, int do_resolve)
 {
-    Elf32_Sym *sym, *esym, *sym_end;
+    ElfW(Sym) *sym, *esym;
     int sym_bind, sh_num, sym_index;
-    const char *name;
-    unsigned long addr;
+    const char *name;
-    sym_end = (Elf32_Sym *)(symtab_section->data + symtab_section->data_offset);
-    for(sym = (Elf32_Sym *)symtab_section->data + 1;
         sym < sym_end;
-        sym++) {
+    for_each_elem(symtab_section, 1, sym, ElfW(Sym)) {
         sh_num = sym->st_shndx;
+        if (sh_num == SHN_UNDEF) {
-        if (sh_num == SHN_UNDEF) {
+            name = (char *) strtab_section->data + sym->st_name;
+            /* Use ld.so to resolve symbol for us (for tcc -run) */
+            if (do_resolve) {
-            name = strtab_section->data + sym->st_name;
+#if defined TCC_IS_NATIVE && !defined _WIN32
-            if (do_resolve) {
+                void *addr;
-                name = symtab_section->link->data + sym->st_name;
+                name = (char *) symtab_section->link->data + sym->st_name;
-                addr = (unsigned long)resolve_sym(s1, name, ELF32_ST_TYPE(sym->st_info));
+                addr = resolve_sym(s1, name);
+                if (addr) {
+                    sym->st_value = (addr_t)addr;
+#ifdef DEBUG_RELOC
-                if (addr) {
+		    printf ("relocate_sym: %s -> 0x%lx\n", name, sym->st_value);
-                    sym->st_value = addr;
+#endif
+                    goto found;
                     goto found;
 #endif
             } 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];
+                    esym = &((ElfW(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);
+            sym_bind = ELFW(ST_BIND)(sym->st_info);
             if (sym_bind == STB_WEAK) {
                 sym->st_value = 0;
             } else {
-                error_noabort("undefined symbol '%s'", name);
+                tcc_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) by applying the relocations
-/* relocate a given section (CPU dependent) */
+   in the associated relocation section */
-static void relocate_section(TCCState *s1, Section *s)
+ST_FUNC void relocate_section(TCCState *s1, Section *s)
 {
-    Section *sr;
+    Section *sr = s->reloc;
-    Elf32_Rel *rel, *rel_end, *qrel;
+    ElfW_Rel *rel;
-    Elf32_Sym *sym;
+    ElfW(Sym) *sym;
     int type, sym_index;
+    unsigned char *ptr;
-    unsigned char *ptr;
+    addr_t val, addr;
-    unsigned long val, addr;
+#if defined TCC_TARGET_I386 || defined TCC_TARGET_X86_64
-#if defined(TCC_TARGET_I386)
-    int esym_index;
-#endif
+    ElfW_Rel *qrel = (ElfW_Rel *) sr->data; /* ptr to next reloc entry reused */
-    sr = s->reloc;
-    rel_end = (Elf32_Rel *)(sr->data + sr->data_offset);
-    qrel = (Elf32_Rel *)sr->data;
+    int esym_index;
-    for(rel = qrel;
+#endif
-        rel < rel_end;
-        rel++) {
+    for_each_elem(sr, 0, rel, ElfW_Rel) {
+        ptr = s->data + rel->r_offset;
+        sym_index = ELFW(R_SYM)(rel->r_info);
-        ptr = s->data + rel->r_offset;
+        sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
         val = sym->st_value;
-        sym_index = ELF32_R_SYM(rel->r_info);
+#if defined(TCC_TARGET_ARM64) || defined(TCC_TARGET_X86_64)
-        sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
+        val += rel->r_addend;
-        val = sym->st_value;
+#endif
-        type = ELF32_R_TYPE(rel->r_info);
+        type = ELFW(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->r_info = ELFW(R_INFO)(esym_index, R_386_32);
                     qrel++;
                     break;
                 } else {
-                    qrel->r_info = ELF32_R_INFO(0, R_386_RELATIVE);
+                    qrel->r_info = ELFW(R_INFO)(0, R_386_RELATIVE);
                     qrel++;
+                }
+            }
-            *(int *)ptr += val;
+            write32le(ptr, read32le(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->r_info = ELFW(R_INFO)(esym_index, R_386_PC32);
                     qrel++;
                     break;
+                }
+            }
-            *(int *)ptr += val - addr;
+            write32le(ptr, read32le(ptr) + val - addr);
             break;
         case R_386_PLT32:
-            *(int *)ptr += val - addr;
+            write32le(ptr, read32le(ptr) + val - addr);
             break;
         case R_386_GLOB_DAT:
         case R_386_JMP_SLOT:
-            *(int *)ptr = val;
+            write32le(ptr, val);
             break;
         case R_386_GOTPC:
+            write32le(ptr, read32le(ptr) + s1->got->sh_addr - addr);
-            *(int *)ptr += s1->got->sh_addr - addr;
+            break;
-            break;
+        case R_386_GOTOFF:
+            write32le(ptr, read32le(ptr) + val - s1->got->sh_addr);
+            break;
+        case R_386_GOT32:
+        case R_386_GOT32X:
+            /* we load the got offset */
+            write32le(ptr, read32le(ptr) + s1->sym_attrs[sym_index].got_offset);
+            break;
+        case R_386_16:
+            if (s1->output_format != TCC_OUTPUT_FORMAT_BINARY) {
+            output_file:
+                tcc_error("can only produce 16-bit binary files");
+            }
+            write16le(ptr, read16le(ptr) + val);
+            break;
+        case R_386_PC16:
+            if (s1->output_format != TCC_OUTPUT_FORMAT_BINARY)
+                goto output_file;
+            write16le(ptr, read16le(ptr) + val - addr);
+            break;
+        case R_386_RELATIVE:
+            /* do nothing */
+            break;
+        case R_386_COPY:
+            /* This reloction must copy initialized data from the library
+            to the program .bss segment. Currently made like for ARM
-        case R_386_GOTOFF:
+            (to remove noise of defaukt case). Is this true?
-            *(int *)ptr += val - s1->got->sh_addr;
+            */
             break;
+        default:
+            fprintf(stderr,"FIXME: handle reloc type %d at %x [%p] to %x\n",
-        case R_386_GOT32:
+                type, (unsigned)addr, ptr, (unsigned)val);
-            /* we load the got offset */
+            break;
-            *(int *)ptr += s1->got_offsets[sym_index];
+#elif defined(TCC_TARGET_ARM)
-            break;
+        case R_ARM_PC24:
+        case R_ARM_CALL:
+        case R_ARM_JUMP24:
+        case R_ARM_PLT32:
+            {
+                int x, is_thumb, is_call, h, blx_avail, is_bl, th_ko;
-#elif defined(TCC_TARGET_ARM)
+                x = (*(int *) ptr) & 0xffffff;
-	case R_ARM_PC24:
+		if (sym->st_shndx == SHN_UNDEF)
-	case R_ARM_PLT32:
+	            val = s1->plt->sh_addr;
-	    {
+#ifdef DEBUG_RELOC
+		printf ("reloc %d: x=0x%x val=0x%x ", type, x, val);
+#endif
+                (*(int *)ptr) &= 0xff000000;
+                if (x & 0x800000)
-                int x;
+                    x -= 0x1000000;
+                x <<= 2;
+                blx_avail = (TCC_ARM_VERSION >= 5);
+                is_thumb = val & 1;
+                is_bl = (*(unsigned *) ptr) >> 24 == 0xeb;
+                is_call = (type == R_ARM_CALL || (type == R_ARM_PC24 && is_bl));
+                x += val - addr;
-                x = (*(int *)ptr)&0xffffff;
+#ifdef DEBUG_RELOC
-                (*(int *)ptr) &= 0xff000000;
+		printf (" newx=0x%x name=%s\n", x,
-                if (x & 0x800000)
+			(char *) symtab_section->link->data + sym->st_name);
-                    x -= 0x1000000;
+#endif
+                h = x & 2;
+                th_ko = (x & 3) && (!blx_avail || !is_call);
+                if (th_ko || x >= 0x2000000 || x < -0x2000000)
+                    tcc_error("can't relocate value at %x,%d",addr, type);
+                x >>= 2;
-                x *= 4;
+                x &= 0xffffff;
-                x += val - addr;
+                /* Only reached if blx is avail and it is a call */
-                if((x & 3) != 0 || x >= 0x4000000 || x < -0x4000000)
+                if (is_thumb) {
+                    x |= h << 24;
+                    (*(int *)ptr) = 0xfa << 24; /* bl -> blx */
+                }
+                (*(int *) ptr) |= x;
+            }
+            break;
+        /* Since these relocations only concern Thumb-2 and blx instruction was
+           introduced before Thumb-2, we can assume blx is available and not
+           guard its use */
+        case R_ARM_THM_PC22:
+        case R_ARM_THM_JUMP24:
+            {
+                int x, hi, lo, s, j1, j2, i1, i2, imm10, imm11;
+                int to_thumb, is_call, to_plt, blx_bit = 1 << 12;
+                Section *plt;
+                /* weak reference */
+                if (sym->st_shndx == SHN_UNDEF &&
+                    ELFW(ST_BIND)(sym->st_info) == STB_WEAK)
+                    break;
+                /* Get initial offset */
+                hi = (*(uint16_t *)ptr);
+                lo = (*(uint16_t *)(ptr+2));
+                s = (hi >> 10) & 1;
+                j1 = (lo >> 13) & 1;
+                j2 = (lo >> 11) & 1;
+                i1 = (j1 ^ s) ^ 1;
+                i2 = (j2 ^ s) ^ 1;
+                imm10 = hi & 0x3ff;
+                imm11 = lo & 0x7ff;
+                x = (s << 24) | (i1 << 23) | (i2 << 22) |
+                    (imm10 << 12) | (imm11 << 1);
+                if (x & 0x01000000)
+                    x -= 0x02000000;
+                /* Relocation infos */
+                to_thumb = val & 1;
+                plt = s1->plt;
+                to_plt = (val >= plt->sh_addr) &&
+                         (val < plt->sh_addr + plt->data_offset);
+                is_call = (type == R_ARM_THM_PC22);
+                /* Compute final offset */
+                if (to_plt && !is_call) /* Point to 1st instr of Thumb stub */
+                    x -= 4;
+                x += val - addr;
+                if (!to_thumb && is_call) {
+                    blx_bit = 0; /* bl -> blx */
+                    x = (x + 3) & -4; /* Compute offset from aligned PC */
+                }
+                /* Check that relocation is possible
+                   * offset must not be out of range
+                   * if target is to be entered in arm mode:
+                     - bit 1 must not set
+                     - instruction must be a call (bl) or a jump to PLT */
+                if (!to_thumb || x >= 0x1000000 || x < -0x1000000)
+                    if (to_thumb || (val & 2) || (!is_call && !to_plt))
+                        tcc_error("can't relocate value at %x,%d",addr, type);
+                /* Compute and store final offset */
+                s = (x >> 24) & 1;
+                i1 = (x >> 23) & 1;
+                i2 = (x >> 22) & 1;
+                j1 = s ^ (i1 ^ 1);
+                j2 = s ^ (i2 ^ 1);
+                imm10 = (x >> 12) & 0x3ff;
+                imm11 = (x >> 1) & 0x7ff;
+                (*(uint16_t *)ptr) = (uint16_t) ((hi & 0xf800) |
+                                     (s << 10) | imm10);
+                (*(uint16_t *)(ptr+2)) = (uint16_t) ((lo & 0xc000) |
+                                (j1 << 13) | blx_bit | (j2 << 11) |
+                                imm11);
+            }
+            break;
+        case R_ARM_MOVT_ABS:
+        case R_ARM_MOVW_ABS_NC:
+            {
+                int x, imm4, imm12;
+                if (type == R_ARM_MOVT_ABS)
+                    val >>= 16;
+                imm12 = val & 0xfff;
+                imm4 = (val >> 12) & 0xf;
+                x = (imm4 << 16) | imm12;
+                if (type == R_ARM_THM_MOVT_ABS)
+                    *(int *)ptr |= x;
+                else
+                    *(int *)ptr += x;
+            }
+            break;
+        case R_ARM_THM_MOVT_ABS:
+        case R_ARM_THM_MOVW_ABS_NC:
+            {
+                int x, i, imm4, imm3, imm8;
+                if (type == R_ARM_THM_MOVT_ABS)
+                    val >>= 16;
+                imm8 = val & 0xff;
+                imm3 = (val >> 8) & 0x7;
+                i = (val >> 11) & 1;
+                imm4 = (val >> 12) & 0xf;
+                x = (imm3 << 28) | (imm8 << 16) | (i << 10) | imm4;
+                if (type == R_ARM_THM_MOVT_ABS)
+                    *(int *)ptr |= x;
+                else
+                    *(int *)ptr += x;
+            }
+            break;
+        case R_ARM_PREL31:
+            {
+                int x;
+                x = (*(int *)ptr) & 0x7fffffff;
+                (*(int *)ptr) &= 0x80000000;
-                    error("can't relocate value at %x",addr);
+                x = (x * 2) / 2;
-                x >>= 2;
+                x += val - addr;
-                x &= 0xffffff;
+                if((x^(x>>1))&0x40000000)
+                    tcc_error("can't relocate value at %x,%d",addr, type);
+                (*(int *)ptr) |= x & 0x7fffffff;
+            }
-                (*(int *)ptr) |= x;
+        case R_ARM_ABS32:
             *(int *)ptr += val;
-	    break;
+            break;
+        case R_ARM_REL32:
+            *(int *)ptr += val - addr;
+            break;
-	case R_ARM_ABS32:
+        case R_ARM_GOTPC:
-	    *(int *)ptr += val;
+            *(int *)ptr += s1->got->sh_addr - addr;
-	    break;
+            break;
-	case R_ARM_GOTPC:
+        case R_ARM_GOTOFF:
-	    *(int *)ptr += s1->got->sh_addr - addr;
+            *(int *)ptr += val - s1->got->sh_addr;
-	    break;
+            break;
+        case R_ARM_GOT32:
+            /* we load the got offset */
+            *(int *)ptr += s1->sym_attrs[sym_index].got_offset;
+            break;
+        case R_ARM_COPY:
+            break;
+        case R_ARM_V4BX:
+            /* trade Thumb support for ARMv4 support */
+            if ((0x0ffffff0 & *(int*)ptr) == 0x012FFF10)
+                *(int*)ptr ^= 0xE12FFF10 ^ 0xE1A0F000; /* BX Rm -> MOV PC, Rm */
+            break;
+        case R_ARM_GLOB_DAT:
+        case R_ARM_JUMP_SLOT:
+            *(addr_t *)ptr = val;
+            break;
+        case R_ARM_NONE:
+            /* Nothing to do.  Normally used to indicate a dependency
+               on a certain symbol (like for exception handling under EABI).  */
+            break;
+        default:
+            fprintf(stderr,"FIXME: handle reloc type %x at %x [%p] to %x\n",
+                type, (unsigned)addr, ptr, (unsigned)val);
+            break;
+#elif defined(TCC_TARGET_ARM64)
+        case R_AARCH64_ABS64:
+            write64le(ptr, val);
+            break;
+        case R_AARCH64_ABS32:
+            write32le(ptr, val);
+            break;
+        case R_AARCH64_MOVW_UABS_G0_NC:
+            write32le(ptr, ((read32le(ptr) & 0xffe0001f) |
+                            (val & 0xffff) << 5));
+            break;
+        case R_AARCH64_MOVW_UABS_G1_NC:
+            write32le(ptr, ((read32le(ptr) & 0xffe0001f) |
+                            (val >> 16 & 0xffff) << 5));
+            break;
+        case R_AARCH64_MOVW_UABS_G2_NC:
+            write32le(ptr, ((read32le(ptr) & 0xffe0001f) |
+                            (val >> 32 & 0xffff) << 5));
+            break;
+        case R_AARCH64_MOVW_UABS_G3:
+            write32le(ptr, ((read32le(ptr) & 0xffe0001f) |
+                            (val >> 48 & 0xffff) << 5));
+            break;
+        case R_AARCH64_ADR_PREL_PG_HI21: {
+            uint64_t off = (val >> 12) - (addr >> 12);
+            if ((off + ((uint64_t)1 << 20)) >> 21)
+                tcc_error("R_AARCH64_ADR_PREL_PG_HI21 relocation failed");
+            write32le(ptr, ((read32le(ptr) & 0x9f00001f) |
+                            (off & 0x1ffffc) << 3 | (off & 3) << 29));
+            break;
+        }
+        case R_AARCH64_ADD_ABS_LO12_NC:
+            write32le(ptr, ((read32le(ptr) & 0xffc003ff) |
+                            (val & 0xfff) << 10));
+            break;
+        case R_AARCH64_JUMP26:
+        case R_AARCH64_CALL26:
+	    /* This check must match the one in build_got_entries, testing
+	       if we really need a PLT slot.  */
+	    if (sym->st_shndx == SHN_UNDEF)
+	        /* We've put the PLT slot offset into r_addend when generating
+		   it, and that's what we must use as relocation value (adjusted
+		   by section offset of course).  */
+		val = s1->plt->sh_addr + rel->r_addend;
+#ifdef DEBUG_RELOC
+	    printf ("reloc %d @ 0x%lx: val=0x%lx name=%s\n", type, addr, val,
+		    (char *) symtab_section->link->data + sym->st_name);
+#endif
+            if (((val - addr) + ((uint64_t)1 << 27)) & ~(uint64_t)0xffffffc)
+	      {
+                tcc_error("R_AARCH64_(JUMP|CALL)26 relocation failed (val=%lx, addr=%lx)", addr, val);
+	      }
+            write32le(ptr, (0x14000000 |
+                            (uint32_t)(type == R_AARCH64_CALL26) << 31 |
+                            ((val - addr) >> 2 & 0x3ffffff)));
+            break;
+        case R_AARCH64_ADR_GOT_PAGE: {
+            uint64_t off =
+                (((s1->got->sh_addr +
+                   s1->sym_attrs[sym_index].got_offset) >> 12) - (addr >> 12));
+            if ((off + ((uint64_t)1 << 20)) >> 21)
+                tcc_error("R_AARCH64_ADR_GOT_PAGE relocation failed");
+            write32le(ptr, ((read32le(ptr) & 0x9f00001f) |
+                            (off & 0x1ffffc) << 3 | (off & 3) << 29));
+            break;
+        }
+        case R_AARCH64_LD64_GOT_LO12_NC:
+            write32le(ptr,
+                      ((read32le(ptr) & 0xfff803ff) |
+                       ((s1->got->sh_addr +
+                         s1->sym_attrs[sym_index].got_offset) & 0xff8) << 7));
+            break;
+        case R_AARCH64_COPY:
+            break;
+        case R_AARCH64_GLOB_DAT:
+        case R_AARCH64_JUMP_SLOT:
+            /* They don't need addend */
+#ifdef DEBUG_RELOC
-        case R_ARM_GOT32:
+	    printf ("reloc %d @ 0x%lx: val=0x%lx name=%s\n", type, addr,
-            /* we load the got offset */
+		    val - rel->r_addend,
-            *(int *)ptr += s1->got_offsets[sym_index];
+		    (char *) symtab_section->link->data + sym->st_name);
-            break;
+#endif
-	case R_ARM_COPY:
+            write64le(ptr, val - rel->r_addend);
             break;
-	default:
+        default:
-	    fprintf(stderr,"FIXME: handle reloc type %x at %lx [%.8x] to %lx\n",
+            fprintf(stderr, "FIXME: handle reloc type %x at %x [%p] to %x\n",
-                    type,addr,(unsigned int )ptr,val);
+                    type, (unsigned)addr, ptr, (unsigned)val);
             break;
 #elif defined(TCC_TARGET_C67)
-	case R_C60_32:
+        case R_C60_32:
-	    *(int *)ptr += val;
+            *(int *)ptr += val;
-	    break;
+            break;
         case R_C60LO16:
             {
                 uint32_t orig;
-                /* put the low 16 bits of the absolute address */
+                /* put the low 16 bits of the absolute address
-                // add to what is already there
+                   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
+                /* 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 %x [%p] to %x\n",
+                type, (unsigned)addr, ptr, (unsigned)val);
+            break;
+#elif defined(TCC_TARGET_X86_64)
+        case R_X86_64_64:
+            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 = ELFW(R_INFO)(esym_index, R_X86_64_64);
+		    qrel->r_addend = rel->r_addend;
+                    qrel++;
+                    break;
+                } else {
+		    qrel->r_info = ELFW(R_INFO)(0, R_X86_64_RELATIVE);
+		    qrel->r_addend = read64le(ptr) + val;
+                    qrel++;
+                }
+            }
+            write64le(ptr, read64le(ptr) + val);
+            break;
+        case R_X86_64_32:
+        case R_X86_64_32S:
+            if (s1->output_type == TCC_OUTPUT_DLL) {
+                /* XXX: this logic may depend on TCC's codegen
+                   now TCC uses R_X86_64_32 even for a 64bit pointer */
+                qrel->r_info = ELFW(R_INFO)(0, R_X86_64_RELATIVE);
+		/* Use sign extension! */
+                qrel->r_addend = (int)read32le(ptr) + val;
+                qrel++;
+            }
+            write32le(ptr, read32le(ptr) + val);
+            break;
+        case R_X86_64_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 = ELFW(R_INFO)(esym_index, R_X86_64_PC32);
+		    /* Use sign extension! */
+                    qrel->r_addend = (int)read32le(ptr);
+                    qrel++;
+                    break;
+                }
+            }
+            goto plt32pc32;
+        case R_X86_64_PLT32:
+	    /* We've put the PLT slot offset into r_addend when generating
+	       it, and that's what we must use as relocation value (adjusted
+	       by section offset of course).  */
+	    val = s1->plt->sh_addr + rel->r_addend;
+	    /* fallthrough.  */
+	plt32pc32:
+	{
+            long long diff;
+            diff = (long long)val - addr;
+            if (diff < -2147483648LL || diff > 2147483647LL) {
+                tcc_error("internal error: relocation failed");
+            }
+            write32le(ptr, read32le(ptr) + diff);
+        }
+            break;
+        case R_X86_64_GLOB_DAT:
+        case R_X86_64_JUMP_SLOT:
+            /* They don't need addend */
+            write64le(ptr, val - rel->r_addend);
+            break;
+        case R_X86_64_GOTPCREL:
+	case R_X86_64_GOTPCRELX:
+	case R_X86_64_REX_GOTPCRELX:
             write32le(ptr, read32le(ptr) +
-                *(int *) ptr    = (*(int *) ptr    & (~(0xffff << 7)) ) |  (((val+orig)      & 0xffff) << 7);
+                      (s1->got->sh_addr - addr +
-                *(int *)(ptr+4) = (*(int *)(ptr+4) & (~(0xffff << 7)) ) | ((((val+orig)>>16) & 0xffff) << 7);
+                       s1->sym_attrs[sym_index].got_offset - 4));
             break;
-            break;
+        case R_X86_64_GOTTPOFF:
 /* relocate relocation table in 'sr' */
 static void relocate_rel(TCCState *s1, Section *sr)
+{
     Section *s;
-    Elf32_Rel *rel, *rel_end;
+    ElfW_Rel *rel;
-    s = s1->sections[sr->sh_info];
-    rel_end = (Elf32_Rel *)(sr->data + sr->data_offset);
-    for(rel = (Elf32_Rel *)sr->data;
-        rel < rel_end;
+    s = s1->sections[sr->sh_info];
-        rel++) {
+    for_each_elem(sr, 0, rel, ElfW_Rel)
-        rel->r_offset += s->sh_addr;
         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;
+    ElfW_Rel *rel;
+    int sym_index, esym_index, type, count;
-    count = 0;
-    rel_end = (Elf32_Rel *)(sr->data + sr->data_offset);
+    count = 0;
+    for_each_elem(sr, 0, rel, ElfW_Rel) {
-    for(rel = (Elf32_Rel *)sr->data; rel < rel_end; rel++) {
+        sym_index = ELFW(R_SYM)(rel->r_info);
+        type = ELFW(R_TYPE)(rel->r_info);
+        switch(type) {
+#if defined(TCC_TARGET_I386)
+        case R_386_32:
+#elif defined(TCC_TARGET_X86_64)
-        sym_index = ELF32_R_SYM(rel->r_info);
+        case R_X86_64_32:
-        type = ELF32_R_TYPE(rel->r_info);
+        case R_X86_64_32S:
+        case R_X86_64_64:
-        switch(type) {
+#endif
+            count++;
+            break;
+#if defined(TCC_TARGET_I386)
-        case R_386_32:
+        case R_386_PC32:
-            count++;
+#elif defined(TCC_TARGET_X86_64)
-            break;
+        case R_X86_64_PC32:
-        case R_386_PC32:
+#endif
             esym_index = s1->symtab_to_dynsym[sym_index];
+        }
+    }
     if (count) {
         /* allocate the section */
         sr->sh_flags |= SHF_ALLOC;
-        sr->sh_size = count * sizeof(Elf32_Rel);
+        sr->sh_size = count * sizeof(ElfW_Rel);
+    }
     return count;
+}
-static void put_got_offset(TCCState *s1, int index, unsigned long val)
+static struct sym_attr *alloc_sym_attr(TCCState *s1, int index)
+{
     int n;
-    unsigned long *tab;
+    struct sym_attr *tab;
-    if (index >= s1->nb_got_offsets) {
+    if (index >= s1->nb_sym_attrs) {
         /* 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)
+            n *= 2;
-            error("memory full");
+        tab = tcc_realloc(s1->sym_attrs, n * sizeof(*s1->sym_attrs));
-        s1->got_offsets = tab;
+        s1->sym_attrs = tab;
-        memset(s1->got_offsets + s1->nb_got_offsets, 0,
+        memset(s1->sym_attrs + s1->nb_sym_attrs, 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;
+               (n - s1->nb_sym_attrs) * sizeof(*s1->sym_attrs));
-    p[3] = val >> 24;
-}
+        s1->nb_sym_attrs = n;
-#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);
     return &s1->sym_attrs[index];
 #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, ELFW(ST_INFO)(STB_GLOBAL, STT_OBJECT),
+, s1->got->sh_num, "_GLOBAL_OFFSET_TABLE_");
+    ptr = section_ptr_add(s1->got, 3 * PTR_SIZE);
+#if PTR_SIZE == 4
+    /* keep space for _DYNAMIC pointer, if present */
+    write32le(ptr, 0);
-    s1->got->sh_entsize = 4;
+    /* two dummy got entries */
-    add_elf_sym(symtab_section, 0, 4, ELF32_ST_INFO(STB_GLOBAL, STT_OBJECT),
+    write32le(ptr + 4, 0);
+    write32le(ptr + 8, 0);
-, s1->got->sh_num, "_GLOBAL_OFFSET_TABLE_");
+#else
-    ptr = section_ptr_add(s1->got, 3 * sizeof(int));
+    /* keep space for _DYNAMIC pointer, if present */
+    write32le(ptr, 0);
-    /* keep space for _DYNAMIC pointer, if present */
+    write32le(ptr + 4, 0);
+    /* two dummy got entries */
+    write32le(ptr + 8, 0);
-    put32(ptr, 0);
+    write32le(ptr + 12, 0);
-    /* two dummy got entries */
+    write32le(ptr + 16, 0);
-    put32(ptr + 4, 0);
+    write32le(ptr + 20, 0);
+#endif
-    put32(ptr + 8, 0);
+}
 /* put a got or plt entry corresponding to a symbol in symtab_section. 'size'
-/* 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.
-   and 'info' can be modifed if more precise info comes from the DLL */
+   Returns offset of GOT or PLT slot.  */
-static void put_got_entry(TCCState *s1,
+static unsigned long put_got_entry(TCCState *s1,
-                          int reloc_type, unsigned long size, int info,
+				   int reloc_type, unsigned long size, int info,
-                          int sym_index)
+				   int sym_index)
+{
+    int index, need_plt_entry;
-    int index;
+    const char *name;
-    const char *name;
+    ElfW(Sym) *sym;
+    unsigned long offset;
+    int *ptr;
-    Elf32_Sym *sym;
+    struct sym_attr *symattr;
-    unsigned long offset;
+    if (!s1->got)
+        build_got(s1);
-    int *ptr;
+    need_plt_entry =
+#ifdef TCC_TARGET_X86_64
+        (reloc_type == R_X86_64_JUMP_SLOT);
+#elif defined(TCC_TARGET_I386)
+        (reloc_type == R_386_JMP_SLOT);
+#elif defined(TCC_TARGET_ARM)
+        (reloc_type == R_ARM_JUMP_SLOT);
-    if (!s1->got)
+#elif defined(TCC_TARGET_ARM64)
+        (reloc_type == R_AARCH64_JUMP_SLOT);
+#else
+;
+#endif
+    if (need_plt_entry && !s1->plt) {
+	/* add PLT */
+	s1->plt = new_section(s1, ".plt", SHT_PROGBITS,
+			      SHF_ALLOC | SHF_EXECINSTR);
+	s1->plt->sh_entsize = 4;
+    }
+    /* If a got/plt entry already exists for that symbol, no need to add one */
+    if (sym_index < s1->nb_sym_attrs) {
-        build_got(s1);
+	if (need_plt_entry && s1->sym_attrs[sym_index].plt_offset)
+	  return s1->sym_attrs[sym_index].plt_offset;
+	else if (!need_plt_entry && s1->sym_attrs[sym_index].got_offset)
+	  return s1->sym_attrs[sym_index].got_offset;
-    /* 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)
+    symattr = alloc_sym_attr(s1, sym_index);
-        return;
     /* Only store the GOT offset if it's not generated for the PLT entry.  */
-    put_got_offset(s1, sym_index, s1->got->data_offset);
+    if (!need_plt_entry)
         symattr->got_offset = s1->got->data_offset;
+    sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
+    name = (char *) symtab_section->link->data + sym->st_name;
+    offset = sym->st_value;
-    if (s1->dynsym) {
+#if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64)
-        sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
+        if (need_plt_entry) {
-        name = symtab_section->link->data + sym->st_name;
+            Section *plt;
-        offset = sym->st_value;
+            uint8_t *p;
-#ifdef TCC_TARGET_I386
+            int modrm;
+	    unsigned long relofs;
         if (reloc_type == R_386_JMP_SLOT) {
-            Section *plt;
+#if defined(TCC_OUTPUT_DLL_WITH_PLT)
-            uint8_t *p;
+            modrm = 0x25;
-            int modrm;
+#else
             /* if we build a DLL, we add a %ebx offset */
-            /* if we build a DLL, we add a %ebx offset */
+            if (s1->output_type == TCC_OUTPUT_DLL)
-            if (s1->output_type == TCC_OUTPUT_DLL)
+                modrm = 0xa3;
-                modrm = 0xa3;
+            else
-            else
+                modrm = 0x25;
-                modrm = 0x25;
+#endif
             /* 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 + PTR_SIZE */
-            plt = s1->plt;
+                p[1] = modrm + 0x10;
-            if (plt->data_offset == 0) {
+                write32le(p + 2, PTR_SIZE);
-                /* first plt entry */
+                p[6] = 0xff; /* jmp *(got + PTR_SIZE * 2) */
-                p = section_ptr_add(plt, 16);
+                p[7] = modrm;
-                p[0] = 0xff; /* pushl got + 4 */
+                write32le(p + 8, PTR_SIZE * 2);
+            }
+	    /* The PLT slot refers to the relocation entry it needs
+	       via offset.  The reloc entry is created below, so its
-                p[1] = modrm + 0x10;
+	       offset is the current data_offset.  */
+	    relofs = s1->got->reloc ? s1->got->reloc->data_offset : 0;
-                put32(p + 2, 4);
+            symattr->plt_offset = plt->data_offset;
-                p[6] = 0xff; /* jmp *(got + 8) */
+            p = section_ptr_add(plt, 16);
+            p[0] = 0xff; /* jmp *(got + x) */
-                p[7] = modrm;
+            p[1] = modrm;
-                put32(p + 8, 8);
+            write32le(p + 2, s1->got->data_offset);
-            }
+            p[6] = 0x68; /* push $xxx */
 #ifdef TCC_TARGET_X86_64
-            p = section_ptr_add(plt, 16);
+	    /* On x86-64, the relocation is referred to by _index_.  */
-            p[0] = 0xff; /* jmp *(got + x) */
+	    write32le(p + 7, relofs / sizeof (ElfW_Rel));
-            p[1] = modrm;
+#else
-            put32(p + 2, s1->got->data_offset);
+            write32le(p + 7, relofs);
-            p[6] = 0x68; /* push $xxx */
+#endif
-            put32(p + 7, (plt->data_offset - 32) >> 1);
+            p[11] = 0xe9; /* jmp plt_start */
-            p[11] = 0xe9; /* jmp plt_start */
+            write32le(p + 12, -(plt->data_offset));
-            put32(p + 12, -(plt->data_offset));
 	    /* If this was an UNDEF symbol set the offset in the
-            /* the symbol is modified so that it will be relocated to
+	       dynsymtab to the PLT slot, so that PC32 relocs to it
-               the PLT */
+	       can be resolved.  */
-            if (s1->output_type == TCC_OUTPUT_EXE)
+	    if (sym->st_shndx == SHN_UNDEF)
-                offset = plt->data_offset - 16;
+	        offset = plt->data_offset - 16;
         }
 #elif defined(TCC_TARGET_ARM)
-	if (reloc_type == R_ARM_JUMP_SLOT) {
+        if (need_plt_entry) {
             Section *plt;
             uint8_t *p;
+            /* if we build a DLL, we add a %ebx offset */
+            if (s1->output_type == TCC_OUTPUT_DLL)
+                tcc_error("DLLs unimplemented!");
+            /* add a PLT entry */
+            plt = s1->plt;
             if (plt->data_offset == 0) {
-            /* if we build a DLL, we add a %ebx offset */
+                /* first plt entry */
-            if (s1->output_type == TCC_OUTPUT_DLL)
+                p = section_ptr_add(plt, 16);
-                error("DLLs unimplemented!");
+                write32le(p,    0xe52de004); /* push {lr}         */
+                write32le(p+4,  0xe59fe010); /* ldr lr, [pc, #16] */
-            /* add a PLT entry */
+                write32le(p+8,  0xe08fe00e); /* add lr, pc, lr    */
-            plt = s1->plt;
+                write32le(p+12, 0xe5bef008); /* ldr pc, [lr, #8]! */
+            }
+            symattr->plt_offset = plt->data_offset;
+            if (symattr->plt_thumb_stub) {
+                p = section_ptr_add(plt, 20);
+                write32le(p,   0x4778); /* bx pc */
+                write32le(p+2, 0x46c0); /* nop   */
+                p += 4;
-            if (plt->data_offset == 0) {
+            } else
+                p = section_ptr_add(plt, 16);
+            write32le(p,   0xe59fc004); /* ldr ip, [pc, #4] ; GOT entry offset */
+            write32le(p+4, 0xe08fc00c); /* add ip, pc, ip ; addr of GOT entry  */
+            write32le(p+8, 0xe59cf000); /* ldr pc, [ip] ; jump to GOT entry */
+            write32le(p+12, s1->got->data_offset); /* GOT entry off once patched */
+            /* the symbol is modified so that it will be relocated to
+               the PLT */
+	    if (sym->st_shndx == SHN_UNDEF)
+                offset = plt->data_offset - 16;
+        }
-                /* first plt entry */
+#elif defined(TCC_TARGET_ARM64)
-                p = section_ptr_add(plt, 16);
+        if (need_plt_entry) {
-		put32(p     , 0xe52de004);
+            Section *plt;
+            uint8_t *p;
-		put32(p +  4, 0xe59fe010);
+            if (s1->output_type == TCC_OUTPUT_DLL)
-		put32(p +  8, 0xe08fe00e);
+                tcc_error("DLLs unimplemented!");
 		put32(p + 12, 0xe5bef008);
             plt = s1->plt;
+            if (plt->data_offset == 0)
+                section_ptr_add(plt, 32);
             symattr->plt_offset = plt->data_offset;
             p = section_ptr_add(plt, 16);
+            write32le(p, s1->got->data_offset);
-	    put32(p  , 0xe59fc004);
+            write32le(p + 4, (uint64_t)s1->got->data_offset >> 32);
 	    put32(p+4, 0xe08fc00c);
-	    put32(p+8, 0xe59cf000);
+            if (sym->st_shndx == SHN_UNDEF)
-	    put32(p+12, s1->got->data_offset);
+                offset = plt->data_offset - 16;
+        }
+#elif defined(TCC_TARGET_C67)
+    if (s1->dynsym) {
+        tcc_error("C67 got not implemented");
+    }
+#else
+#error unsupported CPU
 #endif
+    if (s1->dynsym) {
-            /* the symbol is modified so that it will be relocated to
+	/* XXX This might generate multiple syms for name.  */
-               the PLT */
+        index = put_elf_sym(s1->dynsym, offset,
+                            size, info, 0, sym->st_shndx, name);
+        /* Create the relocation (it's against the GOT for PLT
+	   and GOT relocs).  */
+        put_elf_reloc(s1->dynsym, s1->got,
-            if (s1->output_type == TCC_OUTPUT_EXE)
+                      s1->got->data_offset,
-                offset = plt->data_offset - 16;
+                      reloc_type, index);
-        }
+    } else {
-#elif defined(TCC_TARGET_C67)
+	/* Without .dynsym (i.e. static link or memory output) we
-        error("C67 got not implemented");
+	   still need relocs against the generated got, so as to fill
-#else
+	   the entries with the symbol values (determined later).  */
-#error unsupported CPU
+	put_elf_reloc(symtab_section, s1->got,
-#endif
+                      s1->got->data_offset,
-        index = put_elf_sym(s1->dynsym, offset,
+                      reloc_type, sym_index);
                             size, info, 0, sym->st_shndx, name);
-        /* put a got entry */
+    /* And now create the GOT slot itself.  */
-        put_elf_reloc(s1->dynsym, s1->got,
+    ptr = section_ptr_add(s1->got, PTR_SIZE);
-                      s1->got->data_offset,
+    *ptr = 0;
-                      reloc_type, index);
+    if (need_plt_entry)
       return symattr->plt_offset;
-    ptr = section_ptr_add(s1->got, sizeof(int));
-    *ptr = 0;
-}
+    else
-/* build GOT and PLT entries */
-static void build_got_entries(TCCState *s1)
+      return symattr->got_offset;
+}
     Section *s, *symtab;
-    Elf32_Rel *rel, *rel_end;
+/* build GOT and PLT entries */
+ST_FUNC void build_got_entries(TCCState *s1)
     Elf32_Sym *sym;
-    int i, type, reloc_type, sym_index;
+    Section *s;
     ElfW_Rel *rel;
-    for(i = 1; i < s1->nb_sections; i++) {
+    ElfW(Sym) *sym;
-        s = s1->sections[i];
+    int i, type, reloc_type, sym_index;
-        if (s->sh_type != SHT_REL)
+    for(i = 1; i < s1->nb_sections; i++) {
-            continue;
+        s = s1->sections[i];
-        /* no need to handle got relocations */
+        if (s->sh_type != SHT_RELX)
-        if (s->link != symtab_section)
+            continue;
-            continue;
+        /* no need to handle got relocations */
-        symtab = s->link;
+        if (s->link != symtab_section)
-        rel_end = (Elf32_Rel *)(s->data + s->data_offset);
+            continue;
-        for(rel = (Elf32_Rel *)s->data;
+        for_each_elem(s, 0, rel, ElfW_Rel) {
-            rel < rel_end;
+            type = ELFW(R_TYPE)(rel->r_info);
-            rel++) {
+            switch(type) {
-            type = ELF32_R_TYPE(rel->r_info);
+#if defined(TCC_TARGET_I386)
-            switch(type) {
+            case R_386_GOT32:
-#if defined(TCC_TARGET_I386)
+            case R_386_GOT32X:
+            case R_386_GOTOFF:
+            case R_386_GOTPC:
+            case R_386_PLT32:
-            case R_386_GOT32:
+                if (!s1->got)
-            case R_386_GOTOFF:
+                    build_got(s1);
-            case R_386_GOTPC:
+                if (type == R_386_GOT32 || type == R_386_GOT32X ||
-            case R_386_PLT32:
+                    type == R_386_PLT32) {
-                if (!s1->got)
+                    sym_index = ELFW(R_SYM)(rel->r_info);
-                    build_got(s1);
+                    sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
-                if (type == R_386_GOT32 || type == R_386_PLT32) {
-                    sym_index = ELF32_R_SYM(rel->r_info);
+                    /* look at the symbol got offset. If none, then add one */
-                    sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
+                    if (type == R_386_GOT32 || type == R_386_GOT32X)
+                        reloc_type = R_386_GLOB_DAT;
+                    else
+                        reloc_type = R_386_JMP_SLOT;
-                    /* look at the symbol got offset. If none, then add one */
+                    put_got_entry(s1, reloc_type, sym->st_size, sym->st_info,
-                    if (type == R_386_GOT32)
+                                  sym_index);
                         reloc_type = R_386_GLOB_DAT;
-                    else
+                break;
-                        reloc_type = R_386_JMP_SLOT;
+#elif defined(TCC_TARGET_ARM)
+            case R_ARM_PC24:
+            case R_ARM_CALL:
+            case R_ARM_JUMP24:
+            case R_ARM_GOT32:
+            case R_ARM_GOTOFF:
+            case R_ARM_GOTPC:
+            case R_ARM_PLT32:
+                if (!s1->got)
+                    build_got(s1);
+                sym_index = ELFW(R_SYM)(rel->r_info);
+                sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
+		if (type != R_ARM_GOTOFF && type != R_ARM_GOTPC
+		    && sym->st_shndx == SHN_UNDEF) {
+                    unsigned long ofs;
+                    /* 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;
+                    ofs = put_got_entry(s1, reloc_type, sym->st_size,
+				        sym->st_info, sym_index);
+#ifdef DEBUG_RELOC
+                    printf ("maybegot: %s, %d, %d --> ofs=0x%x\n",
+			    (char *) symtab_section->link->data + sym->st_name,
+			    type, sym->st_shndx, ofs);
+#endif
+		    if (type != R_ARM_GOT32) {
+			addr_t *ptr = (addr_t*)(s1->sections[s->sh_info]->data
+						+ rel->r_offset);
+			/* x must be signed!  */
+			int x = *ptr & 0xffffff;
+			x = (x << 8) >> 8;
+			x <<= 2;
+			x += ofs;
+			x >>= 2;
+#ifdef DEBUG_RELOC
+			printf ("insn=0x%x --> 0x%x (x==0x%x)\n", *ptr,
+				(*ptr & 0xff000000) | x, x);
+#endif
+			*ptr = (*ptr & 0xff000000) | x;
+		    }
+                }
+                break;
+            case R_ARM_THM_JUMP24:
+                sym_index = ELFW(R_SYM)(rel->r_info);
+                sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
+                /* We are relocating a jump from thumb code to arm code */
+                if (sym->st_shndx != SHN_UNDEF && !(sym->st_value & 1)) {
+                    int index;
+                    uint8_t *p;
+                    char *name, buf[1024];
+                    Section *text_section;
+                    name = (char *) symtab_section->link->data + sym->st_name;
+                    text_section = s1->sections[sym->st_shndx];
+                    /* Modify reloc to target a thumb stub to switch to ARM */
+                    snprintf(buf, sizeof(buf), "%s_from_thumb", name);
+                    index = put_elf_sym(symtab_section,
+                                        text_section->data_offset + 1,
+                                        sym->st_size, sym->st_info, 0,
+                                        sym->st_shndx, buf);
-                    put_got_entry(s1, reloc_type, sym->st_size, sym->st_info,
+                    rel->r_info = ELFW(R_INFO)(index, type);
-                                  sym_index);
+                    /* Create a thumb stub fonction to switch to ARM mode */
+                    put_elf_reloc(symtab_section, text_section,
+                                  text_section->data_offset + 4, R_ARM_JUMP24,
+                                  sym_index);
+                    p = section_ptr_add(text_section, 8);
+                    write32le(p,   0x4778); /* bx pc */
+                    write32le(p+2, 0x46c0); /* nop   */
+                    write32le(p+4, 0xeafffffe); /* b $sym */
+                }
+#elif defined(TCC_TARGET_ARM64)
+                //xx Other cases may be required here:
+            case R_AARCH64_ADR_GOT_PAGE:
+            case R_AARCH64_LD64_GOT_LO12_NC:
+                if (!s1->got)
+                    build_got(s1);
+                sym_index = ELFW(R_SYM)(rel->r_info);
+                sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
                 reloc_type = R_AARCH64_GLOB_DAT;
-                break;
+                put_got_entry(s1, reloc_type, sym->st_size, sym->st_info,
-#elif defined(TCC_TARGET_ARM)
+                              sym_index);
-	    case R_ARM_GOT32:
+                break;
             case R_ARM_GOTOFF:
-            case R_ARM_GOTPC:
+	    case R_AARCH64_JUMP26:
-            case R_ARM_PLT32:
+	    case R_AARCH64_CALL26:
                 if (!s1->got)
                     build_got(s1);
-                if (type == R_ARM_GOT32 || type == R_ARM_PLT32) {
+                sym_index = ELFW(R_SYM)(rel->r_info);
-                    sym_index = ELF32_R_SYM(rel->r_info);
+                sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
-                    sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
+                if (sym->st_shndx == SHN_UNDEF) {
-                    /* look at the symbol got offset. If none, then add one */
+		    unsigned long ofs;
-                    if (type == R_ARM_GOT32)
+		    reloc_type = R_AARCH64_JUMP_SLOT;
-                        reloc_type = R_ARM_GLOB_DAT;
+                    ofs = put_got_entry(s1, reloc_type, sym->st_size,
-                    else
+					sym->st_info, sym_index);
-                        reloc_type = R_ARM_JUMP_SLOT;
+		    /* We store the place of the generated PLT slot
-                    put_got_entry(s1, reloc_type, sym->st_size, sym->st_info,
+		       in our addend.  */
-                                  sym_index);
+		    rel->r_addend += ofs;
+                }
-                break;
+		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 = ELFW(R_SYM)(rel->r_info);
+                    sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
+                    /* look at the symbol got offset. If none, then add one */
+                    if (type == R_C60_GOT32)
+                        reloc_type = R_C60_GLOB_DAT;
+                    else
+                        reloc_type = R_C60_JMP_SLOT;
+                    put_got_entry(s1, reloc_type, sym->st_size, sym->st_info,
+                                  sym_index);
+                }
+                break;
+#elif defined(TCC_TARGET_X86_64)
+            case R_X86_64_GOT32:
+            case R_X86_64_GOTTPOFF:
+            case R_X86_64_GOTPCREL:
+	    case R_X86_64_GOTPCRELX:
+	    case R_X86_64_REX_GOTPCRELX:
+            case R_X86_64_PLT32:
+                sym_index = ELFW(R_SYM)(rel->r_info);
+                sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
+		if (type == R_X86_64_PLT32 &&
+		    ELFW(ST_VISIBILITY)(sym->st_other) != STV_DEFAULT)
+		  {
+		    rel->r_info = ELFW(R_INFO)(sym_index, R_X86_64_PC32);
+		    break;
+		  }
+                if (!s1->got) {
+                    build_got(s1);
+                    sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
 #elif defined(TCC_TARGET_C67)
-	    case R_C60_GOT32:
+                if (type == R_X86_64_GOT32 || type == R_X86_64_GOTPCREL ||
-            case R_C60_GOTOFF:
+		    type == R_X86_64_GOTPCRELX ||
-            case R_C60_GOTPC:
+		    type == R_X86_64_REX_GOTPCRELX ||
-            case R_C60_PLT32:
+                    type == R_X86_64_PLT32) {
-                if (!s1->got)
+		    unsigned long ofs;
-                    build_got(s1);
+                    /* look at the symbol got offset. If none, then add one */
-                if (type == R_C60_GOT32 || type == R_C60_PLT32) {
+		    if (type == R_X86_64_PLT32)
-                    sym_index = ELF32_R_SYM(rel->r_info);
+		        reloc_type = R_X86_64_JUMP_SLOT;
-                    sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
+		    else
-                    /* look at the symbol got offset. If none, then add one */
+                        reloc_type = R_X86_64_GLOB_DAT;
-                    if (type == R_C60_GOT32)
+                    ofs = put_got_entry(s1, reloc_type, sym->st_size,
-                        reloc_type = R_C60_GLOB_DAT;
+					sym->st_info, sym_index);
-                    else
+		    if (type == R_X86_64_PLT32)
-                        reloc_type = R_C60_JMP_SLOT;
+		        /* We store the place of the generated PLT slot
-                    put_got_entry(s1, reloc_type, sym->st_size, sym->st_info,
+			   in our addend.  */
-                                  sym_index);
+		        rel->r_addend += ofs;
                 }
                 break;
 #else
 #error unsupported CPU
 #endif
     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)
+static void put_dt(Section *dynamic, int dt, addr_t val)
 {
-    Elf32_Dyn *dyn;
+    ElfW(Dyn) *dyn;
-    dyn = section_ptr_add(dynamic, sizeof(Elf32_Dyn));
+    dyn = section_ptr_add(dynamic, sizeof(ElfW(Dyn)));
     dyn->d_tag = dt;
     dyn->d_un.d_val = val;
+}
         end_offset = s->data_offset;
+    }
     add_elf_sym(symtab_section,
 , 0,
-                ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0,
+                ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
                 s->sh_num, sym_start);
     add_elf_sym(symtab_section,
                 end_offset, 0,
-                ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0,
+                ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
                 s->sh_num, sym_end);
-}
+}
 /* add tcc runtime libraries */
-static void tcc_add_runtime(TCCState *s1)
+static int tcc_add_support(TCCState *s1, const char *filename)
+{
+    char buf[1024];
+    snprintf(buf, sizeof(buf), "%s/%s/%s", s1->tcc_lib_path,
+    /* an cpu specific path inside tcc_lib_path, mainly for keeping libtcc1.a */
+    #ifdef TCC_TARGET_I386
+	"i386"
+    #endif
+    #ifdef TCC_TARGET_X86_64
+        "x86-64"
+    #endif
+    #ifdef TCC_TARGET_ARM
+	"arm"
+    #endif
+    #ifdef TCC_TARGET_ARM64
+	"arm64"
+    #endif
+    #ifdef TCC_TARGET_C67
+	"C67"
+    #endif
+	,filename);
+    return tcc_add_file(s1, buf, TCC_FILETYPE_BINARY);
+}
-    char buf[1024];
+ST_FUNC void tcc_add_bcheck(TCCState *s1)
+{
 #ifdef CONFIG_TCC_BCHECK
-    if (do_bounds_check) {
-        unsigned long *ptr;
+    addr_t *ptr;
         Section *init_section;
-        unsigned char *pinit;
+    if (0 == s1->do_bounds_check)
-        int sym_index;
+        return;
-        /* XXX: add an object file to do that */
+    /* XXX: add an object file to do that */
-        ptr = section_ptr_add(bounds_section, sizeof(unsigned long));
+    ptr = section_ptr_add(bounds_section, sizeof(*ptr));
-        *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 */
+    *ptr = 0;
-        snprintf(buf, sizeof(buf), "%s/%s", tcc_lib_path, "bcheck.o");
+    add_elf_sym(symtab_section, 0, 0,
+                ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
+                bounds_section->sh_num, "__bounds_start");
+    if (s1->output_type != TCC_OUTPUT_MEMORY) {
+        /* add 'call __bound_init()' in .init section */
+        /* XXX not called on MSYS, reason is unknown. For this
+           case a call to __bound_init is performed in bcheck.c
+           when __bound_ptr_add, __bound_new_region,
-        tcc_add_file(s1, buf);
+           __bound_delete_region called */
-#ifdef TCC_TARGET_I386
-        if (s1->output_type != TCC_OUTPUT_MEMORY) {
+	int sym_index = find_elf_sym(symtab_section, "__bound_init");
-            /* add 'call __bound_init()' in .init section */
+	if (sym_index) {
-            init_section = find_section(s1, ".init");
-            pinit = section_ptr_add(init_section, 5);
+    	    Section *init_section = find_section(s1, ".init");
-            pinit[0] = 0xe8;
+    	    unsigned char *pinit = section_ptr_add(init_section, 5);
-            put32(pinit + 1, -4);
+    	    pinit[0] = 0xe8;
-            sym_index = find_elf_sym(symtab_section, "__bound_init");
+            write32le(pinit + 1, -4);
+    	    put_elf_reloc(symtab_section, init_section,
-            put_elf_reloc(symtab_section, init_section,
+                      init_section->data_offset - 4, R_386_PC32, sym_index);
                           init_section->data_offset - 4, R_386_PC32, sym_index);
+	else
+    	    tcc_warning("__bound_init not defined");
+    }
+#endif
+}
+/* add tcc runtime libraries */
 ST_FUNC void tcc_add_runtime(TCCState *s1)
 #endif
     tcc_add_pragma_libs(s1);
-#endif
+    /* add libc */
-    /* add libc */
+    if (!s1->nostdlib) {
+        tcc_add_library(s1, "c");
+#ifdef CONFIG_USE_LIBGCC
+        if (!s1->static_link) {
-    if (!s1->nostdlib) {
+            tcc_add_file(s1, TCC_LIBGCC, TCC_FILETYPE_BINARY);
+        }
-        tcc_add_library(s1, "c");
+#endif
+#if !defined(TCC_TARGET_MEOS)
+        tcc_add_support(s1, "libtcc1.a");
+#endif
+    }
+    /* tcc_add_bcheck tries to relocate a call to __bound_init in _init so
+       libtcc1.a must be loaded before for __bound_init to be defined and
        crtn.o must be loaded after to not finalize _init too early. */
-        snprintf(buf, sizeof(buf), "%s/%s", tcc_lib_path, "libtcc1.a");
+    tcc_add_bcheck(s1);
+    if (!s1->nostdlib) {
+        /* add crt end if not memory output */
+        if (s1->output_type != TCC_OUTPUT_MEMORY)
-        tcc_add_file(s1, buf);
+#if defined(TCC_TARGET_MEOS)
+;
 //            tcc_add_crt(s1, "start.o");
-    /* add crt end if not memory output */
+#else
-    if (s1->output_type != TCC_OUTPUT_MEMORY && !s1->nostdlib) {
+            tcc_add_crt(s1, "crtn.o");
-        tcc_add_file(s1, CONFIG_TCC_CRT_PREFIX "/crtn.o");
+#endif
+    }
 }
 /* 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)
+ST_FUNC 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,
+                ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
                 text_section->sh_num, "_etext");
     add_elf_sym(symtab_section,
                 data_section->data_offset, 0,
-                ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0,
+                ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
                 data_section->sh_num, "_edata");
     add_elf_sym(symtab_section,
                 bss_section->data_offset, 0,
                 p++;
+            }
             snprintf(buf, sizeof(buf), "__start_%s", s->name);
             add_elf_sym(symtab_section,
 , 0,
-                        ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0,
+                        ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
                         s->sh_num, buf);
             snprintf(buf, sizeof(buf), "__stop_%s", s->name);
             add_elf_sym(symtab_section,
                         s->data_offset, 0,
-                        ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0,
+                        ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
                         s->sh_num, buf);
+        }
     next_sec: ;
+    }
+}
-/* 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)
+                              const int *sec_order)
+{
     Section *s;
     int i, offset, size;
     offset = 0;
     for(i=1;inb_sections;i++) {
-        s = s1->sections[section_order[i]];
+        s = s1->sections[sec_order[i]];
         if (s->sh_type != SHT_NOBITS &&
             (s->sh_flags & SHF_ALLOC)) {
             while (offset < s->sh_offset) {
             offset += size;
+        }
+    }
+}
-/* output an ELF file */
-/* XXX: suppress unneeded sections */
-int tcc_output_file(TCCState *s1, const char *filename)
-{
-    Elf32_Ehdr ehdr;
-    FILE *f;
+#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
-    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;
+#define HAVE_PHDR       1
-    int type, file_type;
+#define EXTRA_RELITEMS  14
+/* move the relocation value from .dynsym to .got */
-    unsigned long rel_addr, rel_size;
+void patch_dynsym_undef(TCCState *s1, Section *s)
+{
+    uint32_t *gotd = (void *)s1->got->data;
+    ElfW(Sym) *sym;
-    file_type = s1->output_type;
+    gotd += 3; /* dummy entries in .got */
+    /* relocate symbols in .dynsym */
-    s1->nb_errors = 0;
+    for_each_elem(s, 1, sym, ElfW(Sym)) {
         if (sym->st_shndx == SHN_UNDEF) {
+            *gotd++ = sym->st_value + 6; /* XXX 6 is magic ? */
+            sym->st_value = 0;
+        }
+    }
+}
-    if (file_type != TCC_OUTPUT_OBJ) {
-        tcc_add_runtime(s1);
-    }
-    phdr = NULL;
+#else
-    section_order = NULL;
+#define HAVE_PHDR      1
-    interp = NULL;
+#define EXTRA_RELITEMS 9
-    dynamic = NULL;
-    dynstr = NULL; /* avoid warning */
-    saved_dynamic_data_offset = 0; /* avoid warning */
+/* zero plt offsets of weak symbols in .dynsym */
+void patch_dynsym_undef(TCCState *s1, Section *s)
+{
+    ElfW(Sym) *sym;
+    for_each_elem(s, 1, sym, ElfW(Sym))
+        if (sym->st_shndx == SHN_UNDEF && ELFW(ST_BIND)(sym->st_info) == STB_WEAK)
-    if (file_type != TCC_OUTPUT_OBJ) {
+            sym->st_value = 0;
-        relocate_common_syms();
+}
+#endif
-        tcc_add_linker_symbols(s1);
+ST_FUNC void fill_got_entry(TCCState *s1, ElfW_Rel *rel)
-        if (!s1->static_link) {
+{
-            const char *name;
+    int sym_index = ELFW(R_SYM) (rel->r_info);
+    ElfW(Sym) *sym = &((ElfW(Sym) *) symtab_section->data)[sym_index];
-            int sym_index, index;
+    unsigned long offset;
-            Elf32_Sym *esym, *sym_end;
+    if (sym_index >= s1->nb_sym_attrs)
+        return;
-            if (file_type == TCC_OUTPUT_EXE) {
+    offset = s1->sym_attrs[sym_index].got_offset;
-                char *ptr;
+    section_reserve(s1->got, offset + PTR_SIZE);
-                /* 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));
+#ifdef TCC_TARGET_X86_64
-                strcpy(ptr, elf_interp);
+    /* only works for x86-64 */
-            }
+    write32le(s1->got->data + offset + 4, sym->st_value >> 32);
-            /* add dynamic symbol table */
-            s1->dynsym = new_symtab(s1, ".dynsym", SHT_DYNSYM, SHF_ALLOC,
+#endif
-                                    ".dynstr",
+    write32le(s1->got->data + offset, sym->st_value & 0xffffffff);
+}
+/* Perform relocation to GOT or PLT entries */
-                                    ".hash", SHF_ALLOC);
+ST_FUNC void fill_got(TCCState *s1)
+{
+    Section *s;
+    ElfW_Rel *rel;
+    int i;
-            dynstr = s1->dynsym->link;
+    for(i = 1; i < s1->nb_sections; i++) {
+        s = s1->sections[i];
+        if (s->sh_type != SHT_RELX)
+            continue;
+        /* no need to handle got relocations */
+        if (s->link != symtab_section)
-            /* add dynamic section */
+            continue;
+        for_each_elem(s, 0, rel, ElfW_Rel) {
+            switch (ELFW(R_TYPE) (rel->r_info)) {
+                case R_X86_64_GOT32:
+                case R_X86_64_GOTPCREL:
+		case R_X86_64_GOTPCRELX:
+		case R_X86_64_REX_GOTPCRELX:
+                case R_X86_64_PLT32:
+                    fill_got_entry(s1, rel);
+                    break;
+            }
-            dynamic = new_section(s1, ".dynamic", SHT_DYNAMIC,
+        }
+    }
+}
-                                  SHF_ALLOC | SHF_WRITE);
-            dynamic->link = dynstr;
-            dynamic->sh_entsize = sizeof(Elf32_Dyn);
+/* Bind symbols of executable: resolve undefined symbols from exported symbols
+   in shared libraries and export non local defined symbols to shared libraries
-            /* add PLT */
-            s1->plt = new_section(s1, ".plt", SHT_PROGBITS,
-                                  SHF_ALLOC | SHF_EXECINSTR);
+   if -rdynamic switch was given on command line */
-            s1->plt->sh_entsize = 4;
-            build_got(s1);
 static void bind_exe_dynsyms(TCCState *s1)
-            /* scan for undefined symbols and see if they are in the
+{
-               dynamic symbols. If a symbol STT_FUNC is found, then we
+    const char *name;
-               add it in the PLT. If a symbol STT_OBJECT is found, we
+    int sym_index, index;
-               add it in the .bss section with a suitable relocation */
+    ElfW(Sym) *sym, *esym;
-            sym_end = (Elf32_Sym *)(symtab_section->data +
+    int type;
-                                    symtab_section->data_offset);
+    /* Resolve undefined symbols from dynamic symbols. When there is a match:
+       - if STT_FUNC or STT_GNU_IFUNC symbol -> add it in PLT
+       - if STT_OBJECT symbol -> add it in .bss section with suitable reloc */
+    for_each_elem(symtab_section, 1, sym, ElfW(Sym)) {
+        if (sym->st_shndx == SHN_UNDEF) {
+            name = (char *) symtab_section->link->data + sym->st_name;
+            sym_index = find_elf_sym(s1->dynsymtab_section, name);
-            if (file_type == TCC_OUTPUT_EXE) {
+            if (sym_index) {
-                for(sym = (Elf32_Sym *)symtab_section->data + 1;
+                esym = &((ElfW(Sym) *)s1->dynsymtab_section->data)[sym_index];
-                    sym < sym_end;
+                type = ELFW(ST_TYPE)(esym->st_info);
-                    sym++) {
+                if ((type == STT_FUNC) || (type == STT_GNU_IFUNC)) {
-                    if (sym->st_shndx == SHN_UNDEF) {
+                    /* Indirect functions shall have STT_FUNC type in executable
+                     * dynsym section. Indeed, a dlsym call following a lazy
-                        name = symtab_section->link->data + sym->st_name;
+                     * resolution would pick the symbol value from the
-                        sym_index = find_elf_sym(s1->dynsymtab_section, name);
+                     * executable dynsym entry which would contain the address
-                        if (sym_index) {
+                     * of the function wanted by the caller of dlsym instead of
-                            esym = &((Elf32_Sym *)s1->dynsymtab_section->data)[sym_index];
+                     * the address of the function that would return that
+                     * address */
+                    put_got_entry(s1, R_JMP_SLOT, esym->st_size,
+                                  ELFW(ST_INFO)(STB_GLOBAL,STT_FUNC),
+                                  sym - (ElfW(Sym) *)symtab_section->data);
+                } else if (type == STT_OBJECT) {
+                    unsigned long offset;
+                    ElfW(Sym) *dynsym;
+                    offset = bss_section->data_offset;
+                    /* XXX: which alignment ? */
+                    offset = (offset + 16 - 1) & -16;
-                            type = ELF32_ST_TYPE(esym->st_info);
+                    index = put_elf_sym(s1->dynsym, offset, esym->st_size,
-                            if (type == STT_FUNC) {
+                                        esym->st_info, 0, bss_section->sh_num,
+                                        name);
+                    /* Ensure R_COPY works for weak symbol aliases */
+                    if (ELFW(ST_BIND)(esym->st_info) == STB_WEAK) {
+                        for_each_elem(s1->dynsymtab_section, 1, dynsym, ElfW(Sym)) {
-                                put_got_entry(s1, R_JMP_SLOT, esym->st_size,
+                            if ((dynsym->st_value == esym->st_value)
-                                              esym->st_info,
+                                && (ELFW(ST_BIND)(dynsym->st_info) == STB_GLOBAL)) {
-                                              sym - (Elf32_Sym *)symtab_section->data);
+                                char *dynname = (char *) s1->dynsymtab_section->link->data
-                            } else if (type == STT_OBJECT) {
+                                                + dynsym->st_name;
-                                unsigned long offset;
+                                put_elf_sym(s1->dynsym, offset, dynsym->st_size,
-                                offset = bss_section->data_offset;
+                                            dynsym->st_info, 0,
-                                /* XXX: which alignment ? */
+                                            bss_section->sh_num, dynname);
-                                offset = (offset + 16 - 1) & -16;
+                                break;
-                                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);
+                    put_elf_reloc(s1->dynsym, bss_section,
-                                offset += esym->st_size;
+                                  offset, R_COPY, index);
-                                bss_section->data_offset = offset;
+                    offset += esym->st_size;
-                            }
-                        } else {
+                    bss_section->data_offset = offset;
-                                /* STB_WEAK undefined symbols are accepted */
+                }
-                                /* XXX: _fp_hw seems to be part of the ABI, so we ignore
-                                   it */
+            } else {
-                            if (ELF32_ST_BIND(sym->st_info) == STB_WEAK ||
+                /* STB_WEAK undefined symbols are accepted */
-                                !strcmp(name, "_fp_hw")) {
-                            } else {
+                /* XXX: _fp_hw seems to be part of the ABI, so we ignore it */
+                if (ELFW(ST_BIND)(sym->st_info) == STB_WEAK ||
-                                error_noabort("undefined symbol '%s'", name);
+                    !strcmp(name, "_fp_hw")) {
                 } else {
+                    tcc_error_noabort("undefined symbol '%s'", name);
+                }
+            }
+        } else if (s1->rdynamic && ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
-                        }
+            /* if -rdynamic option, then export all non local symbols */
+            name = (char *) symtab_section->link->data + sym->st_name;
-                    } else if (s1->rdynamic &&
+            put_elf_sym(s1->dynsym, sym->st_value, sym->st_size, sym->st_info,
-                               ELF32_ST_BIND(sym->st_info) != STB_LOCAL) {
+, sym->st_shndx, name);
                         /* 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)
+/* Bind symbols of libraries: export non local symbols of executable that
-                    goto fail;
+   resolve undefined symbols of shared libraries */
+static void bind_libs_dynsyms(TCCState *s1)
-                /* now look at unresolved dynamic symbols and export
+{
+    const char *name;
-                   corresponding symbol */
+    int sym_index;
-                sym_end = (Elf32_Sym *)(s1->dynsymtab_section->data +
-                                        s1->dynsymtab_section->data_offset);
+    ElfW(Sym) *sym, *esym;
-                for(esym = (Elf32_Sym *)s1->dynsymtab_section->data + 1;
-                    esym < sym_end;
-                    esym++) {
+    /* now look at unresolved dynamic symbols and export
-                    if (esym->st_shndx == SHN_UNDEF) {
+       corresponding symbol */
-                        name = s1->dynsymtab_section->link->data + esym->st_name;
+    for_each_elem(s1->dynsymtab_section, 1, esym, ElfW(Sym)) {
-                        sym_index = find_elf_sym(symtab_section, name);
+        name = (char *) s1->dynsymtab_section->link->data + esym->st_name;
-                        if (sym_index) {
+        sym_index = find_elf_sym(symtab_section, name);
-                            /* XXX: avoid adding a symbol if already
+        if (sym_index) {
+            /* XXX: avoid adding a symbol if already present because of
+               -rdynamic ? */
+            sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
+            if (sym->st_shndx != SHN_UNDEF)
-                               present because of -rdynamic ? */
+                put_elf_sym(s1->dynsym, sym->st_value, sym->st_size,
-                            sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
+                            sym->st_info, 0, sym->st_shndx, name);
-                            put_elf_sym(s1->dynsym, sym->st_value, sym->st_size,
+        } else if (esym->st_shndx == SHN_UNDEF) {
-                                        sym->st_info, 0,
+            /* weak symbols can stay undefined */
-                                        sym->st_shndx, name);
+            if (ELFW(ST_BIND)(esym->st_info) != STB_WEAK)
-                        } else {
+                tcc_warning("undefined dynamic symbol '%s'", name);
-                            if (ELF32_ST_BIND(esym->st_info) == STB_WEAK) {
+        }
-                                /* weak symbols can stay undefined */
-                            } else {
-                                warning("undefined dynamic symbol '%s'", name);
+    }
-                            }
+}
-                        }
-                    }
-                }
+/* Export all non local symbols (for shared libraries) */
-            } else {
-                int nb_syms;
+static void export_global_syms(TCCState *s1)
-                /* shared library case : we simply export all the global symbols */
+{
-                nb_syms = symtab_section->data_offset / sizeof(Elf32_Sym);
+    int nb_syms, dynindex, index;
-                s1->symtab_to_dynsym = tcc_mallocz(sizeof(int) * nb_syms);
+    const char *name;
-                for(sym = (Elf32_Sym *)symtab_section->data + 1;
+    ElfW(Sym) *sym;
+    nb_syms = symtab_section->data_offset / sizeof(ElfW(Sym));
-                    sym < sym_end;
+    s1->symtab_to_dynsym = tcc_mallocz(sizeof(int) * nb_syms);
+    for_each_elem(symtab_section, 1, sym, ElfW(Sym)) {
+        if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
-                    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,
+	    name = (char *) symtab_section->link->data + sym->st_name;
-                                            sym->st_info, 0,
-                                            sym->st_shndx, name);
+	    dynindex = put_elf_sym(s1->dynsym, sym->st_value, sym->st_size,
-                        s1->symtab_to_dynsym[sym -
-                                            (Elf32_Sym *)symtab_section->data] =
-                            index;
-                    }
+				   sym->st_info, 0, sym->st_shndx, name);
+	    index = sym - (ElfW(Sym) *) symtab_section->data;
+	    s1->symtab_to_dynsym[index] = dynindex;
+        }
+    }
+}
+/* relocate the PLT: compute addresses and offsets in the PLT now that final
-                }
+   address for PLT and GOT are known (see fill_program_header) */
+ST_FUNC void relocate_plt(TCCState *s1)
+{
+    uint8_t *p, *p_end;
-            }
+    if (!s1->plt)
+      return;
+    p = s1->plt->data;
+    p_end = p + s1->plt->data_offset;
+    if (p < p_end) {
+#if defined(TCC_TARGET_I386)
+        write32le(p + 2, read32le(p + 2) + s1->got->sh_addr);
+        write32le(p + 8, read32le(p + 8) + s1->got->sh_addr);
+        p += 16;
-            build_got_entries(s1);
+        while (p < p_end) {
+            write32le(p + 2, read32le(p + 2) + s1->got->sh_addr);
+            p += 16;
+        }
+#elif defined(TCC_TARGET_X86_64)
+        int x = s1->got->sh_addr - s1->plt->sh_addr - 6;
+        write32le(p + 2, read32le(p + 2) + x);
+        write32le(p + 8, read32le(p + 8) + x - 6);
+        p += 16;
+        while (p < p_end) {
+            write32le(p + 2, read32le(p + 2) + x + s1->plt->data - p);
+            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) {
+            if (read32le(p) == 0x46c04778) /* PLT Thumb stub present */
+                p += 4;
+            write32le(p + 12, x + read32le(p + 12) + s1->plt->data - p);
+            p += 16;
+        }
+#elif defined(TCC_TARGET_ARM64)
+        uint64_t plt = s1->plt->sh_addr;
+        uint64_t got = s1->got->sh_addr;
+        uint64_t off = (got >> 12) - (plt >> 12);
-            /* add a list of needed dlls */
+        if ((off + ((uint32_t)1 << 20)) >> 21)
+            tcc_error("Failed relocating PLT (off=0x%lx, got=0x%lx, plt=0x%lx)", off, got, plt);
+        write32le(p, 0xa9bf7bf0); // stp x16,x30,[sp,#-16]!
+        write32le(p + 4, (0x90000010 | // adrp x16,...
+			  (off & 0x1ffffc) << 3 | (off & 3) << 29));
+        write32le(p + 8, (0xf9400211 | // ldr x17,[x16,#...]
+			  (got & 0xff8) << 7));
+        write32le(p + 12, (0x91000210 | // add x16,x16,#...
+			   (got & 0xfff) << 10));
+        write32le(p + 16, 0xd61f0220); // br x17
+        write32le(p + 20, 0xd503201f); // nop
+        write32le(p + 24, 0xd503201f); // nop
+        write32le(p + 28, 0xd503201f); // nop
+        p += 32;
+        while (p < p_end) {
+            uint64_t pc = plt + (p - s1->plt->data);
+            uint64_t addr = got + read64le(p);
+            uint64_t off = (addr >> 12) - (pc >> 12);
-            for(i = 0; i < s1->nb_loaded_dlls; i++) {
+            if ((off + ((uint32_t)1 << 20)) >> 21)
-                DLLReference *dllref = s1->loaded_dlls[i];
+                tcc_error("Failed relocating PLT (off=0x%lx, addr=0x%lx, pc=0x%lx)", off, addr, pc);
-                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;
+            write32le(p, (0x90000010 | // adrp x16,...
-            dynamic->data_offset += 8 * 9;
-        } else {
-            /* still need to build got entries in case of static link */
+			  (off & 0x1ffffc) << 3 | (off & 3) << 29));
-            build_got_entries(s1);
+            write32le(p + 4, (0xf9400211 | // ldr x17,[x16,#...]
-        }
-    }
-    memset(&ehdr, 0, sizeof(ehdr));
-    /* we add a section for symbols */
-    strsec = new_section(s1, ".shstrtab", SHT_STRTAB, 0);
+			      (addr & 0xff8) << 7));
-    put_elf_str(strsec, "");
+            write32le(p + 8, (0x91000210 | // add x16,x16,#...
-    /* compute number of sections */
-    shnum = s1->nb_sections;
+			      (addr & 0xfff) << 10));
-    /* this array is used to reorder sections in the output file */
+            write32le(p + 12, 0xd61f0220); // br x17
-    section_order = tcc_malloc(sizeof(int) * shnum);
-    section_order[0] = 0;
-    sh_order_index = 1;
+            p += 16;
-    /* compute number of program headers */
-    switch(file_type) {
     default:
-    case TCC_OUTPUT_OBJ:
+#elif defined(TCC_TARGET_C67)
-        phnum = 0;
+        /* XXX: TODO */
-        break;
+#else
-    case TCC_OUTPUT_EXE:
+#error unsupported CPU
-        if (!s1->static_link)
+#endif
-            phnum = 4;
+    }
         else
+/* Allocate strings for section names and decide if an unallocated section
-            phnum = 2;
+   should be output.
+   NOTE: the strsec section comes last, so its size is also correct ! */
-        break;
+static void alloc_sec_names(TCCState *s1, int file_type, Section *strsec)
     case TCC_OUTPUT_DLL:
+    int i;
-        phnum = 3;
+    Section *s;
         break;
     /* Allocate strings for section names */
     for(i = 1; i < s1->nb_sections; i++) {
-    /* allocate strings for section names and decide if an unallocated
+        s = s1->sections[i];
-       section should be output */
+        s->sh_name = put_elf_str(strsec, s->name);
+        /* when generating a DLL, we include relocations but we may
-    /* NOTE: the strsec section comes last, so its size is also
+           patch them */
+        if (file_type == TCC_OUTPUT_DLL &&
+            s->sh_type == SHT_RELX &&
+            !(s->sh_flags & SHF_ALLOC)) {
+            /* gr: avoid bogus relocs for empty (debug) sections */
+            if (s1->sections[s->sh_info]->sh_flags & SHF_ALLOC)
+                prepare_dynamic_rel(s1, s);
-       correct ! */
+            else if (s1->do_debug)
+                s->sh_size = s->data_offset;
+        } else if (s1->do_debug ||
+            file_type == TCC_OUTPUT_OBJ ||
+            file_type == TCC_OUTPUT_EXE ||
+            (s->sh_flags & SHF_ALLOC) ||
+            i == (s1->nb_sections - 1)) {
+            /* we output all sections if debug or object file */
-    for(i = 1; i < s1->nb_sections; i++) {
+            s->sh_size = s->data_offset;
-        s = s1->sections[i];
+        }
+    }
+}
+/* Info to be copied in dynamic section */
+struct dyn_inf {
+    Section *dynamic;
-        s->sh_name = put_elf_str(strsec, s->name);
+    Section *dynstr;
+    unsigned long dyn_rel_off;
+    addr_t rel_addr;
+    addr_t rel_size;
-        /* when generating a DLL, we include relocations but we may
+#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+    addr_t bss_addr;
+    addr_t bss_size;
+#endif
+};
-           patch them */
+/* Assign sections to segments and decide how are sections laid out when loaded
-        if (file_type == TCC_OUTPUT_DLL &&
+   in memory. This function also fills corresponding program headers. */
-            s->sh_type == SHT_REL &&
-            !(s->sh_flags & SHF_ALLOC)) {
+static int layout_sections(TCCState *s1, ElfW(Phdr) *phdr, int phnum,
-            prepare_dynamic_rel(s1, s);
+                           Section *interp, Section* strsec,
-        } else if (do_debug ||
+                           struct dyn_inf *dyninf, int *sec_order)
             file_type == TCC_OUTPUT_OBJ ||
-            (s->sh_flags & SHF_ALLOC) ||
+    int i, j, k, file_type, sh_order_index, file_offset;
-            i == (s1->nb_sections - 1)) {
+    unsigned long s_align;
-            /* we output all sections if debug or object file */
+    long long tmp;
-            s->sh_size = s->data_offset;
+    addr_t addr;
-        }
+    ElfW(Phdr) *ph;
     Section *s;
-    /* allocate program segment headers */
+    file_type = s1->output_type;
-    phdr = tcc_mallocz(phnum * sizeof(Elf32_Phdr));
+    sh_order_index = 1;
     file_offset = 0;
-    if (s1->output_format == TCC_OUTPUT_FORMAT_ELF) {
+    if (s1->output_format == TCC_OUTPUT_FORMAT_ELF)
-        file_offset = sizeof(Elf32_Ehdr) + phnum * sizeof(Elf32_Phdr);
+        file_offset = sizeof(ElfW(Ehdr)) + phnum * sizeof(ElfW(Phdr));
-    } else {
+    s_align = ELF_PAGE_SIZE;
-        file_offset = 0;
+    if (s1->section_align)
-    }
-    if (phnum > 0) {
-        /* compute section to program header mapping */
-        if (s1->has_text_addr) {
-            int a_offset, p_offset;
-            addr = s1->text_addr;
+        s_align = s1->section_align;
+    if (phnum > 0) {
+        if (s1->has_text_addr) {
-            /* we ensure that (addr % ELF_PAGE_SIZE) == file_offset %
+            int a_offset, p_offset;
-               ELF_PAGE_SIZE */
+            addr = s1->text_addr;
+            /* we ensure that (addr % ELF_PAGE_SIZE) == file_offset %
+               ELF_PAGE_SIZE */
+            a_offset = (int) (addr & (s_align - 1));
+            p_offset = file_offset & (s_align - 1);
+            if (a_offset < p_offset)
+                a_offset += s_align;
-            a_offset = addr & (ELF_PAGE_SIZE - 1);
+            file_offset += (a_offset - p_offset);
-            p_offset = file_offset & (ELF_PAGE_SIZE - 1);
+        } else {
-            if (a_offset < p_offset)
+            if (file_type == TCC_OUTPUT_DLL)
-                a_offset += ELF_PAGE_SIZE;
+                addr = 0;
-            file_offset += (a_offset - p_offset);
+            else
-        } else {
+                addr = ELF_START_ADDR;
-            if (file_type == TCC_OUTPUT_DLL)
+            /* compute address after headers */
+            addr += (file_offset & (s_align - 1));
+        }
-                addr = 0;
-            else
+        ph = &phdr[0];
-                addr = ELF_START_ADDR;
+        /* Leave one program headers for the program interpreter and one for
-            /* compute address after headers */
+           the program header table itself if needed. These are done later as
-            addr += (file_offset & (ELF_PAGE_SIZE - 1));
+           they require section layout to be done first. */
         if (interp)
             ph += 1 + HAVE_PHDR;
                     } 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) {
+                    } else if (s->sh_type == SHT_RELX) {
                         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;
+                    sec_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;
+                    file_offset += (int) ( 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_RELX) {
+#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+                        if (!strcmp(strsec->data + s->sh_name, ".rel.got")) {
+                            dyninf->rel_addr = addr;
+                            dyninf->rel_size += s->sh_size; /* XXX only first rel. */
+                        }
+                        if (!strcmp(strsec->data + s->sh_name, ".rel.bss")) {
+                            dyninf->bss_addr = addr;
+                            dyninf->bss_size = s->sh_size; /* XXX only first rel. */
-                    /* update dynamic relocation infos */
+                        }
-                    if (s->sh_type == SHT_REL) {
+#else
-                        if (rel_size == 0)
+                        if (dyninf->rel_size == 0)
+                            dyninf->rel_addr = addr;
-                            rel_addr = addr;
+                        dyninf->rel_size += s->sh_size;
-                        rel_size += s->sh_size;
+#endif
+                    }
                     addr += s->sh_size;
                     if (s->sh_type != SHT_NOBITS)
                         file_offset += s->sh_size;
+                }
+            }
+	    if (j == 0) {
+		/* Make the first PT_LOAD segment include the program
+		   headers itself (and the ELF header as well), it'll
+		   come out with same memory use but will make various
+		   tools like binutils strip work better.  */
+		ph->p_offset &= ~(ph->p_align - 1);
+		ph->p_vaddr &= ~(ph->p_align - 1);
 		ph->p_paddr &= ~(ph->p_align - 1);
+	    }
             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)
+                    if ((addr & (s_align - 1)) != 0)
-                        addr += ELF_PAGE_SIZE;
+                        addr += s_align;
                 } else {
-                    addr = (addr + ELF_PAGE_SIZE - 1) & ~(ELF_PAGE_SIZE - 1);
+                    addr = (addr + s_align - 1) & ~(s_align - 1);
-                    file_offset = (file_offset + ELF_PAGE_SIZE - 1) &
+                    file_offset = (file_offset + s_align - 1) & ~(s_align - 1);
                         ~(ELF_PAGE_SIZE - 1);
+            }
+        }
+    }
+    /* 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;
+        sec_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;
+    }
+    return file_offset;
+}
+static void fill_unloadable_phdr(ElfW(Phdr) *phdr, int phnum, Section *interp,
+                                 Section *dynamic)
-            }
+{
     ElfW(Phdr) *ph;
+    /* if interpreter, then add corresponding program header */
+    if (interp) {
+        ph = &phdr[0];
+        if (HAVE_PHDR)
+        {
+            int len = phnum * sizeof(ElfW(Phdr));
+            ph->p_type = PT_PHDR;
+            ph->p_offset = sizeof(ElfW(Ehdr));
+            ph->p_vaddr = interp->sh_addr - len;
+            ph->p_paddr = ph->p_vaddr;
+            ph->p_filesz = ph->p_memsz = len;
+            ph->p_flags = PF_R | PF_X;
-        /* if interpreter, then add corresponing program header */
+            ph->p_align = 4; /* interp->sh_addralign; */
-        if (interp) {
+            ph++;
             ph = &phdr[0];
-            ph->p_type = PT_INTERP;
+        ph->p_type = PT_INTERP;
-            ph->p_offset = interp->sh_offset;
+        ph->p_offset = interp->sh_offset;
-            ph->p_vaddr = interp->sh_addr;
+        ph->p_vaddr = interp->sh_addr;
-            ph->p_paddr = ph->p_vaddr;
+        ph->p_paddr = ph->p_vaddr;
-            ph->p_filesz = interp->sh_size;
+        ph->p_filesz = interp->sh_size;
-            ph->p_memsz = interp->sh_size;
+        ph->p_memsz = interp->sh_size;
-            ph->p_flags = PF_R;
+        ph->p_flags = PF_R;
-            ph->p_align = interp->sh_addralign;
-        }
         ph->p_align = interp->sh_addralign;
         /* if dynamic section, then add corresponing program header */
         if (dynamic) {
-            Elf32_Sym *sym_end;
+    /* if dynamic section, then add corresponding program header */
     if (dynamic) {
-            ph = &phdr[phnum - 1];
+        ph = &phdr[phnum - 1];
-            ph->p_type = PT_DYNAMIC;
+        ph->p_type = PT_DYNAMIC;
-            ph->p_offset = dynamic->sh_offset;
+        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;
         ph->p_vaddr = dynamic->sh_addr;
-#elif defined(TCC_TARGET_C67)
+        ph->p_paddr = ph->p_vaddr;
-                    /* XXX: TODO */
-#else
+        ph->p_filesz = dynamic->sh_size;
-#error unsupported CPU
-#endif
-                }
+        ph->p_memsz = dynamic->sh_size;
-            }
+        ph->p_flags = PF_R | PF_W;
-            /* 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) {
+        ph->p_align = dynamic->sh_addralign;
-                    /* relocate to the PLT if the symbol corresponds
+    }
+}
-                       to a PLT entry */
-                    if (sym->st_value)
+/* Fill the dynamic section with tags describing the address and size of
-                        sym->st_value += s1->plt->sh_addr;
+   sections */
-                } else if (sym->st_shndx < SHN_LORESERVE) {
+static void fill_dynamic(TCCState *s1, struct dyn_inf *dyninf)
-                    /* do symbol relocation */
+{
-                    sym->st_value += s1->sections[sym->st_shndx]->sh_addr;
+    Section *dynamic;
-                }
-            }
+    dynamic = dyninf->dynamic;
+    /* put dynamic section entries */
+    dynamic->data_offset = dyninf->dyn_rel_off;
+    put_dt(dynamic, DT_HASH, s1->dynsym->hash->sh_addr);
+    put_dt(dynamic, DT_STRTAB, dyninf->dynstr->sh_addr);
+    put_dt(dynamic, DT_SYMTAB, s1->dynsym->sh_addr);
+    put_dt(dynamic, DT_STRSZ, dyninf->dynstr->data_offset);
+    put_dt(dynamic, DT_SYMENT, sizeof(ElfW(Sym)));
+#if defined(TCC_TARGET_ARM64) || defined(TCC_TARGET_X86_64)
+    put_dt(dynamic, DT_RELA, dyninf->rel_addr);
+    put_dt(dynamic, DT_RELASZ, dyninf->rel_size);
+    put_dt(dynamic, DT_RELAENT, sizeof(ElfW_Rel));
+#else
+#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
-            /* put dynamic section entries */
+    put_dt(dynamic, DT_PLTGOT, s1->got->sh_addr);
-            dynamic->data_offset = saved_dynamic_data_offset;
+    put_dt(dynamic, DT_PLTRELSZ, dyninf->rel_size);
+    put_dt(dynamic, DT_JMPREL, dyninf->rel_addr);
+    put_dt(dynamic, DT_PLTREL, DT_REL);
+    put_dt(dynamic, DT_REL, dyninf->bss_addr);
+    put_dt(dynamic, DT_RELSZ, dyninf->bss_size);
-            put_dt(dynamic, DT_HASH, s1->dynsym->hash->sh_addr);
+#else
-            put_dt(dynamic, DT_STRTAB, dynstr->sh_addr);
+    put_dt(dynamic, DT_REL, dyninf->rel_addr);
-            put_dt(dynamic, DT_SYMTAB, s1->dynsym->sh_addr);
+    put_dt(dynamic, DT_RELSZ, dyninf->rel_size);
-            put_dt(dynamic, DT_STRSZ, dynstr->data_offset);
+    put_dt(dynamic, DT_RELENT, sizeof(ElfW_Rel));
-            put_dt(dynamic, DT_SYMENT, sizeof(Elf32_Sym));
+#endif
-            put_dt(dynamic, DT_REL, rel_addr);
-            put_dt(dynamic, DT_RELSZ, rel_size);
+#endif
-            put_dt(dynamic, DT_RELENT, sizeof(Elf32_Rel));
-            put_dt(dynamic, DT_NULL, 0);
-        }
+    if (s1->do_debug)
-        ehdr.e_phentsize = sizeof(Elf32_Phdr);
+        put_dt(dynamic, DT_DEBUG, 0);
-        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) &
+    put_dt(dynamic, DT_NULL, 0);
-            ~(s->sh_addralign - 1);
+}
-        s->sh_offset = file_offset;
-        if (s->sh_type != SHT_NOBITS)
-            file_offset += s->sh_size;
-    }
 /* Relocate remaining sections and symbols (that is those not related to
-    /* if building executable or DLL, then relocate each section
+   dynamic linking) */
-       except the GOT which is already relocated */
+static int final_sections_reloc(TCCState *s1)
     if (file_type != TCC_OUTPUT_OBJ) {
+    int i;
+    Section *s;
+    relocate_syms(s1, 0);
-        relocate_syms(s1, 0);
+    if (s1->nb_errors != 0)
+        return -1;
     /* relocate sections */
-        if (s1->nb_errors != 0) {
+    /* XXX: ignore sections with allocated relocations ? */
-        fail:
+    for(i = 1; i < s1->nb_sections; i++) {
-            ret = -1;
+        s = s1->sections[i];
-            goto the_end;
+#ifdef TCC_TARGET_I386
         if (s->reloc && s != s1->got && (s->sh_flags & SHF_ALLOC)) //gr
         /* On X86 gdb 7.3 works in any case but gdb 6.6 will crash if SHF_ALLOC
-        /* relocate sections */
+        checking is removed */
-        /* XXX: ignore sections with allocated relocations ? */
+#else
-        for(i = 1; i < s1->nb_sections; i++) {
+        if (s->reloc && s != s1->got)
-            s = s1->sections[i];
+        /* On X86_64 gdb 7.3 will crash if SHF_ALLOC checking is present */
-            if (s->reloc && s != s1->got)
-                relocate_section(s1, s);
-        }
-        /* relocate relocation entries if the relocation tables are
+#endif
-           allocated in the executable */
-        for(i = 1; i < s1->nb_sections; i++) {
+            relocate_section(s1, s);
-            s = s1->sections[i];
+    }
-            if ((s->sh_flags & SHF_ALLOC) &&
-                s->sh_type == SHT_REL) {
-                relocate_rel(s1, s);
-            }
+    /* relocate relocation entries if the relocation tables are
-        }
+       allocated in the executable */
+    for(i = 1; i < s1->nb_sections; i++) {
-        /* get entry point address */
+        s = s1->sections[i];
-        if (file_type == TCC_OUTPUT_EXE)
+        if ((s->sh_flags & SHF_ALLOC) &&
-            ehdr.e_entry = (unsigned long)tcc_get_symbol_err(s1, "_start");
+            s->sh_type == SHT_RELX) {
-        else
+            relocate_rel(s1, s);
-            ehdr.e_entry = text_section->sh_addr; /* XXX: is it correct ? */
+        }
     }
+    return 0;
+}
-    /* write elf file */
+/* Create an ELF file on disk.
-    if (file_type == TCC_OUTPUT_OBJ)
-        mode = 0666;
+   This function handle ELF specific layout requirements */
+static void tcc_output_elf(TCCState *s1, FILE *f, int phnum, ElfW(Phdr) *phdr,
-    else
+                           int file_offset, int *sec_order)
+{
-        mode = 0777;
+    int i, shnum, offset, size, file_type;
-    fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, mode);
+    Section *s;
-    if (fd < 0) {
+    ElfW(Ehdr) ehdr;
-        error_noabort("could not write '%s'", filename);
+    ElfW(Shdr) shdr, *sh;
         goto fail;
     file_type = s1->output_type;
-    f = fdopen(fd, "wb");
+    shnum = s1->nb_sections;
-#ifdef TCC_TARGET_COFF
+    memset(&ehdr, 0, sizeof(ehdr));
     if (s1->output_format == TCC_OUTPUT_FORMAT_COFF) {
-        tcc_output_coff(s1, f);
+    if (phnum > 0) {
-    } else
+        ehdr.e_phentsize = sizeof(ElfW(Phdr));
-#endif
+        ehdr.e_phnum = phnum;
-    if (s1->output_format == TCC_OUTPUT_FORMAT_ELF) {
+        ehdr.e_phoff = sizeof(ElfW(Ehdr));
+    }
+    /* 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;
-        sort_syms(s1, symtab_section);
+    ehdr.e_ident[4] = ELFCLASSW;
     ehdr.e_ident[5] = ELFDATA2LSB;
+    ehdr.e_ident[6] = EV_CURRENT;
-        /* align to 4 */
+#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
-        file_offset = (file_offset + 3) & -4;
+    ehdr.e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
 #endif
-        /* fill header */
+#ifdef TCC_TARGET_ARM
+#ifdef TCC_ARM_EABI
-        ehdr.e_ident[0] = ELFMAG0;
+    ehdr.e_ident[EI_OSABI] = 0;
-        ehdr.e_ident[1] = ELFMAG1;
+    ehdr.e_flags = EF_ARM_EABI_VER4;
-        ehdr.e_ident[2] = ELFMAG2;
+    if (file_type == TCC_OUTPUT_EXE || file_type == TCC_OUTPUT_DLL)
+        ehdr.e_flags |= EF_ARM_HASENTRY;
-        ehdr.e_ident[3] = ELFMAG3;
+    if (s1->float_abi == ARM_HARD_FLOAT)
-        ehdr.e_ident[4] = ELFCLASS32;
+        ehdr.e_flags |= EF_ARM_VFP_FLOAT;
-        ehdr.e_ident[5] = ELFDATA2LSB;
+    else
-        ehdr.e_ident[6] = EV_CURRENT;
+        ehdr.e_flags |= EF_ARM_SOFT_FLOAT;
-#ifdef __FreeBSD__
+#else
-        ehdr.e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
+    ehdr.e_ident[EI_OSABI] = ELFOSABI_ARM;
 #endif
-#ifdef TCC_TARGET_ARM
+#endif
-        ehdr.e_ident[EI_OSABI] = ELFOSABI_ARM;
+    switch(file_type) {
-#endif
+    default:
-        switch(file_type) {
+    case TCC_OUTPUT_EXE:
-        default:
+        ehdr.e_type = ET_EXEC;
-        case TCC_OUTPUT_EXE:
+        ehdr.e_entry = get_elf_sym_addr(s1, "_start", 1);
-            ehdr.e_type = ET_EXEC;
+        break;
-            break;
+    case TCC_OUTPUT_DLL:
+        ehdr.e_type = ET_DYN;
-        case TCC_OUTPUT_DLL:
+        ehdr.e_entry = text_section->sh_addr; /* XXX: is it correct ? */
-            ehdr.e_type = ET_DYN;
+        break;
-            break;
+    case TCC_OUTPUT_OBJ:
+        ehdr.e_type = ET_REL;
+        break;
         case TCC_OUTPUT_OBJ:
-            ehdr.e_type = ET_REL;
+    ehdr.e_machine = EM_TCC_TARGET;
-            break;
+    ehdr.e_version = EV_CURRENT;
     ehdr.e_shoff = file_offset;
-        ehdr.e_machine = EM_TCC_TARGET;
+    ehdr.e_ehsize = sizeof(ElfW(Ehdr));
+    ehdr.e_shentsize = sizeof(ElfW(Shdr));
-        ehdr.e_version = EV_CURRENT;
+    ehdr.e_shnum = shnum;
-        ehdr.e_shoff = file_offset;
+    ehdr.e_shstrndx = shnum - 1;
         ehdr.e_ehsize = sizeof(Elf32_Ehdr);
-        ehdr.e_shentsize = sizeof(Elf32_Shdr);
+    fwrite(&ehdr, 1, sizeof(ElfW(Ehdr)), f);
-            offset++;
+        offset++;
+    }
-        for(i=0;inb_sections;i++) {
+    for(i = 0; i < s1->nb_sections; i++) {
-            sh = &shdr;
+        sh = &shdr;
-            memset(sh, 0, sizeof(Elf32_Shdr));
+        memset(sh, 0, sizeof(ElfW(Shdr)));
-            s = s1->sections[i];
+        s = s1->sections[i];
-            if (s) {
+        if (s) {
-                sh->sh_name = s->sh_name;
+            sh->sh_name = s->sh_name;
-                sh->sh_type = s->sh_type;
+            sh->sh_type = s->sh_type;
-                sh->sh_addralign = s->sh_addralign;
+            sh->sh_addralign = s->sh_addralign;
-                sh->sh_addr = s->sh_addr;
+            sh->sh_addr = s->sh_addr;
-                sh->sh_offset = s->sh_offset;
+            sh->sh_offset = s->sh_offset;
-                sh->sh_size = s->sh_size;
+            sh->sh_size = s->sh_size;
+        }
-            fwrite(sh, 1, sizeof(Elf32_Shdr), f);
+        fwrite(sh, 1, sizeof(ElfW(Shdr)), f);
+    }
-    } else {
-        tcc_output_binary(s1, f, section_order);
+}
+/* Write an elf, coff or "binary" file */
+static int tcc_write_elf_file(TCCState *s1, const char *filename, int phnum,
+                              ElfW(Phdr) *phdr, int file_offset, int *sec_order)
+{
+    int fd, mode, file_type;
+    FILE *f;
+    file_type = s1->output_type;
+    if (file_type == TCC_OUTPUT_OBJ)
+        mode = 0666;
+    else
+        mode = 0777;
+    unlink(filename);
+    fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, mode);
+    if (fd < 0) {
+        tcc_error_noabort("could not write '%s'", filename);
+        return -1;
+    }
+    f = fdopen(fd, "wb");
+    if (s1->verbose)
+        printf("<- %s\n", filename);
+#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)
+        tcc_output_elf(s1, f, phnum, phdr, file_offset, sec_order);
+    else
+        tcc_output_binary(s1, f, sec_order);
     fclose(f);
+    return 0;
+}
+/* Output an elf, coff or binary file */
+/* XXX: suppress unneeded sections */
+static int elf_output_file(TCCState *s1, const char *filename)
+{
+    int i, ret, phnum, shnum, file_type, file_offset, *sec_order;
+    struct dyn_inf dyninf;
+    ElfW(Phdr) *phdr;
+    ElfW(Sym) *sym;
+    Section *strsec, *interp, *dynamic, *dynstr;
+    file_type = s1->output_type;
+    s1->nb_errors = 0;
+    /* if linking, also link in runtime libraries (libc, libgcc, etc.) */
+    if (file_type != TCC_OUTPUT_OBJ) {
+        tcc_add_runtime(s1);
+    }
+    phdr = NULL;
+    sec_order = NULL;
+    interp = dynamic = dynstr = NULL; /* avoid warning */
+    dyninf.dyn_rel_off = 0; /* avoid warning */
+    if (file_type != TCC_OUTPUT_OBJ) {
+        relocate_common_syms();
+        tcc_add_linker_symbols(s1);
+        if (!s1->static_link) {
+            if (file_type == TCC_OUTPUT_EXE) {
+                char *ptr;
+                /* allow override the dynamic loader */
+                const char *elfint = getenv("LD_SO");
+                if (elfint == NULL)
+                    elfint = DEFAULT_ELFINTERP(s1);
+                /* add interpreter section only if executable */
+                interp = new_section(s1, ".interp", SHT_PROGBITS, SHF_ALLOC);
+                interp->sh_addralign = 1;
+                ptr = section_ptr_add(interp, 1 + strlen(elfint));
+                strcpy(ptr, elfint);
+            }
+            /* 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(ElfW(Dyn));
+            build_got(s1);
+            if (file_type == TCC_OUTPUT_EXE) {
+                bind_exe_dynsyms(s1);
+                if (s1->nb_errors) {
+                    ret = -1;
+                    goto the_end;
+                }
+                bind_libs_dynsyms(s1);
+            } else /* shared library case: simply export all global symbols */
+                export_global_syms(s1);
+            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));
+            }
+            if (s1->rpath)
+                put_dt(dynamic, DT_RPATH, put_elf_str(dynstr, s1->rpath));
+            /* XXX: currently, since we do not handle PIC code, we
+               must relocate the readonly segments */
+            if (file_type == TCC_OUTPUT_DLL) {
+                if (s1->soname)
+                    put_dt(dynamic, DT_SONAME, put_elf_str(dynstr, s1->soname));
+                put_dt(dynamic, DT_TEXTREL, 0);
+            }
+            if (s1->symbolic)
+                put_dt(dynamic, DT_SYMBOLIC, 0);
+            /* add necessary space for other entries */
+            dyninf.dyn_rel_off = dynamic->data_offset;
+            dynamic->data_offset += sizeof(ElfW(Dyn)) * EXTRA_RELITEMS;
+        } else {
+            /* still need to build got entries in case of static link */
+            build_got_entries(s1);
+        }
+    }
+    /* 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 */
+    sec_order = tcc_malloc(sizeof(int) * shnum);
+    sec_order[0] = 0;
+    /* 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 + HAVE_PHDR;
+        else
+            phnum = 2;
+        break;
+    case TCC_OUTPUT_DLL:
+        phnum = 3;
+        break;
+    }
+    /* Allocate strings for section names */
+    alloc_sec_names(s1, file_type, strsec);
+    /* allocate program segment headers */
+    phdr = tcc_mallocz(phnum * sizeof(ElfW(Phdr)));
+    /* compute section to program header mapping */
+    file_offset = layout_sections(s1, phdr, phnum, interp, strsec, &dyninf,
+                                  sec_order);
+    /* Fill remaining program header and finalize relocation related to dynamic
+       linking. */
+    if (phnum > 0) {
+        fill_unloadable_phdr(phdr, phnum, interp, dynamic);
+        if (dynamic) {
+            dyninf.dynamic = dynamic;
+            dyninf.dynstr = dynstr;
+            fill_dynamic(s1, &dyninf);
+            /* put in GOT the dynamic section address and relocate PLT */
+            write32le(s1->got->data, dynamic->sh_addr);
+            if (file_type == TCC_OUTPUT_EXE
+#if defined(TCC_OUTPUT_DLL_WITH_PLT)
+                || file_type == TCC_OUTPUT_DLL
+#endif
+            )
+                relocate_plt(s1);
+            /* relocate symbols in .dynsym now that final addresses are known */
+            for_each_elem(s1->dynsym, 1, sym, ElfW(Sym)) {
+                if (sym->st_shndx == SHN_UNDEF) {
+                    /* relocate to PLT if symbol corresponds to a PLT entry,
+		       but not if it's a weak symbol */
+		    if (ELFW(ST_BIND)(sym->st_info) == STB_WEAK)
+		        sym->st_value = 0;
+		    else 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;
+                }
+            }
+        }
+    }
+    /* if building executable or DLL, then relocate each section
+       except the GOT which is already relocated */
+    if (file_type != TCC_OUTPUT_OBJ) {
+        ret = final_sections_reloc(s1);
+        if (ret)
+            goto the_end;
+    }
+    /* Perform relocation to GOT or PLT entries */
+    if (file_type == TCC_OUTPUT_EXE && s1->static_link)
+        fill_got(s1);
+    /* Create the ELF file with name 'filename' */
+    ret = tcc_write_elf_file(s1, filename, phnum, phdr, file_offset, sec_order);
+    if (s1->do_strip) {
+	int rc;
+	const char *strip_cmd = "sstrip "; // super strip utility from ELFkickers
+	const char *null_dev = " 2> /dev/null";
+	char buf[1050];
+	snprintf(buf, sizeof(buf), "%s%s%s", strip_cmd, filename, null_dev);
+	rc = system(buf);
+	if (rc)
+	    system(buf+1);	// call a strip utility from binutils
     ret = 0;
  the_end:
     tcc_free(s1->symtab_to_dynsym);
-    tcc_free(section_order);
+    tcc_free(sec_order);
     tcc_free(phdr);
+    tcc_free(s1->sym_attrs);
+    s1->sym_attrs = NULL;
+    return ret;
+}
+LIBTCCAPI int tcc_output_file(TCCState *s, const char *filename)
+{
+    int ret;
+#ifdef TCC_TARGET_PE
+    if (s->output_type != TCC_OUTPUT_OBJ) {
+        ret = pe_output_file(s, filename);
+    } else
+#elif defined TCC_TARGET_MEOS
+    if (s->output_type != TCC_OUTPUT_OBJ) {
+        ret = tcc_output_me(s, filename);
+    } else
+#endif
-    tcc_free(s1->got_offsets);
+        ret = elf_output_file(s, filename);
     return ret;
+}
     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,
+ST_FUNC int tcc_load_object_file(TCCState *s1,
                                 int fd, unsigned long file_offset)
 {
-    Elf32_Ehdr ehdr;
+    ElfW(Ehdr) ehdr;
-    Elf32_Shdr *shdr, *sh;
+    ElfW(Shdr) *shdr, *sh;
     int size, i, j, offset, offseti, nb_syms, sym_index, ret;
     unsigned char *strsec, *strtab;
     int *old_to_new_syms;
     char *sh_name, *name;
     SectionMergeInfo *sm_table, *sm;
-    Elf32_Sym *sym, *symtab;
+    ElfW(Sym) *sym, *symtab;
-    Elf32_Rel *rel, *rel_end;
+    ElfW_Rel *rel;
+    Section *s;
+    int stab_index;
+    int stabstr_index;
-    Section *s;
+    stab_index = stabstr_index = 0;
     if (read(fd, &ehdr, sizeof(ehdr)) != sizeof(ehdr))
         goto fail1;
     if (ehdr.e_ident[0] != ELFMAG0 ||
         goto fail1;
     /* test CPU specific stuff */
     if (ehdr.e_ident[5] != ELFDATA2LSB ||
         ehdr.e_machine != EM_TCC_TARGET) {
     fail1:
-        error_noabort("invalid object file");
+        tcc_error_noabort("invalid object file");
         return -1;
+    }
     /* read sections */
     shdr = load_data(fd, file_offset + ehdr.e_shoff,
-                     sizeof(Elf32_Shdr) * ehdr.e_shnum);
+                     sizeof(ElfW(Shdr)) * ehdr.e_shnum);
     sm_table = tcc_mallocz(sizeof(SectionMergeInfo) * ehdr.e_shnum);
     /* load section names */
     sh = &shdr[ehdr.e_shstrndx];
     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");
+                tcc_error_noabort("object must contain only one symtab");
             fail:
                 ret = -1;
                 goto the_end;
+            }
-            nb_syms = sh->sh_size / sizeof(Elf32_Sym);
+            nb_syms = sh->sh_size / sizeof(ElfW(Sym));
             symtab = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
             sm_table[i].s = symtab_section;
             /* now load strtab */
     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;
+        sh_name = (char *) strsec + sh->sh_name;
         /* ignore sections types we do not handle */
         if (sh->sh_type != SHT_PROGBITS &&
-            sh->sh_type != SHT_REL &&
+            sh->sh_type != SHT_RELX &&
+#ifdef TCC_ARM_EABI
+            sh->sh_type != SHT_ARM_EXIDX &&
+#endif
-            sh->sh_type != SHT_NOBITS)
+            sh->sh_type != SHT_NOBITS &&
+            sh->sh_type != SHT_PREINIT_ARRAY &&
+            sh->sh_type != SHT_INIT_ARRAY &&
+            sh->sh_type != SHT_FINI_ARRAY &&
+            strcmp(sh_name, ".stabstr")
+            )
             continue;
         if (sh->sh_addralign < 1)
             sh->sh_addralign = 1;
         /* find corresponding section, if any */
         for(j = 1; j < s1->nb_sections;j++) {
         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");
+            tcc_error_noabort("invalid section type");
             goto fail;
+        }
         /* align start of section */
+        offset = s->data_offset;
+        if (0 == strcmp(sh_name, ".stab")) {
+            stab_index = i;
+            goto no_align;
+        }
+        if (0 == strcmp(sh_name, ".stabstr")) {
+            stabstr_index = i;
+            goto no_align;
+        }
         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;
-        s->data_offset = offset;
+    no_align:
         sm_table[i].offset = offset;
         sm_table[i].s = s;
         /* concatenate sections */
         size = sh->sh_size;
             s->data_offset += size;
+        }
     next: ;
+    }
+    /* gr relocate stab strings */
+    if (stab_index && stabstr_index) {
+        Stab_Sym *a, *b;
+        unsigned o;
+        s = sm_table[stab_index].s;
+        a = (Stab_Sym *)(s->data + sm_table[stab_index].offset);
+        b = (Stab_Sym *)(s->data + s->data_offset);
+        o = sm_table[stabstr_index].offset;
+        while (a < b)
+            a->n_strx += o, a++;
+    }
     /* second short pass to update sh_link and sh_info fields of new
-       sections */
-    sm = sm_table;
+       sections */
     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) {
+        if (sh->sh_type == SHT_RELX) {
             s->sh_info = sm_table[sh->sh_info].s->sh_num;
             /* update backward link */
             s1->sections[s->sh_info]->reloc = s;
+        }
+    }
     sm = sm_table;
     /* resolve symbols */
             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) {
+                if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
-                    name = strtab + sym->st_name;
+                    name = (char *) strtab + sym->st_name;
                     sym_index = find_elf_sym(symtab_section, name);
                     if (sym_index)
                         old_to_new_syms[i] = sym_index;
+                }
                 continue;
             sym->st_shndx = sm->s->sh_num;
             /* offset value */
             sym->st_value += sm->offset;
+        }
         /* add symbol */
-        name = strtab + sym->st_name;
+        name = (char *) 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;
+    }
         if (!s)
             continue;
         sh = &shdr[i];
         offset = sm_table[i].offset;
         switch(s->sh_type) {
-        case SHT_REL:
+        case SHT_RELX:
             /* take relocation offset information */
             offseti = sm_table[sh->sh_info].offset;
-            rel_end = (Elf32_Rel *)(s->data + s->data_offset);
-            for(rel = (Elf32_Rel *)(s->data + offset);
+            for_each_elem(s, (offset / sizeof(*rel)), rel, ElfW_Rel) {
-                rel < rel_end;
-                rel++) {
                 int type;
                 unsigned sym_index;
                 /* convert symbol index */
-                type = ELF32_R_TYPE(rel->r_info);
+                type = ELFW(R_TYPE)(rel->r_info);
-                sym_index = ELF32_R_SYM(rel->r_info);
+                sym_index = ELFW(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];
+                /* ignore link_once in rel section. */
-                if (!sym_index) {
+                if (!sym_index && !sm->link_once
+#ifdef TCC_TARGET_ARM
+                    && type != R_ARM_V4BX
+#endif
+                   ) {
                 invalid_reloc:
-                    error_noabort("Invalid relocation entry");
+                    tcc_error_noabort("Invalid relocation entry [%2d] '%s' @ %.8x",
+                        i, strsec + sh->sh_name, rel->r_offset);
                     goto fail;
+                }
-                rel->r_info = ELF32_R_INFO(sym_index, type);
+                rel->r_info = ELFW(R_INFO)(sym_index, type);
                 /* offset the relocation offset */
                 rel->r_offset += offseti;
+#ifdef TCC_TARGET_ARM
+                /* Jumps and branches from a Thumb code to a PLT entry need
+                   special handling since PLT entries are ARM code.
+                   Unconditional bl instructions referencing PLT entries are
+                   handled by converting these instructions into blx
+                   instructions. Other case of instructions referencing a PLT
+                   entry require to add a Thumb stub before the PLT entry to
+                   switch to ARM mode. We set bit plt_thumb_stub of the
+                   attribute of a symbol to indicate such a case. */
+                if (type == R_ARM_THM_JUMP24)
+                    alloc_sym_attr(s1, sym_index)->plt_thumb_stub = 1;
+#endif
+            }
             break;
         default:
             break;
+        }
     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_name[16];           /* name of this member */
-    char ar_date[12];		/* file mtime */
+    char ar_date[12];           /* file mtime */
-    char ar_uid[6];		/* owner uid; printed as decimal */
+    char ar_uid[6];             /* owner uid; printed as decimal */
+{
     int i, bound, nsyms, sym_index, off, ret;
     uint8_t *data;
     const char *ar_names, *p;
     const uint8_t *ar_index;
-    Elf32_Sym *sym;
+    ElfW(Sym) *sym;
     data = tcc_malloc(size);
     if (read(fd, data, size) != size)
         goto fail;
     nsyms = get_be32(data);
     ar_index = data + 4;
-    ar_names = ar_index + nsyms * 4;
+    ar_names = (char *) ar_index + nsyms * 4;
     do {
-	bound = 0;
+        bound = 0;
-	for(p = ar_names, i = 0; i < nsyms; i++, p += strlen(p)+1) {
+        for(p = ar_names, i = 0; i < nsyms; i++, p += strlen(p)+1) {
-	    sym_index = find_elf_sym(symtab_section, p);
+            sym_index = find_elf_sym(symtab_section, p);
-	    if(sym_index) {
+            if(sym_index) {
-		sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
+                sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
-		if(sym->st_shndx == SHN_UNDEF) {
-		    off = get_be32(ar_index + i * 4) + sizeof(ArchiveHeader);
-#if 0
-		    printf("%5d\t%s\t%08x\n", i, p, sym->st_shndx);
+                if(sym->st_shndx == SHN_UNDEF) {
-#endif
+                    off = get_be32(ar_index + i * 4) + sizeof(ArchiveHeader);
-		    ++bound;
+                    ++bound;
-		    lseek(fd, off, SEEK_SET);
+                    lseek(fd, off, SEEK_SET);
-		    if(tcc_load_object_file(s1, fd, off) < 0) {
+                    if(tcc_load_object_file(s1, fd, off) < 0) {
     tcc_free(data);
     return ret;
+}
 /* load a '.a' file */
-static int tcc_load_archive(TCCState *s1, int fd)
+ST_FUNC int tcc_load_archive(TCCState *s1, int fd)
+{
     ArchiveHeader hdr;
     char ar_size[11];
     char ar_name[17];
     for(;;) {
         len = read(fd, &hdr, sizeof(hdr));
         if (len == 0)
             break;
         if (len != sizeof(hdr)) {
-            error_noabort("invalid archive");
+            tcc_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);
         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 */
         lseek(fd, file_offset + size, SEEK_SET);
+    }
     return 0;
+}
 #if !defined(TCC_TARGET_PE) && !defined(TCC_TARGET_MEOS)
 /* 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)
+ST_FUNC int tcc_load_dll(TCCState *s1, int fd, const char *filename, int level)
 {
-    Elf32_Ehdr ehdr;
+    ElfW(Ehdr) ehdr;
-    Elf32_Shdr *shdr, *sh, *sh1;
+    ElfW(Shdr) *shdr, *sh, *sh1;
-    int i, nb_syms, nb_dts, sym_bind, ret;
+    int i, j, nb_syms, nb_dts, sym_bind, ret;
-    Elf32_Sym *sym, *dynsym;
+    ElfW(Sym) *sym, *dynsym;
-    Elf32_Dyn *dt, *dynamic;
+    ElfW(Dyn) *dt, *dynamic;
     unsigned char *dynstr;
-    const char *name, *soname, *p;
+    const char *name, *soname;
     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");
+        tcc_error_noabort("bad architecture");
         return -1;
+    }
     /* read sections */
-    shdr = load_data(fd, ehdr.e_shoff, sizeof(Elf32_Shdr) * ehdr.e_shnum);
+    shdr = load_data(fd, ehdr.e_shoff, sizeof(ElfW(Shdr)) * ehdr.e_shnum);
     /* load dynamic section and dynamic symbols */
     nb_syms = 0;
     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);
+            nb_dts = sh->sh_size / sizeof(ElfW(Dyn));
             dynamic = load_data(fd, sh->sh_offset, sh->sh_size);
             break;
         case SHT_DYNSYM:
-            nb_syms = sh->sh_size / sizeof(Elf32_Sym);
+            nb_syms = sh->sh_size / sizeof(ElfW(Sym));
             dynsym = load_data(fd, sh->sh_offset, sh->sh_size);
             sh1 = &shdr[sh->sh_link];
             dynstr = load_data(fd, sh1->sh_offset, sh1->sh_size);
             break;
         default:
-            break;
-        }
-    }
             break;
     /* compute the real library name */
-    soname = filename;
+    }
     p = strrchr(soname, '/');
-    if (p)
+    /* compute the real library name */
-        soname = p + 1;
+    soname = tcc_basename(filename);
             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 = tcc_mallocz(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);
+        sym_bind = ELFW(ST_BIND)(sym->st_info);
         if (sym_bind == STB_LOCAL)
             continue;
-        name = dynstr + sym->st_name;
+        name = (char *) 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;
+            name = (char *) dynstr + dt->d_un.d_val;
-            for(i = 0; i < s1->nb_loaded_dlls; i++) {
+            for(j = 0; j < s1->nb_loaded_dlls; j++) {
-                dllref = s1->loaded_dlls[i];
+                dllref = s1->loaded_dlls[j];
                 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);
+                tcc_error_noabort("referenced dll '%s' not found", name);
                 ret = -1;
                 goto the_end;
     case '\t':
     case '\f':
     case '\v':
     case '\r':
     case '\n':
-        input();
+        inp();
         goto redo;
     case '/':
         minp();
         if (ch == '*') {
-            file->buf_ptr = parse_comment(file->buf_ptr);
+            file->buf_ptr = parse_comment(file->buf_ptr,0);
             ch = file->buf_ptr[0];
             goto redo;
         } else {
             q = name;
             *q++ = '/';
             goto parse_name;
+        }
         break;
-    case 'a' ... 'z':
-    case 'A' ... 'Z':
-    case '_':
     case '\\':
+        ch = handle_eob();
+        if (ch != '\\')
+            goto redo;
+        /* fall through */
+    /* case 'a' ... 'z': */
+    case 'a':
+       case 'b':
+       case 'c':
+       case 'd':
+       case 'e':
+       case 'f':
+       case 'g':
+       case 'h':
+       case 'i':
+       case 'j':
+       case 'k':
+       case 'l':
+       case 'm':
+       case 'n':
+       case 'o':
+       case 'p':
+       case 'q':
+       case 'r':
+       case 's':
+       case 't':
+       case 'u':
+       case 'v':
+       case 'w':
+       case 'x':
+       case 'y':
+       case 'z':
+    /* case 'A' ... 'z': */
+    case 'A':
+       case 'B':
+       case 'C':
+       case 'D':
+       case 'E':
+       case 'F':
+       case 'G':
+       case 'H':
+       case 'I':
+       case 'J':
+       case 'K':
+       case 'L':
+       case 'M':
+       case 'N':
+       case 'O':
+       case 'P':
+       case 'Q':
+       case 'R':
+       case 'S':
+       case 'T':
+       case 'U':
+       case 'V':
+       case 'W':
+       case 'X':
+       case 'Y':
+       case 'Z':
+    case '_':
     case '.':
     case '$':
     case '~':
         q = name;
     parse_name:
     case CH_EOF:
         c = LD_TOK_EOF;
         break;
     default:
         c = ch;
-        input();
+        inp();
         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)
+static int ld_add_file(TCCState *s1, const char filename[])
-{
-    char cmd[64];
-    char filename[1024];
+{
+    int ret;
-    int t;
+    ret = tcc_add_file_internal(s1, filename, 0, TCC_FILETYPE_BINARY);
+    if (ret)
+        ret = tcc_add_dll(s1, filename, 0);
+    return ret;
+}
-    ch = file->buf_ptr[0];
+static inline int new_undef_syms(void)
-    ch = handle_eob();
+{
-    for(;;) {
+    int ret = 0;
-        t = ld_next(s1, cmd, sizeof(cmd));
+    ret = new_undef_sym;
+    new_undef_sym = 0;
+    return ret;
+}
+static int ld_add_file_list(TCCState *s1, const char *cmd, int as_needed)
-        if (t == LD_TOK_EOF)
+{
-            return 0;
+    char filename[1024], libname[1024];
+    int t, group, nblibs = 0, ret = 0;
-        else if (t != LD_TOK_NAME)
+    char **libs = NULL;
-            return -1;
+    group = !strcmp(cmd, "GROUP");
-        if (!strcmp(cmd, "INPUT") ||
+    if (!as_needed)
-            !strcmp(cmd, "GROUP")) {
+        new_undef_syms();
-            t = ld_next(s1, cmd, sizeof(cmd));
+    t = ld_next(s1, filename, sizeof(filename));
-            if (t != '(')
+    if (t != '(')
-                expect("(");
+        expect("(");
+    t = ld_next(s1, filename, sizeof(filename));
-            t = ld_next(s1, filename, sizeof(filename));
+    for(;;) {
-            for(;;) {
+        libname[0] = '\0';
-                if (t == LD_TOK_EOF) {
+        if (t == LD_TOK_EOF) {
+            tcc_error_noabort("unexpected end of file");
-                    error_noabort("unexpected end of file");
+            ret = -1;
-                    return -1;
+            goto lib_parse_error;
+        } else if (t == ')') {
+            break;
+        } else if (t == '-') {
+            t = ld_next(s1, filename, sizeof(filename));
+            if ((t != LD_TOK_NAME) || (filename[0] != 'l')) {
+                tcc_error_noabort("library name expected");
+                ret = -1;
+                goto lib_parse_error;
+            }
+            pstrcpy(libname, sizeof libname, &filename[1]);
+            if (s1->static_link) {
+                snprintf(filename, sizeof filename, "lib%s.a", libname);
+            } else {
-                } else if (t == ')') {
+                snprintf(filename, sizeof filename, "lib%s.so", libname);
-                    break;
+            }
+        } else if (t != LD_TOK_NAME) {
+            tcc_error_noabort("filename expected");
+            ret = -1;
+            goto lib_parse_error;
+        }
+        if (!strcmp(filename, "AS_NEEDED")) {
+            ret = ld_add_file_list(s1, cmd, 1);
+            if (ret)
+                goto lib_parse_error;
+        } else {
+            /* TODO: Implement AS_NEEDED support. Ignore it for now */
-                } else if (t != LD_TOK_NAME) {
+            if (!as_needed) {
+                ret = ld_add_file(s1, filename);
+                if (ret)
+                    goto lib_parse_error;
+                if (group) {
+                    /* Add the filename *and* the libname to avoid future conversions */
+                    dynarray_add((void ***) &libs, &nblibs, tcc_strdup(filename));
+                    if (libname[0] != '\0')
+                        dynarray_add((void ***) &libs, &nblibs, tcc_strdup(libname));
                     error_noabort("filename expected");
-                    return -1;
+            }
                 tcc_add_file(s1, filename);
-                t = ld_next(s1, filename, sizeof(filename));
+        t = ld_next(s1, filename, sizeof(filename));
-                if (t == ',') {
+        if (t == ',') {
-                    t = ld_next(s1, filename, sizeof(filename));
+            t = ld_next(s1, filename, sizeof(filename));
+        }
+    }
+    if (group && !as_needed) {
+        while (new_undef_syms()) {
+            int i;
+            for (i = 0; i < nblibs; i ++)
+                ld_add_file(s1, libs[i]);
+        }
+    }
+lib_parse_error:
+    dynarray_reset(&libs, &nblibs);
+    return ret;
+}
+/* interpret a subset of GNU ldscripts to handle the dummy libc.so
+   files */
+ST_FUNC int tcc_load_ldscript(TCCState *s1)
+{
+    char cmd[64];
+    char filename[1024];
+    int t, ret;
+    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")) {
+            ret = ld_add_file_list(s1, cmd, 0);
             if (ret)
                 return ret;
         } 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");
+                    tcc_error_noabort("unexpected end of file");
                     return -1;
                 } else if (t == ')') {
                     break;
             return -1;
+        }
+    }
     return 0;
+}
+#endif /* !TCC_TARGET_PE */

Subversion Repositories Kolibri OS

(root)/programs/develop/ktcc/trunk/source/tccelf.c – Rev 647 → 6429