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

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

 /*
  * ELF object format helpers
  *
  *  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.c 2040 2008-02-21 08:57:23Z peter $");
+/*@unused@*/ RCSID("$Id: elf.c 2206 2009-07-21 06:48:42Z peter $");
 
 #include <libyasm.h>
 #define YASM_OBJFMT_ELF_INTERNAL
 #include "elf.h"
 #include "elf-machine.h"
 
 static void elf_section_data_destroy(void *data);
 static void elf_secthead_print(void *data, FILE *f, int indent_level);
 
 const yasm_assoc_data_callback elf_section_data = {
     elf_section_data_destroy,
     elf_secthead_print
 };
 
 static void elf_symrec_data_destroy(/*@only@*/ void *d);
 static void elf_symtab_entry_print(void *data, FILE *f, int indent_level);
+static void elf_ssym_symtab_entry_print(void *data, FILE *f, int indent_level);
 
 const yasm_assoc_data_callback elf_symrec_data = {
     elf_symrec_data_destroy,
     elf_symtab_entry_print
 };
 
+const yasm_assoc_data_callback elf_ssym_symrec_data = {
+    elf_symrec_data_destroy,
+    elf_ssym_symtab_entry_print
+};
+
 extern elf_machine_handler
     elf_machine_handler_x86_x86,
     elf_machine_handler_x86_amd64;
 
 static const elf_machine_handler *elf_machine_handlers[] =
 {
     &elf_machine_handler_x86_x86,
     &elf_machine_handler_x86_amd64,
     NULL
 };
@@ skipping 23 matching lines @@
     {
         /* Allocate "special" syms */
         elf_ssyms =
             yasm_xmalloc(elf_march->num_ssyms * sizeof(yasm_symrec *));
         for (i=0; (unsigned int)i<elf_march->num_ssyms; i++)
         {
             /* FIXME: misuse of NULL bytecode */
             elf_ssyms[i] = yasm_symtab_define_label(symtab,
                                                     elf_march->ssyms[i].name,
                                                     NULL, 0, 0);
+            yasm_symrec_add_data(elf_ssyms[i], &elf_ssym_symrec_data,
+                                 &elf_march->ssyms[i]);
         }
     }
 
     return elf_march;
 }
 
 yasm_symrec *
 elf_get_special_sym(const char *name, const char *parser)
 {
     int i;
@@ skipping 29 matching lines @@
     }
     return 0;
 }
 
 /* takes ownership of addr */
 elf_reloc_entry *
 elf_reloc_entry_create(yasm_symrec *sym,
                        yasm_symrec *wrt,
                        yasm_intnum *addr,
                        int rel,
-                       size_t valsize)
+                       size_t valsize,
+                       int is_GOT_sym)
 {
     elf_reloc_entry *entry;
 
     if (!elf_march->accepts_reloc)
         yasm_internal_error(N_("Unsupported machine for ELF output"));
 
-    if (!elf_march->accepts_reloc(valsize, wrt, elf_ssyms))
+    if (!elf_march->accepts_reloc(valsize, wrt))
     {
         if (addr)
             yasm_intnum_destroy(addr);
         return NULL;
     }
 
     if (sym == NULL)
         yasm_internal_error("sym is null");
 
     entry = yasm_xmalloc(sizeof(elf_reloc_entry));
     entry->reloc.sym = sym;
     entry->reloc.addr = addr;
     entry->rtype_rel = rel;
     entry->valsize = valsize;
     entry->addend = NULL;
     entry->wrt = wrt;
+    entry->is_GOT_sym = is_GOT_sym;
 
     return entry;
 }
 
 void
 elf_reloc_entry_destroy(void *entry)
 {
     if (((elf_reloc_entry*)entry)->addend)
         yasm_intnum_destroy(((elf_reloc_entry*)entry)->addend);
     yasm_xfree(entry);
@@ skipping 165 matching lines @@
         default:                fprintf(f, "undef\n");  break;
     }
     fprintf(f, "%*ssize=", indent_level, "");
     if (entry->xsize)
         yasm_expr_print(entry->xsize, f);
     else
         fprintf(f, "%ld", entry->size);
     fprintf(f, "\n");
 }
 
+static void
+elf_ssym_symtab_entry_print(void *data, FILE *f, int indent_level)
+{
+    /* TODO */
+}
+
 elf_symtab_head *
 elf_symtab_create()
 {
     elf_symtab_head *symtab = yasm_xmalloc(sizeof(elf_symtab_head));
     elf_symtab_entry *entry = yasm_xmalloc(sizeof(elf_symtab_entry));
 
     STAILQ_INIT(symtab);
     entry->in_table = 1;
     entry->sym = NULL;
     entry->sect = NULL;
@@ skipping 332 matching lines @@
     {
         size_t prepend_length = strlen(elf_march->reloc_section_prefix);
         char *sectname = yasm_xmalloc(prepend_length + strlen(basesect) + 1);
         strcpy(sectname, elf_march->reloc_section_prefix);
         strcat(sectname, basesect);
         return sectname;
     }
 }
 
 void
-elf_handle_reloc_addend(yasm_intnum *intn, elf_reloc_entry *reloc)
+elf_handle_reloc_addend(yasm_intnum *intn,
+                        elf_reloc_entry *reloc,
+                        unsigned long offset)
 {
     if (!elf_march->handle_reloc_addend)
         yasm_internal_error(N_("Unsupported machine for ELF output"));
-    elf_march->handle_reloc_addend(intn, reloc);
+    elf_march->handle_reloc_addend(intn, reloc, offset);
 }
 
 unsigned long
 elf_secthead_write_rel_to_file(FILE *f, elf_section_index symtab_idx,
                                yasm_section *sect, elf_secthead *shead,
                                elf_section_index sindex)
 {
     unsigned char buf[SHDR_MAXSIZE], *bufp = buf;
 
     if (shead == NULL)
@@ skipping 51 matching lines @@
 
         esym = yasm_symrec_get_data(reloc->reloc.sym, &elf_symrec_data);
         if (esym)
             r_sym = esym->symindex;
         else
             r_sym = STN_UNDEF;
 
         vis = yasm_symrec_get_visibility(reloc->reloc.sym);
         if (!elf_march->map_reloc_info_to_type)
             yasm_internal_error(N_("Unsupported arch/machine for elf output"));
-        r_type = elf_march->map_reloc_info_to_type(reloc, elf_ssyms);
+        r_type = elf_march->map_reloc_info_to_type(reloc);
 
         bufp = buf;
         if (!elf_march->write_reloc || !elf_march->reloc_entry_size)
             yasm_internal_error(N_("Unsupported arch/machine for elf output"));
         elf_march->write_reloc(bufp, reloc, r_type, r_sym);
         fwrite(buf, elf_march->reloc_entry_size, 1, f);
         size += elf_march->reloc_entry_size;
 
         reloc = (elf_reloc_entry *)
             yasm_section_reloc_next((yasm_reloc *)reloc);
@@ skipping 140 matching lines @@
 
     if (((unsigned)(bufp - buf)) != elf_march->proghead_size)
         yasm_internal_error(N_("ELF program header is not proper length"));
 
     if (fwrite(buf, elf_march->proghead_size, 1, f))
         return elf_march->proghead_size;
 
     yasm_internal_error(N_("Failed to write ELF program header"));
     return 0;
 }