Merge GDB 7.5.1

bfd/elf64-sh64.c

 /* SuperH SH64-specific support for 64-bit ELF
    Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
-   2010, 2011 Free Software Foundation, Inc.
+   2010, 2011, 2012 Free Software Foundation, Inc.
 
    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
@@ skipping 1493 matching lines @@
 
           /* A local symbol never has STO_SH5_ISA32, so we don't need
              datalabel processing here.  Make sure this does not change
              without notice.  */
           if ((sym->st_other & STO_SH5_ISA32) != 0)
             ((*info->callbacks->reloc_dangerous)
              (info,
               _("Unexpected STO_SH5_ISA32 on local symbol is not handled"),
               input_bfd, input_section, rel->r_offset));
 
-          if (sec != NULL && elf_discarded_section (sec))
+          if (sec != NULL && discarded_section (sec))
             /* Handled below.  */
             ;
           else 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 (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
                 goto final_link_relocate;
@@ skipping 126 matching lines @@
             {
               if (! ((*info->callbacks->undefined_symbol)
                      (info, h->root.root.string, input_bfd,
                       input_section, rel->r_offset,
                       (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
                        || ELF_ST_VISIBILITY (h->other)))))
                 return FALSE;
             }
         }
 
-      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)
         continue;
 
       disp = (relocation
               - input_section->output_section->vma
               - input_section->output_offset
               - rel->r_offset);
       dropped = 0;
       switch ((int)r_type)
