Merge GDB 7.5.1

bfd/elf32-cr16.c

 /* BFD back-end for National Semiconductor's CR16 ELF
-   Copyright 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+   Copyright 2007, 2008, 2009, 2010, 2012 Free Software Foundation, Inc.
    Written by M R Swami Reddy.
 
    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,
@@ skipping 565 matching lines @@
 static bfd_boolean
 _bfd_cr16_elf_create_got_section (bfd * abfd, struct bfd_link_info * info)
 {
   flagword   flags;
   asection * s;
   struct elf_link_hash_entry * h;
   const struct elf_backend_data * bed = get_elf_backend_data (abfd);
   int ptralign;
 
   /* This function may be called more than once.  */
-  if (bfd_get_section_by_name (abfd, ".got") != NULL)
+  if (bfd_get_linker_section (abfd, ".got") != NULL)
     return TRUE;
 
   switch (bed->s->arch_size)
     {
     case 16:
       ptralign = 1;
       break;
 
     case 32:
       ptralign = 2;
       break;
 
     default:
       bfd_set_error (bfd_error_bad_value);
       return FALSE;
     }
 
   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
            | SEC_LINKER_CREATED);
 
-  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, ptralign))
     return FALSE;
 
   if (bed->want_got_plt)
     {
-      s = bfd_make_section_with_flags (abfd, ".got.plt", flags);
+      s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
       if (s == NULL
           || ! bfd_set_section_alignment (abfd, s, ptralign))
         return FALSE;
     }
 
   /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
      (or .got.plt) section.  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.  */
   h = _bfd_elf_define_linkage_sym (abfd, info, s, "_GLOBAL_OFFSET_TABLE_");
@@ skipping 118 matching lines @@
         }
 
       switch (ELF32_R_TYPE (rel->r_info))
         {
         case R_CR16_GOT_REGREL20:
         case R_CR16_GOTC_REGREL20:
           /* 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->executable))
             {
-              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))
                     goto fail;
                 }
             }
 
           if (h != NULL)
             {
               if (h->got.offset != (bfd_vma) -1)
                 /* We have already allocated space in the .got.  */
@@ skipping 257 matching lines @@
               /* Check for range.  */
               if ((long) Rvalue > 0xfffff || (long) Rvalue < 0x0)
                return bfd_reloc_overflow;
 
             bfd_put_16 (input_bfd, ((bfd_get_16 (input_bfd, hit_data) & 0xfff0)
                         | ((Rvalue >> 16) & 0xf)), hit_data);
             bfd_put_16 (input_bfd, (Rvalue) & 0xffff, hit_data + 2);
           }
         else if (r_type == R_CR16_GOT_REGREL20) 
           {
-            asection * sgot = bfd_get_section_by_name (dynobj, ".got");
+            asection * sgot = bfd_get_linker_section (dynobj, ".got");
 
             if (h != NULL)
               {
                 bfd_vma off;
 
                 off = h->got.offset;
                 BFD_ASSERT (off != (bfd_vma) -1);
 
                 if (! elf_hash_table (info)->dynamic_sections_created
                      || SYMBOL_REFERENCES_LOCAL (info, h))
@@ skipping 28 matching lines @@
 
 
              bfd_put_16 (input_bfd, (bfd_get_16 (input_bfd, hit_data))
                          | (((Rvalue >> 16) & 0xf) << 8), hit_data);
              bfd_put_16 (input_bfd, (Rvalue) & 0xffff, hit_data + 2);
 
           }
         else if (r_type == R_CR16_GOTC_REGREL20)
           {
              asection * sgot;
-             sgot = bfd_get_section_by_name (dynobj, ".got");
+             sgot = bfd_get_linker_section (dynobj, ".got");
 
              if (h != NULL)
                {
                  bfd_vma off;
 
                  off = h->got.offset;
                  BFD_ASSERT (off != (bfd_vma) -1);
 
                   Rvalue >>=1; /* For code symbols.  */
 
@@ skipping 314 matching lines @@
       else
         {
           bfd_boolean unresolved_reloc, warned;
 
           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
                                    r_symndx, symtab_hdr, sym_hashes,
                                    h, sec, relocation,
                                    unresolved_reloc, warned);
         }
 
-      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;
 
       r = cr16_elf_final_link_relocate (howto, input_bfd, output_bfd,
                                         input_section,
                                         contents, rel->r_offset,
                                         relocation, rel->r_addend,
                                         (struct elf_link_hash_entry *) h,
                                         r_symndx,
@@ skipping 824 matching lines @@
       bfd_set_error (bfd_error_bad_value);
       return FALSE;
     }
 
   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
      .rel[a].bss sections.  */
 
   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
            | SEC_LINKER_CREATED);
 
-  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_cr16_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->executable)
         {
-          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 38 matching lines @@
           BFD_ASSERT (h->needs_plt);
           return TRUE;
         }
 
       /* Make sure this symbol is output as a dynamic symbol.  */
       if (h->dynindx == -1)
         {
           if (! bfd_elf_link_record_dynamic_symbol (info, h))
             return FALSE;
         }