Merge GDB 7.5.1

bfd/elf32-score.c

 /* 32-bit ELF support for S+core.
-   Copyright 2006, 2007, 2008, 2009, 2010, 2011
+   Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012
    Free Software Foundation, Inc.
    Contributed by
    Brain.lin (brain.lin@sunplusct.com)
    Mei Ligang (ligang@sunnorth.com.cn)
    Pei-Lin Tsai (pltsai@sunplus.com)
 
    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
@@ skipping 1046 matching lines @@
       h->root.dynindx = --hsd->min_got_dynindx;
       hsd->low = (struct elf_link_hash_entry *) h;
     }
 
   return TRUE;
 }
 
 static asection *
 score_elf_got_section (bfd *abfd, bfd_boolean maybe_excluded)
 {
-  asection *sgot = bfd_get_section_by_name (abfd, ".got");
+  asection *sgot = bfd_get_linker_section (abfd, ".got");
 
   if (sgot == NULL || (! maybe_excluded && (sgot->flags & SEC_EXCLUDE) != 0))
     return NULL;
   return sgot;
 }
 
 /* Returns the GOT information associated with the link indicated by
    INFO.  If SGOTP is non-NULL, it is filled in with the GOT section.  */
 static struct score_got_info *
 score_elf_got_info (bfd *abfd, asection **sgotp)
@@ skipping 160 matching lines @@
   return FALSE;
 }
 
 /* Returns the dynamic relocation section for DYNOBJ.  */
 static asection *
 score_elf_rel_dyn_section (bfd *dynobj, bfd_boolean create_p)
 {
   static const char dname[] = ".rel.dyn";
   asection *sreloc;
 
-  sreloc = bfd_get_section_by_name (dynobj, dname);
+  sreloc = bfd_get_linker_section (dynobj, dname);
   if (sreloc == NULL && create_p)
     {
-      sreloc = bfd_make_section_with_flags (dynobj, dname,
-                                            (SEC_ALLOC
-                                             | SEC_LOAD
-                                             | SEC_HAS_CONTENTS
-                                             | SEC_IN_MEMORY
-                                             | SEC_LINKER_CREATED
-                                             | SEC_READONLY));
+      sreloc = bfd_make_section_anyway_with_flags (dynobj, dname,
+                                                   (SEC_ALLOC
+                                                    | SEC_LOAD
+                                                    | SEC_HAS_CONTENTS
+                                                    | SEC_IN_MEMORY
+                                                    | SEC_LINKER_CREATED
+                                                    | SEC_READONLY));
       if (sreloc == NULL
           || ! bfd_set_section_alignment (dynobj, sreloc,
                                           SCORE_ELF_LOG_FILE_ALIGN (dynobj)))
         return NULL;
     }
   return sreloc;
 }
 
 static void
 score_elf_allocate_dynamic_relocations (bfd *abfd, unsigned int n)
@@ skipping 152 matching lines @@
       return TRUE;
     }
 
   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
 
   if (maybe_exclude)
     flags |= SEC_EXCLUDE;
 
   /* We have to use an alignment of 2**4 here because this is hardcoded
      in the function stub generation and in the linker script.  */
