Update our yasm copy to yasm 1.1.0 (Part 1: yasm side)...

third_party/yasm/patched-yasm/modules/objfmts/elf/elf-objfmt.c

 /*
  * ELF object format
  *
  *  Copyright (C) 2003-2007  Michael Urman
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND OTHER CONTRIBUTORS ``AS IS''
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR OTHER CONTRIBUTORS BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <util.h>
-/*@unused@*/ RCSID("$Id: elf-objfmt.c 2166 2009-01-02 08:33:21Z peter $");
+/*@unused@*/ RCSID("$Id: elf-objfmt.c 2310 2010-03-28 19:28:54Z peter $");
 
 /* Notes
  *
  * elf-objfmt uses the "linking" view of an ELF file:
  * ELF header, an optional program header table, several sections,
  * and a section header table
  *
  * The ELF header tells us some overall program information,
  *   where to find the PHT (if it exists) with phnum and phentsize, 
  *   and where to find the SHT with shnum and shentsize
@@ skipping 22 matching lines @@
 } yasm_objfmt_elf;
 
 typedef struct {
     yasm_objfmt_elf *objfmt_elf;
     yasm_errwarns *errwarns;
     FILE *f;
     elf_secthead *shead;
     yasm_section *sect;
     yasm_object *object;
     unsigned long sindex;
+    yasm_symrec *GOT_sym;
 } elf_objfmt_output_info;
 
 typedef struct {
     yasm_object *object;
     yasm_objfmt_elf *objfmt_elf;
     yasm_errwarns *errwarns;
     int local_names;
 } build_symtab_info;
 
 yasm_objfmt_module yasm_elf_LTX_objfmt;
@@ skipping 366 matching lines @@
 elf_objfmt_output_reloc(yasm_symrec *sym, yasm_bytecode *bc,
                         unsigned char *buf, unsigned int destsize,
                         unsigned int valsize, int warn, void *d)
 {
     elf_reloc_entry *reloc;
     elf_objfmt_output_info *info = d;
     yasm_intnum *zero;
     int retval;
 
     reloc = elf_reloc_entry_create(sym, NULL,
-        yasm_intnum_create_uint(bc->offset), 0, valsize);
+        yasm_intnum_create_uint(bc->offset), 0, valsize, 0);
     if (reloc == NULL) {
         yasm_error_set(YASM_ERROR_TYPE, N_("elf: invalid relocation size"));
         return 1;
     }
     /* allocate .rel[a] sections on a need-basis */
     elf_secthead_append_reloc(info->sect, info->shead, reloc);
 
     zero = yasm_intnum_create_uint(0);
-    elf_handle_reloc_addend(zero, reloc);
+    elf_handle_reloc_addend(zero, reloc, 0);
     retval = yasm_arch_intnum_tobytes(info->object->arch, zero, buf, destsize,
                                       valsize, 0, bc, warn);
     yasm_intnum_destroy(zero);
     return retval;
 }
 
 static int
 elf_objfmt_output_value(yasm_value *value, unsigned char *buf,
                         unsigned int destsize, unsigned long offset,
                         yasm_bytecode *bc, int warn, /*@null@*/ void *d)
@@ skipping 62 matching lines @@
                 sym = elf_secthead_get_sym(sym_shead);
 
                 intn_val = yasm_bc_next_offset(sym_precbc);
             }
         }
         
         /* For PC-relative, need to add offset of expression within bc. */
         if (value->curpos_rel)
             intn_val += offset;
 
+        /* Check for _GLOBAL_OFFSET_TABLE_ symbol reference */
         reloc = elf_reloc_entry_create(sym, wrt,
             yasm_intnum_create_uint(bc->offset + offset), value->curpos_rel,
-            valsize);
+            valsize, sym == info->GOT_sym);
         if (reloc == NULL) {
             yasm_error_set(YASM_ERROR_TYPE,
                            N_("elf: invalid relocation (WRT or size)"));
             return 1;
         }
         /* allocate .rel[a] sections on a need-basis */
         elf_secthead_append_reloc(info->sect, info->shead, reloc);
     }
 
     intn = yasm_intnum_create_uint(intn_val);
 
     if (value->abs) {
         yasm_intnum *intn2 = yasm_expr_get_intnum(&value->abs, 0);
         if (!intn2) {
             yasm_error_set(YASM_ERROR_TOO_COMPLEX,
                            N_("elf: relocation too complex"));
             yasm_intnum_destroy(intn);
             return 1;
         }
         yasm_intnum_calc(intn, YASM_EXPR_ADD, intn2);
     }
 
     if (reloc)
-        elf_handle_reloc_addend(intn, reloc);
+        elf_handle_reloc_addend(intn, reloc, offset);
     retval = yasm_arch_intnum_tobytes(info->object->arch, intn, buf, destsize,
                                       valsize, 0, bc, warn);
     yasm_intnum_destroy(intn);
     return retval;
 }
 
 static int
 elf_objfmt_output_bytecode(yasm_bytecode *bc, /*@null@*/ void *d)
 {
     /*@null@*/ elf_objfmt_output_info *info = (elf_objfmt_output_info *)d;
@@ skipping 39 matching lines @@
     }
 
     /* If bigbuf was allocated, free it */
     if (bigbuf)
         yasm_xfree(bigbuf);
 
     return 0;
 }
 
 static int
