GDB 7.6.50

bfd/elf32-sh-symbian.c

 /* Renesas / SuperH specific support for Symbian 32-bit ELF files
    Copyright 2004, 2005, 2006, 2007, 2008
    Free Software Foundation, Inc.
    Contributed by Red Hat
 
    This file is part of BFD, the Binary File Descriptor library.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
    MA 02110-1301, USA.  */
 
 
 /* Stop elf32-sh.c from defining any target vectors.  */
 #define SH_TARGET_ALREADY_DEFINED
 #define sh_find_elf_flags           sh_symbian_find_elf_flags
-#define sh_elf_get_flags_from_mach  sh_symbian_elf_get_flags_from_mach 
+#define sh_elf_get_flags_from_mach  sh_symbian_elf_get_flags_from_mach
 #include "elf32-sh.c"
 
 
 //#define SYMBIAN_DEBUG 1
 #define SYMBIAN_DEBUG 0
 
 #define DIRECTIVE_HEADER        "#<SYMEDIT>#\n"
 #define DIRECTIVE_IMPORT        "IMPORT "
 #define DIRECTIVE_EXPORT        "EXPORT "
 #define DIRECTIVE_AS            "AS "
@@ skipping 84 matching lines @@
   for (node = rename_list; node; node = node->next)
     if (strcmp (node->current_name, current_name) == 0)
       {
         if (strcmp (node->new_name, new_name) == 0)
           /* Already added to rename list.  */
           return TRUE;
 
         bfd_set_error (bfd_error_invalid_operation);
         _bfd_error_handler (_("%B: IMPORT AS directive for %s conceals previous IMPORT AS"),
                             abfd, current_name);
-        return FALSE;       
+        return FALSE;
       }
 
   if ((node = bfd_malloc (sizeof * node)) == NULL)
     {
       if (SYMBIAN_DEBUG)
         fprintf (stderr, "IMPORT AS: No mem for new rename node\n");
       return FALSE;
     }
 
   if ((node->current_name = bfd_malloc (strlen (current_name) + 1)) == NULL)
     {
       if (SYMBIAN_DEBUG)
         fprintf (stderr, "IMPORT AS: No mem for current name field in rename node\n");
       free (node);
       return FALSE;
     }
   else
     strcpy (node->current_name, current_name);
-  
+
   if ((node->new_name = bfd_malloc (strlen (new_name) + 1)) == NULL)
     {
       if (SYMBIAN_DEBUG)
         fprintf (stderr, "IMPORT AS: No mem for new name field in rename node\n");
       free (node->current_name);
       free (node);
       return FALSE;
     }
   else
     strcpy (node->new_name, new_name);
@@ skipping 209 matching lines @@
         default:
           result = FALSE;
           break;
         }
 
       if (! result)
         {
           if (SYMBIAN_DEBUG)
             fprintf (stderr, "offset into .directive section: %ld\n",
                      (long) (directive - (char *) contents));
-          
+
           bfd_set_error (bfd_error_invalid_operation);
           _bfd_error_handler (_("%B: Unrecognised .directive command: %s"),
                               abfd, directive);
           break;
         }
     }
 
   return result;
 }
 
@@ skipping 10 matching lines @@
   bfd_size_type sz;
 
   if (!sec)
     return TRUE;
 
   sz = sec->rawsize ? sec->rawsize : sec->size;
   contents = bfd_malloc (sz);
 
   if (!contents)
     bfd_set_error (bfd_error_no_memory);