@@ skipping 113 matching lines @@
               || info->symbolic
               || h->dynindx == -1
               || h->plt.offset == (bfd_vma) -1
               || h->got.offset != (bfd_vma) -1)
             goto force_got;
 
           /* Relocation is to the entry for this symbol in the global
              offset table extension for the procedure linkage table.  */
           if (sgotplt == NULL)
             {
-              sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
+              sgotplt = bfd_get_linker_section (dynobj, ".got.plt");
               BFD_ASSERT (sgotplt != NULL);
             }
 
           relocation = (sgotplt->output_offset
                         + ((h->plt.offset / elf_sh64_sizeof_plt (info)
                             - 1 + 3) * 8));
 
           relocation -= GOT_BIAS;
 
           goto final_link_relocate;
 
         force_got:
         case R_SH_GOT_LOW16:
         case R_SH_GOT_MEDLOW16:
         case R_SH_GOT_MEDHI16:
         case R_SH_GOT_HI16:
         case R_SH_GOT10BY4:
         case R_SH_GOT10BY8:
           /* Relocation is to the entry for this symbol in the global
              offset table.  */
           if (sgot == NULL)
             {
-              sgot = bfd_get_section_by_name (dynobj, ".got");
+              sgot = bfd_get_linker_section (dynobj, ".got");
               BFD_ASSERT (sgot != NULL);
             }
 
           if (h != NULL)
             {
               bfd_vma off;
 
               off = h->got.offset;
               if (seen_stt_datalabel)
                 {
@@ skipping 73 matching lines @@
               else
                 {
                   bfd_put_64 (output_bfd, relocation, sgot->contents + off);
 
                   if (info->shared)
                     {
                       asection *s;
                       Elf_Internal_Rela outrel;
                       bfd_byte *loc;
 
-                      s = bfd_get_section_by_name (dynobj, ".rela.got");
+                      s = bfd_get_linker_section (dynobj, ".rela.got");
                       BFD_ASSERT (s != NULL);
 
                       outrel.r_offset = (sgot->output_section->vma
                                          + sgot->output_offset
                                          + off);
                       outrel.r_info = ELF64_R_INFO (0, R_SH_RELATIVE64);
                       outrel.r_addend = relocation;
                       loc = s->contents;
                       loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
                       bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
@@ skipping 14 matching lines @@
 
         case R_SH_GOTOFF_LOW16:
         case R_SH_GOTOFF_MEDLOW16:
         case R_SH_GOTOFF_MEDHI16:
         case R_SH_GOTOFF_HI16:
           /* Relocation is relative to the start of the global offset
              table.  */
 
           if (sgot == NULL)
             {
-              sgot = bfd_get_section_by_name (dynobj, ".got");
+              sgot = bfd_get_linker_section (dynobj, ".got");
               BFD_ASSERT (sgot != NULL);
             }
 
           /* Note that sgot->output_offset is not involved in this
              calculation.  We always want the start of .got.  If we
              defined _GLOBAL_OFFSET_TABLE in a different way, as is
              permitted by the ABI, we might have to change this
              calculation.  */
           relocation -= sgot->output_section->vma;
 
           relocation -= GOT_BIAS;
 
           addend = rel->r_addend;
 
           goto final_link_relocate;
 
         case R_SH_GOTPC_LOW16:
         case R_SH_GOTPC_MEDLOW16:
         case R_SH_GOTPC_MEDHI16:
         case R_SH_GOTPC_HI16:
           /* Use global offset table as symbol value.  */
 
           if (sgot == NULL)
             {
-              sgot = bfd_get_section_by_name (dynobj, ".got");
+              sgot = bfd_get_linker_section (dynobj, ".got");
               BFD_ASSERT (sgot != NULL);
             }
 
           relocation = sgot->output_section->vma;
 
           relocation += GOT_BIAS;
 
           addend = rel->r_addend;
 
           goto final_link_relocate;
@@ skipping 17 matching lines @@
           if (h->plt.offset == (bfd_vma) -1)
             {
               /* We didn't make a PLT entry for this symbol.  This
                  happens when statically linking PIC code, or when
                  using -Bsymbolic.  */
               goto final_link_relocate;
             }
 
           if (splt == NULL)
             {
-              splt = bfd_get_section_by_name (dynobj, ".plt");
+              splt = bfd_get_linker_section (dynobj, ".plt");
               BFD_ASSERT (splt != NULL);
             }
 
           relocation = (splt->output_section->vma
                         + splt->output_offset
                         + h->plt.offset);
           relocation++;
 
           addend = rel->r_addend;
 
@@ skipping 457 matching lines @@
         case R_SH_GOT_LOW16:
         case R_SH_GOT_MEDLOW16:
         case R_SH_GOT_MEDHI16:
         case R_SH_GOT_HI16:
         case R_SH_GOT10BY4:
         case R_SH_GOT10BY8:
           /* This symbol requires a global offset table entry.  */
 
           if (sgot == NULL)
             {
-              sgot = bfd_get_section_by_name (dynobj, ".got");
+              sgot = bfd_get_linker_section (dynobj, ".got");
               BFD_ASSERT (sgot != NULL);
             }
 
           if (srelgot == NULL
               && (h != NULL || info->shared))
             {
-              srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
+              srelgot = bfd_get_linker_section (dynobj, ".rela.got");
               if (srelgot == NULL)
                 {
-                  srelgot = bfd_make_section_with_flags (dynobj,
-                                                         ".rela.got",
-                                                         (SEC_ALLOC
-                                                          | SEC_LOAD
-                                                          | SEC_HAS_CONTENTS
-                                                          | SEC_IN_MEMORY
-                                                          | SEC_LINKER_CREATED
-                                                          | SEC_READONLY));
+                  flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
+                                    | SEC_IN_MEMORY | SEC_LINKER_CREATED
+                                    | SEC_READONLY);
+                  srelgot = bfd_make_section_anyway_with_flags (dynobj,
+                                                                ".rela.got",
+                                                                flags);
                   if (srelgot == NULL
                       || ! bfd_set_section_alignment (dynobj, srelgot, 2))
                     return FALSE;
                 }
             }
 
           if (h != NULL)
             {
               if (h->type == STT_DATALABEL)
                 {
@@ skipping 631 matching lines @@
   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
            | SEC_LINKER_CREATED);
 
   pltflags = flags;
   pltflags |= SEC_CODE;
   if (bed->plt_not_loaded)
     pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
   if (bed->plt_readonly)
     pltflags |= SEC_READONLY;
 
-  s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
+  s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
   if (s == NULL
       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
     return FALSE;
 
   if (bed->want_plt_sym)
     {
       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
          .plt section.  */
       struct elf_link_hash_entry *h;
       struct bfd_link_hash_entry *bh = NULL;
 
       if (! (_bfd_generic_link_add_one_symbol
              (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
               (bfd_vma) 0, (const char *) NULL, FALSE, bed->collect, &bh)))
         return FALSE;
 
       h = (struct elf_link_hash_entry *) bh;
       h->def_regular = 1;
       h->type = STT_OBJECT;
       elf_hash_table (info)->hplt = h;
 
       if (info->shared
           && ! bfd_elf_link_record_dynamic_symbol (info, h))
         return FALSE;
     }
 
-  s = bfd_make_section_with_flags (abfd,
-                                   bed->default_use_rela_p ? ".rela.plt" : ".rel.plt",
-                                   flags | SEC_READONLY);
+  s = bfd_make_section_anyway_with_flags (abfd,
+                                          bed->default_use_rela_p
+                                          ? ".rela.plt" : ".rel.plt",
+                                          flags | SEC_READONLY);
   if (s == NULL
       || ! bfd_set_section_alignment (abfd, s, ptralign))
     return FALSE;
 
   if (! _bfd_elf_create_got_section (abfd, info))
     return FALSE;
 
-  {
-    const char *secname;
-    char *relname;
-    flagword secflags;
-    asection *sec;
-
-    for (sec = abfd->sections; sec; sec = sec->next)
-      {
-        secflags = bfd_get_section_flags (abfd, sec);
-        if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
-            || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
-          continue;
-        secname = bfd_get_section_name (abfd, sec);
-        relname = (char *) bfd_malloc (strlen (secname) + 6);
-        strcpy (relname, ".rela");
-        strcat (relname, secname);
-        s = bfd_make_section_with_flags (abfd, relname,
-                                         flags | SEC_READONLY);
-        if (s == NULL
-            || ! bfd_set_section_alignment (abfd, s, ptralign))
-          return FALSE;
-      }
-  }
-
   if (bed->want_dynbss)
     {
       /* The .dynbss section is a place to put symbols which are defined
          by dynamic objects, are referenced by regular objects, and are
          not functions.  We must allocate space for them in the process
          image and use a R_*_COPY reloc to tell the dynamic linker to
          initialize them at run time.  The linker script puts the .dynbss
          section into the .bss section of the final image.  */
-      s = bfd_make_section_with_flags (abfd, ".dynbss",
-                                       SEC_ALLOC | SEC_LINKER_CREATED);
+      s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
+                                              SEC_ALLOC | SEC_LINKER_CREATED);
       if (s == NULL)
         return FALSE;
 
       /* The .rel[a].bss section holds copy relocs.  This section is not
          normally needed.  We need to create it here, though, so that the
          linker will map it to an output section.  We can't just create it
          only if we need it, because we will not know whether we need it
          until we have seen all the input files, and the first time the
          main linker code calls BFD after examining all the input files
          (size_dynamic_sections) the input sections have already been
          mapped to the output sections.  If the section turns out not to
          be needed, we can discard it later.  We will never need this
          section when generating a shared object, since they do not use
          copy relocs.  */
       if (! info->shared)
         {
-          s = bfd_make_section_with_flags (abfd,
-                                           (bed->default_use_rela_p
-                                            ? ".rela.bss" : ".rel.bss"),
-                                           flags | SEC_READONLY);
+          s = bfd_make_section_anyway_with_flags (abfd,
+                                                  (bed->default_use_rela_p
+                                                   ? ".rela.bss" : ".rel.bss"),
+                                                  flags | SEC_READONLY);
           if (s == NULL
               || ! bfd_set_section_alignment (abfd, s, ptralign))
             return FALSE;
         }
     }
 
   return TRUE;
 }
 
 
@@ skipping 35 matching lines @@
              object.  In such a case, we don't actually need to build
              a procedure linkage table, and we can just do a REL64
              reloc instead.  */
           BFD_ASSERT (h->needs_plt);
           return TRUE;
         }
 
       /* Make sure this symbol is output as a dynamic symbol.  */
       if (h->dynindx == -1)
         {