-elf_objfmt_create_dbg_secthead(yasm_section *sect, /*@null@*/ void *d)
-{
-    /*@null@*/ elf_objfmt_output_info *info = (elf_objfmt_output_info *)d;
-    elf_secthead *shead;
-    elf_section_type type=SHT_PROGBITS;
-    elf_size entsize=0;
-    const char *sectname;
-    /*@dependent@*/ yasm_symrec *sym;
-    elf_strtab_entry *name;
-
-    shead = yasm_section_get_data(sect, &elf_section_data);
-    if (shead)
-        return 0;   /* only create new secthead if missing */
-
-    sectname = yasm_section_get_name(sect);
-    name = elf_strtab_append_str(info->objfmt_elf->shstrtab, sectname);
-
-    if (yasm__strcasecmp(sectname, ".stab")==0) {
-        entsize = 12;
-    } else if (yasm__strcasecmp(sectname, ".stabstr")==0) {
-        type = SHT_STRTAB;
-    } else if (yasm__strncasecmp(sectname, ".debug_", 7)==0) {
-        ;
-    } else
-        yasm_internal_error(N_("Unrecognized section without data"));
-
-    shead = elf_secthead_create(name, type, 0, 0, 0);
-    elf_secthead_set_entsize(shead, entsize);
-
-    sym = yasm_symtab_define_label(info->object->symtab, sectname,
-                                   yasm_section_bcs_first(sect), 1, 0);
-    elf_secthead_set_sym(shead, sym);
-
-    yasm_section_add_data(sect, &elf_section_data, shead);
-
-    return 0;
-}
-
-static int
 elf_objfmt_output_section(yasm_section *sect, /*@null@*/ void *d)
 {
     /*@null@*/ elf_objfmt_output_info *info = (elf_objfmt_output_info *)d;
     /*@dependent@*/ /*@null@*/ elf_secthead *shead;
     long pos;
     char *relname;
     const char *sectname;
 
     if (info == NULL)
         yasm_internal_error("null info struct");
@@ skipping 89 matching lines @@
     elf_secthead *esdn;
     unsigned long elf_strtab_offset, elf_shstrtab_offset, elf_symtab_offset;
     unsigned long elf_strtab_size, elf_shstrtab_size, elf_symtab_size;
     elf_strtab_entry *elf_strtab_name, *elf_shstrtab_name, *elf_symtab_name;
     unsigned long elf_symtab_nlocal;
 
     info.object = object;
     info.objfmt_elf = objfmt_elf;
     info.errwarns = errwarns;
     info.f = f;
+    info.GOT_sym = yasm_symtab_get(object->symtab, "_GLOBAL_OFFSET_TABLE_");
 
     /* Update filename strtab */
     elf_strtab_entry_set_str(objfmt_elf->file_strtab_entry,
                              object->src_filename);
 
     /* Allocate space for Ehdr by seeking forward */
     if (fseek(f, (long)(elf_proghead_get_size()), SEEK_SET) < 0) {
         yasm_error_set(YASM_ERROR_IO, N_("could not seek on output file"));
         yasm_errwarn_propagate(errwarns, 0);
         return;
     }
 
-    /* Create missing section headers */
-    if (yasm_object_sections_traverse(object, &info,
-                                      elf_objfmt_create_dbg_secthead))
-        return;
-
     /* add all (local) syms to symtab because relocation needs a symtab index
      * if all_syms, register them by name.  if not, use strtab entry 0 */
     buildsym_info.object = object;
     buildsym_info.objfmt_elf = objfmt_elf;
     buildsym_info.errwarns = errwarns;
     buildsym_info.local_names = all_syms;
     yasm_symtab_traverse(object->symtab, &buildsym_info,
                          elf_objfmt_build_symtab);
     elf_symtab_nlocal = elf_symtab_assign_indices(objfmt_elf->elf_symtab);
 
@@ skipping 105 matching lines @@
 static void
 elf_objfmt_destroy(yasm_objfmt *objfmt)
 {
     yasm_objfmt_elf *objfmt_elf = (yasm_objfmt_elf *)objfmt;
     elf_symtab_destroy(objfmt_elf->elf_symtab);
     elf_strtab_destroy(objfmt_elf->shstrtab);
     elf_strtab_destroy(objfmt_elf->strtab);
     yasm_xfree(objfmt);
 }
 
-static elf_secthead *
-elf_objfmt_init_new_section(yasm_object *object, yasm_section *sect,
-                            const char *sectname, unsigned long type,
-                            unsigned long flags, unsigned long line)
+static void
+elf_objfmt_init_new_section(yasm_section *sect, unsigned long line)
 {
+    yasm_object *object = yasm_section_get_object(sect);
+    const char *sectname = yasm_section_get_name(sect);
     yasm_objfmt_elf *objfmt_elf = (yasm_objfmt_elf *)object->objfmt;
     elf_secthead *esd;
     yasm_symrec *sym;
     elf_strtab_entry *name = elf_strtab_append_str(objfmt_elf->shstrtab,
                                                    sectname);
 
-    esd = elf_secthead_create(name, type, flags, 0, 0);
+    elf_section_type type=SHT_PROGBITS;
+    elf_size entsize=0;
+
+    if (yasm__strcasecmp(sectname, ".stab")==0) {
+        entsize = 12;
+    } else if (yasm__strcasecmp(sectname, ".stabstr")==0) {
+        type = SHT_STRTAB;
+    }
+
+    esd = elf_secthead_create(name, type, 0, 0, 0);
+    elf_secthead_set_entsize(esd, entsize);
     yasm_section_add_data(sect, &elf_section_data, esd);
     sym = yasm_symtab_define_label(object->symtab, sectname,
                                    yasm_section_bcs_first(sect), 1, line);
 
     elf_secthead_set_sym(esd, sym);
-
-    return esd;
 }
 
 static yasm_section *
 elf_objfmt_add_default_section(yasm_object *object)
 {
     yasm_section *retval;
     int isnew;
-    elf_secthead *esd;
 
     retval = yasm_object_get_general(object, ".text", 16, 1, 0, &isnew, 0);
-    esd = elf_objfmt_init_new_section(object, retval, ".text", SHT_PROGBITS,
-                                      SHF_ALLOC + SHF_EXECINSTR, 0);
-    yasm_section_set_default(retval, 1);
+    if (isnew)
+    {
+        elf_secthead *esd = yasm_section_get_data(retval, &elf_section_data);
+        elf_secthead_set_typeflags(esd, SHT_PROGBITS,
+                                   SHF_ALLOC + SHF_EXECINSTR);
+        yasm_section_set_default(retval, 1);
+    }
     return retval;
 }
 
 struct elf_section_switch_data {
     /*@only@*/ /*@null@*/ yasm_intnum *align_intn;
     unsigned long flags;
     unsigned long type;
     int gasflags;
     int stdsect;
 };
@@ skipping 168 matching lines @@
             yasm_warn_set(YASM_WARN_GENERAL,
                           N_("entity size for SHF_MERGE not specified"));
             data.flags &= ~SHF_MERGE;
         }
     }
 
     retval = yasm_object_get_general(object, sectname, align,
                                      (data.flags & SHF_EXECINSTR) != 0,
                                      resonly, &isnew, line);
 