-  else 
+  else
     {
       if (bfd_get_section_contents (abfd, sec, contents, 0, sz))
         result = sh_symbian_process_embedded_commands (info, abfd, sec, contents);
       free (contents);
     }
 
   return result;
 }
 
 /* Intercept the normal sh_relocate_section() function
@@ skipping 14 matching lines @@
     {
       Elf_Internal_Rela *            rel;
       Elf_Internal_Rela *            relend;
       Elf_Internal_Shdr *            symtab_hdr;
       struct elf_link_hash_entry **  sym_hashes;
       struct elf_link_hash_entry **  sym_hashes_end;
       struct elf_link_hash_table *   hash_table;
       symbol_rename *                ptr;
       bfd_size_type                  num_global_syms;
       unsigned long                  num_local_syms;
-      
+
       BFD_ASSERT (! elf_bad_symtab (input_bfd));
- 
+
       symtab_hdr       = & elf_tdata (input_bfd)->symtab_hdr;
       hash_table       = elf_hash_table (info);
       num_local_syms   = symtab_hdr->sh_info;
       num_global_syms  = symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
       num_global_syms -= num_local_syms;
       sym_hashes       = elf_sym_hashes (input_bfd);
       sym_hashes_end   = sym_hashes + num_global_syms;
 
       /* First scan the rename table, caching the hash entry and the new index.  */
       for (ptr = rename_list; ptr; ptr = ptr->next)
         {
           struct elf_link_hash_entry *   new_hash;
           struct elf_link_hash_entry **  h;
 
           ptr->current_hash = elf_link_hash_lookup (hash_table, ptr->current_name, FALSE, FALSE, TRUE);
 
           if (ptr->current_hash == NULL)
             {
               if (SYMBIAN_DEBUG)
                 fprintf (stderr, "IMPORT AS: current symbol '%s' does not exist\n", ptr->current_name);
               continue;
             }
-          
-          new_hash = elf_link_hash_lookup (hash_table, ptr->new_name, FALSE, FALSE, TRUE);
 
+          new_hash = elf_link_hash_lookup (hash_table, ptr->new_name,
+                                           FALSE, FALSE, TRUE);
           /* If we could not find the symbol then it is a new, undefined symbol.
              Symbian want this behaviour - ie they want to be able to rename the
              reference in a reloc from one undefined symbol to another, new and
              undefined symbol.  So we create that symbol here.  */
           if (new_hash == NULL)
             {
-              asection *                     psec = bfd_und_section_ptr;
-              Elf_Internal_Sym               new_sym;
-              bfd_vma                        new_value = 0;
-              bfd_boolean                    skip;
-              bfd_boolean                    override;
-              bfd_boolean                    type_change_ok;
-              bfd_boolean                    size_change_ok;
+              struct bfd_link_hash_entry *bh = NULL;
+              bfd_boolean collect = get_elf_backend_data (input_bfd)->collect;
+              if (_bfd_generic_link_add_one_symbol (info, input_bfd,
+                                                    ptr->new_name, BSF_GLOBAL,
+                                                    bfd_und_section_ptr, 0,
+                                                    NULL, FALSE, collect,
+                                                    &bh))
+                {
+                  new_hash = (struct elf_link_hash_entry *) bh;
+                  new_hash->type = STT_FUNC;
+                  new_hash->non_elf = 0;
 
-              new_sym.st_value = 0;
-              new_sym.st_size  = 0;
-              new_sym.st_name  = -1;
-              new_sym.st_info  = ELF_ST_INFO (STB_GLOBAL, STT_FUNC);
-              new_sym.st_other = ELF_ST_VISIBILITY (STV_DEFAULT);
-              new_sym.st_shndx = SHN_UNDEF;
-              new_sym.st_target_internal = 0;
+                  if (SYMBIAN_DEBUG)
+                    fprintf (stderr, "Created new symbol %s\n", ptr->new_name);
+                }
+            }
 
-              if (! _bfd_elf_merge_symbol (input_bfd, info,
-                                           ptr->new_name, & new_sym,
-                                           & psec, & new_value, NULL,
-                                           & new_hash, & skip,
-                                           & override, & type_change_ok,
-                                           & size_change_ok))
-                {
-                  _bfd_error_handler (_("%B: Failed to add renamed symbol %s"),
-                                      input_bfd, ptr->new_name);
-                  continue;
-                }
-              /* XXX - should we check psec, skip, override etc ?  */
-
-              new_hash->root.type = bfd_link_hash_undefined;
-
-              /* Allow the symbol to become local if necessary.  */
-              if (new_hash->dynindx == -1)
-                new_hash->def_regular = 1;
-
-              if (SYMBIAN_DEBUG)
-                fprintf (stderr, "Created new symbol %s\n", ptr->new_name);
+          if (new_hash == NULL)
+            {
+              _bfd_error_handler (_("%B: Failed to add renamed symbol %s"),
+                                  input_bfd, ptr->new_name);
+              continue;
             }
 
           /* Convert the new_hash value into a index into the table of symbol hashes.  */
           for (h = sym_hashes; h < sym_hashes_end; h ++)
             {
               if (* h == new_hash)
                 {
                   ptr->new_symndx = h - sym_hashes + num_local_syms;
                   if (SYMBIAN_DEBUG)
                     fprintf (stderr, "Converted new hash to index of %ld\n", ptr->new_symndx);
@@ skipping 33 matching lines @@
 
       /* Walk the reloc list looking for references to renamed symbols.
          When we find one, we alter the index in the reloc to point to the new symbol.  */
       for (rel = relocs, relend = relocs + input_section->reloc_count;
            rel < relend;
            rel ++)
         {
           int                          r_type;
           unsigned long                r_symndx;
           struct elf_link_hash_entry * h;
-      
+
           r_symndx = ELF32_R_SYM (rel->r_info);
           r_type = ELF32_R_TYPE (rel->r_info);
 
           /* Ignore unused relocs.  */
           if ((r_type >= (int) R_SH_GNU_VTINHERIT
                && r_type <= (int) R_SH_LABEL)
               || r_type == (int) R_SH_NONE
               || r_type < 0
               || r_type >= R_SH_max)
             continue;
@@ skipping 23 matching lines @@
                 BFD_ASSERT (ptr->new_symndx);
                 if (SYMBIAN_DEBUG)
                   fprintf (stderr, "convert reloc %lx from using index %ld to using index %ld\n",
                            (unsigned long) rel->r_info,
                            (long) ELF32_R_SYM (rel->r_info), ptr->new_symndx);
                 rel->r_info = ELF32_R_INFO (ptr->new_symndx, r_type);
                 break;
               }
         }
     }
-  
+
   return sh_elf_relocate_section (output_bfd, info, input_bfd, input_section,
                                   contents, relocs, local_syms, local_sections);
 }
 
 #define TARGET_LITTLE_SYM       bfd_elf32_shl_symbian_vec
 #define TARGET_LITTLE_NAME      "elf32-shl-symbian"
 
 #undef  elf_backend_relocate_section
 #define elf_backend_relocate_section    sh_symbian_relocate_section
 #undef  elf_backend_check_directives
 #define elf_backend_check_directives    sh_symbian_process_directives
 
 #include "elf32-target.h"