-  s = bfd_make_section_with_flags (abfd, ".got", flags);
+  s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
    if (s == NULL
       || ! bfd_set_section_alignment (abfd, s, 4))
     return FALSE;
 
   /* Define the symbol _GLOBAL_OFFSET_TABLE_.  We don't do this in the
      linker script because we don't want to define the symbol if we
      are not creating a global offset table.  */
   bh = NULL;
   if (! (_bfd_generic_link_add_one_symbol
          (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
@@ skipping 1222 matching lines @@
               if (! ((*info->callbacks->undefined_symbol)
                      (info, h->root.root.root.string, input_bfd,
                       input_section, rel->r_offset,
                       (info->unresolved_syms_in_objects == RM_GENERATE_ERROR)
                       || ELF_ST_VISIBILITY (h->root.other))))
                 return bfd_reloc_undefined;
               relocation = 0;
             }
         }
 
-      if (sec != NULL && elf_discarded_section (sec))
+      if (sec != NULL && discarded_section (sec))
         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
-                                         rel, relend, howto, contents);
+                                         rel, 1, relend, howto, 0, contents);
 
       if (info->relocatable)
         {
           /* This is a relocatable link.  We don't have to change
              anything, unless the reloc is against a section symbol,
              in which case we have to adjust according to where the
              section symbol winds up in the output section.  */
           if (r_symndx < symtab_hdr->sh_info)
             {
               sym = local_syms + r_symndx;
@@ skipping 428 matching lines @@
       if (!elf_hash_table (info)->dynamic_sections_created)
         return TRUE;
 
       /* If this symbol is not defined in a regular file, then set
          the symbol to the stub location.  This is required to make
          function pointers compare as equal between the normal
          executable and the shared library.  */
       if (!h->def_regular)
         {
           /* We need .stub section.  */
-          s = bfd_get_section_by_name (dynobj, SCORE_ELF_STUB_SECTION_NAME);
+          s = bfd_get_linker_section (dynobj, SCORE_ELF_STUB_SECTION_NAME);
           BFD_ASSERT (s != NULL);
 
           h->root.u.def.section = s;
           h->root.u.def.value = s->size;
 
           /* XXX Write this stub address somewhere.  */
           h->plt.offset = s->size;
 
           /* Make room for this stub code.  */
           s->size += SCORE_FUNCTION_STUB_SIZE;
@@ skipping 115 matching lines @@
   bfd_boolean reltext;
 
   dynobj = elf_hash_table (info)->dynobj;
   BFD_ASSERT (dynobj != NULL);
 
   if (elf_hash_table (info)->dynamic_sections_created)
     {
       /* Set the contents of the .interp section to the interpreter.  */
       if (!info->shared)
         {
-          s = bfd_get_section_by_name (dynobj, ".interp");
+          s = bfd_get_linker_section (dynobj, ".interp");
           BFD_ASSERT (s != NULL);
           s->size = strlen (ELF_DYNAMIC_INTERPRETER) + 1;
           s->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
         }
     }
 
   /* The check_relocs and adjust_dynamic_symbol entry points have
      determined the sizes of the various dynamic sections.  Allocate
      memory for them.  */
   reltext = FALSE;
@@ skipping 137 matching lines @@
 {
   struct elf_link_hash_entry *h;
   struct bfd_link_hash_entry *bh;
   flagword flags;
   asection *s;
 
   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
            | SEC_LINKER_CREATED | SEC_READONLY);
 
   /* ABI requests the .dynamic section to be read only.  */
-  s = bfd_get_section_by_name (abfd, ".dynamic");
+  s = bfd_get_linker_section (abfd, ".dynamic");
   if (s != NULL)
     {
       if (!bfd_set_section_flags (abfd, s, flags))
         return FALSE;
     }
 
   /* We need to create .got section.  */
   if (!score_elf_create_got_section (abfd, info, FALSE))
     return FALSE;
 
   if (!score_elf_rel_dyn_section (elf_hash_table (info)->dynobj, TRUE))
     return FALSE;
 
   /* Create .stub section.  */
-  if (bfd_get_section_by_name (abfd, SCORE_ELF_STUB_SECTION_NAME) == NULL)
+  if (bfd_get_linker_section (abfd, SCORE_ELF_STUB_SECTION_NAME) == NULL)
     {
-      s = bfd_make_section_with_flags (abfd, SCORE_ELF_STUB_SECTION_NAME,
-                                       flags | SEC_CODE);
+      s = bfd_make_section_anyway_with_flags (abfd, SCORE_ELF_STUB_SECTION_NAME,
+                                              flags | SEC_CODE);
       if (s == NULL
           || !bfd_set_section_alignment (abfd, s, 2))
 
         return FALSE;
     }
 
   if (!info->shared)
     {
       const char *name;
 
@@ skipping 33 matching lines @@
   dynobj = elf_hash_table (info)->dynobj;
 
   if (h->plt.offset != MINUS_ONE)
     {
       asection *s;
       bfd_byte stub[SCORE_FUNCTION_STUB_SIZE];
 
       /* This symbol has a stub.  Set it up.  */
       BFD_ASSERT (h->dynindx != -1);
 
-      s = bfd_get_section_by_name (dynobj, SCORE_ELF_STUB_SECTION_NAME);
+      s = bfd_get_linker_section (dynobj, SCORE_ELF_STUB_SECTION_NAME);
       BFD_ASSERT (s != NULL);
 
       /* FIXME: Can h->dynindex be more than 64K?  */
       if (h->dynindx & 0xffff0000)
         return FALSE;
 
       /* Fill the stub.  */
       score_bfd_put_32 (output_bfd, STUB_LW, stub);
       score_bfd_put_32 (output_bfd, STUB_MOVE, stub + 4);
       score_bfd_put_32 (output_bfd, STUB_LI16 | (h->dynindx << 1), stub + 8);
@@ skipping 58 matching lines @@
                                           struct bfd_link_info *info)
 {
   bfd *dynobj;
   asection *sdyn;
   asection *sgot;
   asection *s;
   struct score_got_info *g;
 
   dynobj = elf_hash_table (info)->dynobj;
 
-  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
+  sdyn = bfd_get_linker_section (dynobj, ".dynamic");
 
   sgot = score_elf_got_section (dynobj, FALSE);
   if (sgot == NULL)
     g = NULL;
   else
     {
       BFD_ASSERT (score_elf_section_data (sgot) != NULL);
       g = score_elf_section_data (sgot)->u.got_info;
       BFD_ASSERT (g != NULL);
     }
@@ skipping 909 matching lines @@
 
 #define bfd_elf32_bfd_reloc_type_lookup      elf32_score_reloc_type_lookup
 #define bfd_elf32_bfd_reloc_name_lookup \
   elf32_score_reloc_name_lookup
 #define bfd_elf32_bfd_link_hash_table_create elf32_score_link_hash_table_create
 #define bfd_elf32_bfd_print_private_bfd_data elf32_score_print_private_bfd_data
 #define bfd_elf32_bfd_merge_private_bfd_data elf32_score_merge_private_bfd_data
 #define bfd_elf32_new_section_hook           elf32_score_new_section_hook
 
 #include "elf32-target.h"