-    if (isnew)
-        esd = elf_objfmt_init_new_section(object, retval, sectname, data.type,
-                                          data.flags, line);
-    else
-        esd = yasm_section_get_data(retval, &elf_section_data);
+    esd = yasm_section_get_data(retval, &elf_section_data);
 
     if (isnew || yasm_section_is_default(retval)) {
         yasm_section_set_default(retval, 0);
         elf_secthead_set_typeflags(esd, data.type, data.flags);
         if (merge_intn)
             elf_secthead_set_entsize(esd, yasm_intnum_get_uint(merge_intn));
         yasm_section_set_align(retval, align, line);
     } else if (flags_override && !data.gasflags)
         yasm_warn_set(YASM_WARN_GENERAL,
                       N_("section flags ignored on section redeclaration"));
@@ skipping 189 matching lines @@
     32,
     0,
     elf_objfmt_dbgfmt_keywords,
     "null",
     elf_objfmt_directives,
     elf_objfmt_stdmacs,
     elf_objfmt_create,
     elf_objfmt_output,
     elf_objfmt_destroy,
     elf_objfmt_add_default_section,
+    elf_objfmt_init_new_section,
     elf_objfmt_section_switch,
     elf_objfmt_get_special_sym
 };
 
 yasm_objfmt_module yasm_elf32_LTX_objfmt = {
     "ELF (32-bit)",
     "elf32",
     "o",
     32,
     0,
     elf_objfmt_dbgfmt_keywords,
     "null",
     elf_objfmt_directives,
     elf_objfmt_stdmacs,
     elf32_objfmt_create,
     elf_objfmt_output,
     elf_objfmt_destroy,
     elf_objfmt_add_default_section,
+    elf_objfmt_init_new_section,
     elf_objfmt_section_switch,
     elf_objfmt_get_special_sym
 };
 
 yasm_objfmt_module yasm_elf64_LTX_objfmt = {
     "ELF (64-bit)",
     "elf64",
     "o",
     64,
     0,
     elf_objfmt_dbgfmt_keywords,
     "null",
     elf_objfmt_directives,
     elf_objfmt_stdmacs,
     elf64_objfmt_create,
     elf_objfmt_output,
     elf_objfmt_destroy,
     elf_objfmt_add_default_section,
+    elf_objfmt_init_new_section,
     elf_objfmt_section_switch,
     elf_objfmt_get_special_sym
 };